ftrfhub.c

用cypress的3721芯片做的无线中心结点c代码

    // Back Channel Data - Get data, format to SNP struct and send it to node.
    // -----------------------------------------------------------------------
    case SEND_PKT:
        status = STATUS_FAILURE;

        sTestTxPkt.devId  = I2CBuffer[1];
        sTestTxPkt.length = I2CBuffer[2] & OPTION_LEN_MSK;
        sTestTxPkt.type   = CYFISNP_API_TYPE_CONF_BCDR;
        showI2C_Buffer("\r\nI2C Rx:", sTestTxPkt.length + 3);

        // Sanity check: Packet small enough and Device is bound
        if (sTestTxPkt.length <= CYFISNP_BCD_PAYLOAD_MAX
        && (CYFISNP_EEP_DEV_REC_ADR+sTestTxPkt.devId)->devId != 0)
        {
            for (ivar=0; ivar != sTestTxPkt.length; ++ivar)
            {
                sTestTxPkt.payload[ivar] = I2CBuffer[3 + ivar];
            }

            if (CYFISNP_TxDataPend(sTestTxPkt.devId) == FALSE   // If no TxPend
            || (I2CBuffer[2]&OPTION_FLUSH_MSK) != 0)            // || Force
            {
                if (CYFISNP_TxDataPut(&sTestTxPkt) == TRUE)
                {
                    status = STATUS_SUCCESS;
                }
            }
        }

        I2CBuffer[1] = status;
        showI2C_Buffer(" Tx:", 2);
        I2CBuffer[RESPONSE_BYTE] = SEND_PKT_RSP;
        break;

    // -----------------------------------------------------------------------
    // Get specific Node's MID (if requested devID = 0 then return Hub's MID).
    // -----------------------------------------------------------------------
    case GET_NODE_CFG:
        showI2C_Buffer("\r\nI2C Rx:", 2);

        devId = I2CBuffer[1];   // Get the device ID from the I2C command
        if (CYFISNP_LookupMid(&I2CBuffer[2], devId))
        {
            I2CBuffer[1] = STATUS_SUCCESS;
            I2CBuffer[6] = CYFISNP_TxDataPend(devId);
        }
        else
        {
            I2CBuffer[1] = STATUS_FAILURE;
        }
        I2CBuffer[RESPONSE_BYTE] = GET_NODE_CFG_RSP;
        showI2C_Buffer(" Tx:", 7);
        break;

    // -----------------------------------------------------------------------
    // Unbind specific device.
    // -----------------------------------------------------------------------
    case UNBIND_NODE:
        showI2C_Buffer("\r\nI2C Rx:", 2);
        devId = I2CBuffer[1];

        if (devId == 0xFF)
        {
            for (ivar=1; ivar <= NETWORK_SIZE; ++ivar)
                CYFISNP_UnbindDevId(ivar);

            I2CBuffer[1] = STATUS_SUCCESS;
        }
        else
        {
            I2CBuffer[1] = CYFISNP_UnbindDevId(devId);
        }

        I2CBuffer[RESPONSE_BYTE] = UNBIND_NODE_RSP;
        showI2C_Buffer(" Tx:", 2);
        break;

    // -----------------------------------------------------------------------
    // Enter Bind Mode
    // -----------------------------------------------------------------------
    case ENTER_BIND_MODE:
        showI2C_Buffer("\r\nI2C Rx:", 1);
        bindNodeId = 0;                 // Default to no bind result
        bindRetryCt = 1;                // Try two bind cycles
        CYFISNP_BindStart();
        I2CBuffer[1] = STATUS_SUCCESS;

        I2CBuffer[RESPONSE_BYTE] = ENTER_BIND_MODE_RSP;
        showI2C_Buffer(" Tx:", 1);
        break;

    // -----------------------------------------------------------------------
    // Report Bind State {active, bound, timeout}
    // -----------------------------------------------------------------------
    case GET_LAST_BIND_RESULT:
        showI2C_Buffer("\r\nI2C Rx:", 1);
        if (CYFISNP_eProtState == CYFISNP_BIND_MODE)
        {
            I2CBuffer[1] = IN_BIND_MODE;
        }
        else if (bindNodeId != 0)
        {
            I2CBuffer[1] = NOT_IN_BIND_MODE;
            I2CBuffer[2] = bindNodeId;
        }
        else
        {
            I2CBuffer[1] = BIND_TIMEOUT;
        }
        I2CBuffer[RESPONSE_BYTE] = GET_LAST_BIND_RESULT_RSP;
        showI2C_Buffer(" Tx:", 3);
        break;

        // -----------------------------------------------------------------------
    default:
        break;
    }
}


//----------------------------------------------------------------------------
//
// SendBackChannelData() = Copnstruct back channel data to send to node.
//
//Variables:
//        sTestTxPkt - instantiation of CYFISNP_API_PKT. Used so data can be
//                     put in the defined structure by SNP
//
//----------------------------------------------------------------------------
void SendBackChannelData(BYTE devId)
{

    sTestTxPkt.length = CYFISNP_BCD_PAYLOAD_MAX;
    sTestTxPkt.type   = CYFISNP_API_TYPE_CONF;
    sTestTxPkt.devId  = devId;

    sTestTxPkt.payload[1] = 0x2A;
    sTestTxPkt.payload[2] = 0x0E;
    sTestTxPkt.payload[3] = 0x4C;
    sTestTxPkt.payload[4] = 0x8F;
    sTestTxPkt.payload[5] = 0x7D;
    //Hand off to protocol
}


void WriteBufferManager(void)
{
    numberOfPacketsInBuffer++;          // increment packet count

    BufferManagement();                 // call buffer management to check for full or empty condition

    pNextWrite++;                       // increment next write pointer

}

void ReadBufferManager()
{
    numberOfPacketsInBuffer--;

    pNextRead++;                        // update read pointer, and call application memory management

    BufferManagement();

}

//-------------------------------------------------------------------------------
//
//  BufferManagement() - Manage pointers to make sure they wrap around.
//
//--------------------------------------------------------------------------------
void BufferManagement()
{
    if (pNextRead == pEnd)
    {
        pNextRead = pBeg;
    }

    if (numberOfPacketsInBuffer == 0)
    {
        pNextWrite = &App_Buff[0];
        pNextRead = &App_Buff[0];
    }

    if (numberOfPacketsInBuffer == MAX_BUFF_PKTS)
    {
        CYFISNP_OutStr("\r\n<Buffer Overflow>");
    }

    if ((pNextWrite == pEnd) && (numberOfPacketsInBuffer != MAX_BUFF_PKTS ))
    {
        pNextWrite = pBeg;              //Reset to beggining of Buffer
    }

    if (pNextRead == pEnd)
    {
        pNextRead = pBeg;               //Reset to beggining of buffer
    }
}

// ---------------------------------------------------------------------------
//
// showLeds() - Run the RED LED showDevRecords
//
// ---------------------------------------------------------------------------
static void showLeds(void)
{
    static CYFISNP_PROT_STATE eProtStateOld;

    if (eProtStateOld != CYFISNP_eProtState) {
        eProtStateOld  = CYFISNP_eProtState;
        switch (CYFISNP_eProtState) {
        case CYFISNP_BIND_MODE:
            CYFISNP_OutStr("<BIND_MODE>");
            LED_GREEN_On();
            break;
        case CYFISNP_DATA_MODE:
            CYFISNP_OutStr("<DATA_MODE>");
            LED_GREEN_Off();
            break;
        case CYFISNP_PING_MODE:
            CYFISNP_OutStr("<PING_MODE>");
            LED_GREEN_Off();
            break;
        default:
            CYFISNP_OutStr("<???_MODE>");
            break;
        }
    }

    // -----------------------------------------------------------------------
    // Blink Rx/Tx data LED
    // -----------------------------------------------------------------------
    if (LED_GREEN_GetState() && CYFISNP_eProtState != CYFISNP_BIND_MODE) {
        if (CYFISNP_TimeExpired(&greenLedTimer) == TRUE) {
            LED_GREEN_Off();
        }
    }

    // -----------------------------------------------------------------------
    // Finish I2C LED Pulse as needed
    // -----------------------------------------------------------------------
    if (numberOfPacketsInBuffer == MAX_BUFF_PKTS) {
        LED_RED_On();                   // LED SOLID ON at buffer overflow
    }
    else if (LED_RED_GetState() && CYFISNP_TimeExpired(&ledI2cPulseTimer))
    {
        LED_RED_Off();
    }
}

#ifdef CYFISNP_DEBUG
// ---------------------------------------------------------------------------
// showDevRecords() Display device and mid table
// ---------------------------------------------------------------------------
static void showDevRecords(void) {
    char ivar;
    char jvar;
    char devId;

    CYFISNP_OutStr("\r\nDEV PinDev FLG MID");
    for (ivar=1; ivar <= CYFISNP_MAX_NODES; ++ivar)
    {
        devId = (CYFISNP_EEP_DEV_REC_ADR+ivar)->devId;
        if (devId != 0)
        {
            CYFISNP_OutStr("\r\n");
            CYFISNP_OutHex(devId);                                  CYFISNP_OutStr(",  ");
            CYFISNP_OutHex((CYFISNP_EEP_DEV_REC_ADR+devId)->devId); CYFISNP_OutStr(",   ");
            CYFISNP_OutHex((CYFISNP_EEP_DEV_REC_ADR+devId)->flg);   CYFISNP_OutStr(" ");

            for (jvar=0; jvar < CYFISNP_SIZEOF_MID; ++jvar)
            {
                CYFISNP_OutChar(' ');
                CYFISNP_OutHex((CYFISNP_EEP_DEV_REC_ADR+devId)->devMid[jvar]);
            }
            if (ivar != devId)
            {
                CYFISNP_OutStr(" <-- ??? Device ID wrong");
            }
        }
    }
    CYFISNP_OutStr("\r\n");
}
#endif