Beispiel #1
0
static void nwkTxAckWaitTimerHandler(SYS_Timer_t *timer)
{
    if (0 == nwkTxActiveFrames)
        return;

    for (int i = 0; i < NWK_BUFFERS_AMOUNT; i++)
    {
        NwkFrame_t *frame = nwkFrameByIndex(i);

        if (NWK_TX_STATE_WAIT_ACK == frame->state && 0 == --frame->tx.timeout)
        {
            frame->state = NWK_TX_STATE_CONFIRM;
            frame->tx.status = NWK_NO_ACK_STATUS;
        }
    }

    SYS_TimerStart(timer);
}
Beispiel #2
0
void nwkTxAckReceived(NWK_DataInd_t *ind)
{
    NwkAckCommand_t *command = (NwkAckCommand_t *)ind->data;

    if (0 == nwkTxActiveFrames)
        return;

    for (int i = 0; i < NWK_BUFFERS_AMOUNT; i++)
    {
        NwkFrame_t *frame = nwkFrameByIndex(i);

        if (NWK_TX_STATE_WAIT_ACK == frame->state && frame->data.header.nwkSeq == command->seq)
        {
            frame->state = NWK_TX_STATE_CONFIRM;
            frame->tx.control = command->control;
            return;
        }
    }
}
void nwkSecurityTaskHandler(void)
{
  if (0 == nwkSecurityActiveFrames)
    return;

  if (nwkSecurityActiveFrame)
  {
    if (NWK_SECURITY_STATE_CONFIRM == nwkSecurityActiveFrame->state)
    {
      bool micStatus = nwkSecurityProcessMic();

      if (nwkSecurityEncrypt)
        nwkTxEncryptConf(nwkSecurityActiveFrame);
      else
        nwkRxDecryptConf(nwkSecurityActiveFrame, micStatus);

      nwkSecurityActiveFrame = NULL;
      --nwkSecurityActiveFrames;
    }
    else if (NWK_SECURITY_STATE_PROCESS == nwkSecurityActiveFrame->state)
    {
      nwkSecurityActiveFrame->state = NWK_SECURITY_STATE_WAIT;
      SYS_EncryptReq((uint8_t *)nwkSecurityVector, (uint8_t *)nwkIb.key);
    }

    return;
  }

  for (int i = 0; i < NWK_BUFFERS_AMOUNT; i++)
  {
    NwkFrame_t *frame = nwkFrameByIndex(i);

    if (NWK_SECURITY_STATE_ENCRYPT_PENDING == frame->state ||
        NWK_SECURITY_STATE_DECRYPT_PENDING == frame->state)
    {
      nwkSecurityActiveFrame = frame;
      nwkSecurityStart();
      return;
    }
  }
}
Beispiel #4
0
void nwkTxTaskHandler(void)
{
    if (0 == nwkTxActiveFrames)
        return;

    for (int i = 0; i < NWK_BUFFERS_AMOUNT; i++)
    {
        NwkFrame_t *frame = nwkFrameByIndex(i);

        switch (frame->state)
        {
#ifdef NWK_ENABLE_SECURITY
        case NWK_TX_STATE_ENCRYPT:
        {
            nwkSecurityProcess(frame, true);
        }
        break;
#endif

        case NWK_TX_STATE_SEND:
        {
            if (!PHY_Busy())
            {
                nwkTxPhyActiveFrame = frame;
                frame->state = NWK_TX_STATE_WAIT_CONF;
                PHY_DataReq((uint8_t *)&frame->data, frame->size);
            }
        }
        break;

        case NWK_TX_STATE_WAIT_CONF:
            break;

        case NWK_TX_STATE_SENT:
        {
            if (NWK_SUCCESS_STATUS == frame->tx.status)
            {
                if (frame->data.header.nwkSrcAddr == nwkIb.addr &&
                        frame->data.header.nwkFcf.ackRequest)
                {
                    frame->state = NWK_TX_STATE_WAIT_ACK;
                    frame->tx.timeout = NWK_ACK_WAIT_TIME / NWK_TX_ACK_WAIT_TIMER_INTERVAL + 1;
                    SYS_TimerStart(&nwkTxAckWaitTimer);
                }
                else
                {
                    frame->state = NWK_TX_STATE_CONFIRM;
                }
            }
            else
            {
                frame->state = NWK_TX_STATE_CONFIRM;
            }
        }
        break;

        case NWK_TX_STATE_WAIT_ACK:
            break;

        case NWK_TX_STATE_CONFIRM:
        {
#ifdef NWK_ENABLE_ROUTING
            nwkRouteFrameSent(frame);
#endif
            frame->tx.confirm(frame);
            --nwkTxActiveFrames;
        }
        break;

        default:
            break;
        };
    }
}