⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 drivers.c

📁 FREESCALE 提供的 ZIGBEE协议
💻 C
📖 第 1 页 / 共 2 页
字号:
                                                     */
    SPIWaitTransferDone();      /* For this bit to be set, SPTED MUST be set */
    SPIClearRecieveDataReg();   /* 
                                 * Clear receive data register. SPI 
                                 * entirely ready for read or write 
                                 */
    SPISendChar(u8Addr );       /*
                                 * Dummy write. Receive register of SPI 
                                 * will contain MSB
                                 */
    SPIWaitTransferDone();      /* 
                                 * For this bit to be set, SPTED MUST be 
                                 * set. Get MSB
                                 */
    SPIReadMSB();               /* MSB */
    SPISendChar(u8Addr);        /*
                                 * Dummy write. Waiting until after 
                                 * reading received data insures no 
                                 * overrun 
                                 */
    SPIWaitTransferDone();      /* 
                                 * For this bit to be set, SPTED MUST be 
                                 * set. Get LSB
                                 */
    SPIReadLSB();               /* LSB */
    DeAssertCE();               /* Disables MC13192 SPI */
    MC13192RestoreInterrupts(); /* Restore MC13192 interrupt status */
    return u16Data;
}

/*
 * SPIDrvRead2 : Read the second word from SPI
 *
 * Parameters : u8Addr - SPI address
 *
 * Return : u16Data -  u16Data[0] is the MSB, u16Data[1] is the LSB
 */
UINT16 SPIDrvRead2(UINT8 u8Addr)
{
    UINT8 u8TempValue;
    UINT16  u16Data;            /* u16Data[0] is MSB, u16Data[1] is LSB */

    SPIClearRecieveStatReg();  /* Clear status register (possible SPRF, SPTEF) */  
    SPIClearRecieveDataReg();  /* 
                                 * Clear receive data register. SPI entirely 
                                 * ready for read or write
                                 */                       
    MC13192DisableInterrupts(); /* Necessary to prevent double SPI access */
    AssertCE();                 /* Enables MC13192 SPI */
    SPISendChar((UINT8)((u8Addr & 0x3f) | 0x80));   /* Mask address, 6bit addr, Set 
                                                     * read bit. 
                                                     */
    SPIWaitTransferDone();      /* For this bit to be set, SPTED MUST be set */
    SPIClearRecieveDataReg();   /* 
                                 * Clear receive data register. SPI 
                                 * entirely ready for read or write 
                                 */
    SPISendChar(u8Addr );       /*
                                 * Dummy write. Receive register of SPI 
                                 * will contain MSB
                                 */
    SPIWaitTransferDone();      /* 
                                 * For this bit to be set, SPTED MUST be 
                                 * set. Get MSB
                                 */
    SPIReadMSB();               /* MSB */
    SPISendChar(u8Addr);             /*
                                       * Dummy write. Waiting until after 
                                       * reading received data insures no 
                                       * overrun 
                                       */
    SPIWaitTransferDone();            /* 
                                       * For this bit to be set, SPTED MUST be 
                                       * set. Get LSB
                                       */
    SPIReadLSB();               /* LSB */
    SPISendChar(u8Addr);             /*
                                       * Dummy write. Waiting until after 
                                       * reading received data insures no 
                                       * overrun 
                                       */
    SPIWaitTransferDone();            /* 
                                       * For this bit to be set, SPTED MUST be 
                                       * set. Get LSB
                                       */
    SPIReadMSB();               /* MSB */
    SPISendChar(u8Addr);             /*
                                       * Dummy write. Waiting until after 
                                       * reading received data insures no 
                                       * overrun 
                                       */
    SPIWaitTransferDone();            /* 
                                       * For this bit to be set, SPTED MUST be 
                                       * set. Get LSB
                                       */
    SPIReadLSB();               /* LSB */
    DeAssertCE();                     /* Disables MC13192 SPI */
    MC13192RestoreInterrupts();       /* Restore MC13192 interrupt status */
    return u16Data;
}


/*
 * RAMDrvWriteTx : Write a block of data to TX packet RAM, whichever is selected
 *
 * Parameters : length - Length of the block of data in bytes
 * *contents - Pointer to the data block
 *
 * Return : None
 */
void RAMDrvWriteTx(tTxPacket *psTxPkt)
{
    UINT8 i, u8TempByte, u8TempValue;   /* Temporary counters */ 
    UINT16  u16Reg;                     /* TX packet length register value */

    u16Reg = SPIDrvRead(TX_PKT_LEN);    /* 
                                         * Read the TX packet length register 
                                         * contents 
                                         */
    u16Reg = (0xFF80 & u16Reg) | (psTxPkt->u8DataLength + 4); /* 
                                                            * Mask out old 
                                                            * length setting and
                                                            * update. Add 2 for
                                                            * CRC and 2 for code bytes
                                                            */
    SPIDrvWrite(TX_PKT_LEN, u16Reg);    /* Update the TX packet length field */
    SPIClearRecieveStatReg();           /* Clear status register 
                                         * (possible SPRF, SPTEF) 
                                         */
    SPIClearRecieveDataReg();   /* 
                                 * Clear receive data register. SPI entirely
                                 * ready for read or write
                                 */                       
    MC13192DisableInterrupts(); /* Necessary to prevent double SPI access */
    AssertCE();                 /* Enables MC13192 SPI */
    SPISendChar(TX_PKT);        /* SPI TX ram data register */
    SPIWaitTransferDone();      /* 
                                 * For this bit to be set, SPTED MUST be set. 
                                 * Now write content MSB 
                                 */
    SPIClearRecieveDataReg();   /* 
                                 * Clear receive data register. SPI entirely 
                                 * ready for read or write
                                 */
    SPISendChar(0xFF);          /* Send 1st Code Byte */
    SPIWaitTransferDone();      /* 
                                 * For this bit to be set, SPTED MUST be set. 
                                 * Now write content MSB 
                                 */
    SPIClearRecieveDataReg();                                  
    SPISendChar(0x7E);          /* Send 2nd Code Byte */
    SPIWaitTransferDone();      /* 
                                 * For this bit to be set, SPTED MUST be set. 
                                 * Now write content MSB 
                                 */
    SPIClearRecieveDataReg();   /* 
                                 * Clear receive data register. SPI entirely 
                                 * ready for read or write
                                 */

    u8TempByte = 0;             /* Byte counter for *contents */
    /* Word loop. Round up. */ 
    for (i=0; i<((psTxPkt->u8DataLength+1) >> 1); i++) { 
        SPISendChar(psTxPkt->pu8Data[u8TempByte + 1]);  /* Write MSB */
        SPIWaitTransferDone();  /* 
                                 * For this bit to be set, SPTED MUST be set. 
                                 * Now write content LSB 
                                 */
        SPIClearRecieveDataReg();/* 
                                 * Clear receive data register. SPI entirely
                                 * ready for read or write
                                 */
        SPISendChar(psTxPkt->pu8Data[u8TempByte]);      /* Write LSB */          
        u8TempByte = (UINT8)(u8TempByte + 2);           /* Increment byte counter */
        SPIWaitTransferDone();  /* For this bit to be set, SPTED MUST be set.*/
        SPIClearRecieveDataReg();/* 
                                 * Clear receive data register. SPI entirely 
                                 * ready for read or write
                                 */
    }
    DeAssertCE();                   /* Disables MC13192 SPI */
    MC13192RestoreInterrupts();     /* Restore MC13192 interrupt status */
}


/*
 * RAMDrvReadRx : Read a block of data from RX packet RAM, whichever is selected
 *
 * Parameters : *length - Returned length of the block of data in bytes
 * *contents - Pointer to the data block storage
 *
 * Return : Status
 */
UINT8 RAMDrvReadRx(tRxPacket *psRxPkt)
{
    UINT8 i, u8TempByte;        /* Temporary counters. */
    UINT8 u8TempValue;          /* 
                                 * Used by SPIClearRecieveDataReg to 
                                 * flush SPI1D register during read
                                 */
    UINT8  u8Status = 0;        /* Holder for the return value */
    UINT16 u16RxLength;
  
    u16RxLength = SPIDrvRead(RX_PKT_LEN);   /* 
                                             * Read the RX packet length 
                                             * register contents 
                                             */
    u16RxLength &= 0x007F;          /* Mask out all but the RX packet length */

    /* MC13192 reports length with 2 CRC bytes and 2 Code bytes,
     * remove them. 
     */
    if (u16RxLength >= 5) {
        psRxPkt->u8DataLength = (UINT8)(u16RxLength - 4); /*
                                                           * Less byte code
                                                           * and CRC
                                                           */
    }
    else {
        psRxPkt->u8DataLength = 0;
    }
        
    if ((psRxPkt->u8DataLength >= 1) && \
        (psRxPkt->u8DataLength <= psRxPkt->u8MaxDataLength)) { /* 
                                                          * If <5, the packet 
                                                          * is garbage
                                                          */
        SPIClearRecieveStatReg();   /* Clear status register (SPRF, SPTEF) */  
        SPIClearRecieveDataReg();   /* 
                                     * Clear receive data register. 
                                     * SPI entirely ready for read or write
                                     */                       
        MC13192DisableInterrupts(); /* Necessary to prevent double SPI access */
        AssertCE();                 /* Enables MC13192 SPI */
        SPISendChar(RX_PKT | 0x80); /* SPI RX ram data register */
        SPIWaitTransferDone();      /* For this bit to be set, SPTED 
                                     * MUST be set.
                                     */
        SPIClearRecieveDataReg();   /* 
                                     * Clear receive data register. 
                                     * SPI entirely ready for read or write 
                                     */
        SPISendChar(u8TempValue);   /* 
                                     * Dummy write. Receive register of SPI will 
                                     * contain MSB garbage for first read 
                                     */
        SPIWaitTransferDone();      /* For this bit to be set, SPTED MUST be set.*/
        SPIClearRecieveDataReg();   /* 
                                     * Clear receive data register. 
                                     * SPI entirely ready for read or write 
                                     */
        SPISendChar(u8TempValue);   /* 
                                     * Dummy write. Receive register of SPI will 
                                     * contain LSB garbage for first read 
                                     */
        SPIWaitTransferDone();      /* For this bit to be set, SPTED MUST be set.*/
        SPIClearRecieveDataReg();   /* 
                                     * Clear receive data register. 
                                     * SPI entirely ready for read or write 
                                     */
                                    /* Byte codes */
        SPISendChar(u8TempValue);   /* 
                                     * Dummy write. Receive register of SPI will 
                                     * contain LSB garbage for first read 
                                     */
        SPIWaitTransferDone();      /* For this bit to be set, SPTED MUST be set.*/
        u8TempValue = SPIRead();    /* Read first code byte */
        SPISendChar(u8TempValue);   /* 
                                     * Dummy write. Receive register of SPI will 
                                     * contain LSB garbage for first read 
                                     */
        SPIWaitTransferDone();      /* For this bit to be set, SPTED MUST be set.*/
        u8TempValue = SPIRead();    /* Read second code byte */

                                     
        u8TempByte = 0;             /* Byte counter for *contents */
        /* Word loop. Round up. Deduct CRC. */
        for (i=0; i<((u16RxLength-1)>>1); i++) { 
            SPISendChar(u8TempValue);/* 
                                     * Dummy write. Receive register of SPI 
                                     * will contain MSB
                                     */
            SPIWaitTransferDone();  /* 
                                     * For this bit to be set, SPTED MUST be 
                                     * set. Get MSB
                                     */
            /* For a trailing garbage byte, just read and discard */
            if ((u8TempByte + 3) == u16RxLength) { 
                SPIClearRecieveDataReg();                  /* Discard */
            }
            else {
                psRxPkt->pu8Data[u8TempByte + 1] = SPIRead();   /* Read MSB */
            }
            SPISendChar(u8TempValue);/*
                                     * Dummy write. Receive register of SPI 
                                     * will contain LSB
                                     */
            SPIWaitTransferDone();  /* 
                                     * For this bit to be set, SPTED MUST be
                                     * set. Get LSB
                                     */
            psRxPkt->pu8Data[u8TempByte] = SPIRead();   /* Read LSB */
            u8TempByte = (UINT8)(u8TempByte + 2);       /* Increment byte counter */
        }
        DeAssertCE();               /* Disables MC13192 SPI */
        psRxPkt->u8Status = SUCCESS;
        MC13192RestoreInterrupts(); /* Restore MC13192 interrupt status */
    }
    /* Check to see if a larger packet than desired is received. */  
    if (psRxPkt->u8DataLength > psRxPkt->u8MaxDataLength) {
        psRxPkt->u8Status = OVERFLOW;
    }
    return u8Status;  
}

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -