/// Callback used by send function
typedef void (*EMAC_TxCallback)(unsigned int status); // EMAC_TxCallback - указатель на функцию, возвращающую void и принимающую unsigned int
typedef void (*EMAC_RxCallback)(unsigned int status); // EMAC_RxCallback - указатель на функцию, возвращающую void и принимающую unsigned int
typedef void (*EMAC_WakeupCallback)(void); //  EMAC_WakeupCallback - указатель на функцию, возвращающую void и принимающую void

    volatile EmacTxTDescriptor *pTxTd;
    volatile EMAC_TxCallback   *pTxCb;

if (rxTd.rxCb) {
            rxTd.rxCb(rxStatusFlag);
        }

            if (*pTxCb) {
                (*pTxCb)(txStatusFlag);
            }

        // Check the buffers
        while (CIRC_CNT(txTd.head, txTd.tail, TX_BUFFERS)) {
            pTxTd = txTd.td + txTd.tail;
            pTxCb = txTd.txCb + txTd.tail;

            // Exit if buffer has not been sent yet
            if ((pTxTd->status & EMAC_TX_USED_BIT) == 0) {
                break;
            }
            
            // Notify upper layer that packet has been sent
            if (*pTxCb) {
                (*pTxCb)(txStatusFlag);
            }
            
            CIRC_INC( txTd.tail, TX_BUFFERS );
        }

        // If a wakeup has been scheduled, notify upper layer that it can send
        // other packets, send will be successfull.
        if( (CIRC_SPACE(txTd.head, txTd.tail, TX_BUFFERS) >= txTd.wakeupThreshold)
         &&  txTd.wakeupCb) {
            txTd.wakeupCb();
        }

    // Инициализация дескриgторов передающего буфера.
    for(Index = 0; Index < TX_BUFFERS; Index++) {// Цикл по количеству передающих буферов
        // Инициализация адресов дескрипторов передающего буфера
        Address = (unsigned int)(&(pTxBuffer[Index * EMAC_TX_UNITSIZE]));
        txTd.td[Index].addr = Address; // Нет Маски, т.к. Слово 0 - адрес начала буфера
        txTd.td[Index].status = EMAC_TX_USED_BIT; // Установка для всех буферов бита used!!!
    }
    txTd.td[TX_BUFFERS - 1].status = EMAC_TX_USED_BIT | EMAC_TX_WRAP_BIT;

  static void irq_handler()
  {
    portBASE_TYPE xYieldRequired = pdFALSE;
    uint32_t status = AT91C_BASE_EMAC->EMAC_ISR;
    if ( status &  AT91C_EMAC_RCOMP)
    {
      xSemaphoreGiveFromISR(RxSem, &xYieldRequired);
    };
    portEND_SWITCHING_ISR(&xYieldRequired);
  }

if ( RxIndx->status & EMAC_RX_SOF_BIT )
          {
            ptr = static_cast<uint8_t*>(p->payload);
            flen =  0;
            sof  = ~0;
          };
          
          if ( sof )
.......................

//-----------------------------------------------------------------------------
/// Прием пакета:
// pFrame - Адрес области памяти, куда копировать фрейм;
// pFrame_Size - Адрес, где расположено значение размера принимаемого кадра
//-----------------------------------------------------------------------------
void EMAC_Receive_Frame(unsigned char *pFrame, unsigned int *pFrame_Size)
{
unsigned int Rx_Index_tmp = Rx_Index; // Локальный номер приемных буферов
unsigned char SOF_Enable = 0; // Обнаружен бит начала кадра SOF
unsigned char EOF_Enable = 0; // Обнаружен бит конца кадра EOF

unsigned int *Rx_Buffer_SOF = 0; // Адрес буфера с установленным битом начала кадра SOF

// Пока бит Ownership = 1 (буфер используется и в нем есть данные)
while (Rx_Descriptor[Rx_Index].addr & EMAC_RX_OWNERSHIP_BIT) {

// Перебераем все буферы, чтобы найти буфер с установленным битом
// Начала кадра EOF.

// Если буфер с установленым битом начала кадра SOF найден
// сбросить во всех дескрипторах предыдущих буферов бит Ownership:
if (Rx_Descriptor[Rx_Index_tmp].addr & EMAC_RX_SOF_BIT) {

// Сбросить предыдущий фрагмент кадра (буфер):
while (Rx_Index_tmp != Rx_Index) {
// Сбросить бит USED:
Rx_Descriptor[Rx_Index].addr &= ~(EMAC_RX_OWNERSHIP_BIT);

// Инкрементировать счетчик количества приемных буферов и,
// если он равен количеству приемных буферов - обнулить его:
if (++Rx_Index == RX_BUFFERS){
Rx_Index = 0; // Обнуление
}
}
// Найдено начало кадра:
SOF_Enable = 1;

// Запомнить адрес буфера с установленным битом начала кадра SOF
Rx_Buffer_SOF = (unsigned int)(&Rx_Buffer[Rx_Index_tmp]) & EMAC_ADDRESS_MASK; // Маска адреса;
}

if (Rx_Descriptor[Rx_Index_tmp].addr & EMAC_RX_EOF_BIT) {
// Найден конец кадра:
EOF_Enable = 0

// Запомнить размер кадра
*pFrame_Size = Rx_Descriptor[Rx_Index_tmp].status & EMAC_LENGTH_FRAME;
}


// Инкрементировать счетчик количества приемных буферов и,
// если он равен количеству приемных буферов - обнулить его:
if (++Rx_Index_tmp == RX_BUFFERS){
Rx_Index_tmp = 0; // Обнуление
}
}

// Eсли обнаружены биты начала кадра и конца кадра, копировать данные
// из буфера в память:
if (SOF_Enable && EOF_Enable) {
memcpy(pFrame, Rx_Buffer_SOF, *pFrame_Size);
}

// Обнуление счетчика приемных буферов
Rx_Index = 0;

// Сбросить бит Ownership во всех дескрипторах:
while (Rx_Index != RX_BUFFERS) { //

// Сбросить бит USED:
Rx_Descriptor[Rx_Index].addr &= ~(EMAC_RX_OWNERSHIP_BIT);

// Инкрементировать счетчик приемных буферов
Rx_Index++;
}
// Обнуление счетчика приемных буферов
Rx_Index = 0;

} // End While
} // End Function