uint32_t app_fifo_write(app_fifo_t * p_fifo, uint8_t const * p_byte_array, uint32_t * p_size)
{
VERIFY_PARAM_NOT_NULL(p_fifo);
VERIFY_PARAM_NOT_NULL(p_size);
const uint32_t available_count = p_fifo->buf_size_mask - fifo_length(p_fifo) + 1;
const uint32_t requested_len = (*p_size);
uint32_t index = 0;
uint32_t write_size = MIN(requested_len, available_count);
(*p_size) = available_count;
// Check if the FIFO is FULL.
if (available_count == 0)
{
return NRF_ERROR_NO_MEM;
}
// Check if application has requested only the size.
if (p_byte_array == NULL)
{
return NRF_SUCCESS;
}
//Fetch bytes from the FIFO.
while (index < write_size)
{
fifo_put(p_fifo, p_byte_array[index++]);
}
(*p_size) = write_size;
return NRF_SUCCESS;
}
uint32_t app_fifo_read(app_fifo_t * p_fifo, uint8_t * p_byte_array, uint32_t * p_size)
{
VERIFY_PARAM_NOT_NULL(p_fifo);
VERIFY_PARAM_NOT_NULL(p_size);
const uint32_t byte_count = fifo_length(p_fifo);
const uint32_t requested_len = (*p_size);
uint32_t index = 0;
uint32_t read_size = MIN(requested_len, byte_count);
(*p_size) = byte_count;
// Check if the FIFO is empty.
if (byte_count == 0)
{
return NRF_ERROR_NOT_FOUND;
}
// Check if application has requested only the size.
if (p_byte_array == NULL)
{
return NRF_SUCCESS;
}
// Fetch bytes from the FIFO.
while (index < read_size)
{
fifo_get(p_fifo, &p_byte_array[index++]);
}
(*p_size) = read_size;
return NRF_SUCCESS;
}
uint32_t fifo_state(struct fifo_t *queue)
{
if (fifo_length(queue) == 0) {
return FIFO_EMPTY;
}
return FIFO_OK;
}
/* fifo_put -- insère un nouvel élément dans la file.
* Ne fait rien si la file est pleine.
* Complexité: O(1)
*/
void fifo_put(Fifo *fifo, void *item)
{
assert((fifo != NULL) && (fifo->items != NULL) && (item != NULL));
if (fifo_length(fifo) == fifo_max_size(fifo))
return;
fifo->items[fifo->newest++] = item;
if (fifo->newest == fifo->max_size) fifo->newest = 0;
}
int main()
{
struct fifo * list = fifo_create_thread_safe_fifo();
int i = 0;
/*pop empty queue*/
fifo_pop(list);
printf("length: %d\n",fifo_length(list));
for(;i<10;i++)
{
fifo_push(list,(void*)i);
}
printf("length: %d\n",fifo_length(list));
for(i=0;i<5;i++)
{
printf("%d\n",(int)fifo_pop(list));
}
printf("length: %d\n",fifo_length(list));
for(i=0;i<2;i++)
{
fifo_push(list,(void*)(i+10));
}
printf("length: %d\n",fifo_length(list));
for(i=0;i<7;i++)
{
printf("%d\n",(int)fifo_pop(list));
}
printf("length: %d\n",fifo_length(list));
for(i=0;i<2;i++)
{
fifo_push(list,(void*)(i+10));
}
printf("length: %d\n",fifo_length(list));
for(i=0;i<2;i++)
{
printf("%d\n",(int)fifo_pop(list));
}
printf("length: %d\n",fifo_length(list));
fifo_delete(list,NULL);
}
uint32_t fifo_pop(struct fifo_t *queue, uint8_t *el)
{
if (fifo_length(queue) == 0) {
return FIFO_EMPTY;
}
++queue->q_top;
if (queue->q_top == (queue->q_size - 1))
queue->q_top = 0;
*el = queue->q_data[queue->q_top];
return FIFO_OK;
}
uint32_t fifo_push(struct fifo_t *queue, uint8_t el)
{
if (fifo_length(queue) == queue->q_size) {
return FIFO_OVERFLOW;
}
++queue->q_end;
if (queue->q_end == (queue->q_size - 1))
queue->q_end = 0;
queue->q_data[queue->q_end] = el;
return FIFO_OK;
}
uint32_t app_fifo_write(app_fifo_t * p_fifo, uint8_t const * p_byte_array, uint32_t * p_size)
{
NULL_PARAM_CHECK(p_fifo);
NULL_PARAM_CHECK(p_size);
const uint32_t available_count = p_fifo->buf_size_mask - fifo_length(p_fifo) + 1;
const uint32_t requested_len = (*p_size);
uint32_t index = 0;
uint32_t write_size = 0;
(*p_size) = available_count;
// Check if the FIFO is FULL.
if (available_count == 0)
{
return NRF_ERROR_NO_MEM;
}
// Check if application has requested only the size.
if (p_byte_array == NULL)
{
(*p_size) = available_count;
return NRF_SUCCESS;
}
// Check is available bytes in FIFO less than requested.
if (requested_len < available_count)
{
write_size = requested_len;
}
else
{
write_size = available_count;
}
//Fetch bytes from the FIFO.
do
{
fifo_put(p_fifo, p_byte_array[index++]);
} while (index < write_size);
(*p_size) = write_size;
return NRF_SUCCESS;
}
uint32_t app_fifo_read(app_fifo_t * p_fifo, uint8_t * p_byte_array, uint32_t * p_size)
{
NULL_PARAM_CHECK(p_fifo);
NULL_PARAM_CHECK(p_size);
const uint32_t byte_count = fifo_length(p_fifo);
const uint32_t requested_len = (*p_size);
uint32_t index = 0;
uint32_t read_size = 0;
(*p_size) = byte_count;
// Check if the FIFO is empty.
if (byte_count == 0)
{
return NRF_ERROR_NOT_FOUND;
}
// Check if application has requested only the size.
if (p_byte_array == NULL)
{
(*p_size) = byte_count;
return NRF_SUCCESS;
}
// Check is available bytes in FIFO less than requested.
if (requested_len < byte_count)
{
read_size = requested_len;
}
else
{
read_size = byte_count;
}
// Fetch bytes from the FIFO.
do
{
fifo_get(p_fifo, &p_byte_array[index++]);
} while (index < read_size);
(*p_size) = read_size;
return NRF_SUCCESS;
}
void EssReceive(void)
{
if(BEnd.MicomUpdate_F==1)
{
Micom_Comm_Receive_Start_F=1;
}
else
{
#if 1
if(fifo_length()>0)
{
fifo_get(Rxd_result_buf);
Check_BERcvData();
}
#else
if(Micom_Comm_Receive_Start_F)
{
Micom_Comm_Receive_Bytes(Rxd_result_buf);
Check_BERcvData();
Micom_Comm_Receive_Start_F = 0;
}
#endif
}
}
/* fifo_full -- détermine si une liste est pleine (ie ne peut plus
* contenir d'éléments supplémentaires).
* Complexité: O(1);
*/
int fifo_full(Fifo *fifo)
{
assert(fifo != NULL);
return (fifo_length(fifo) == fifo_max_size(fifo));
}
/* fifo_empty -- détermine si une file est vide.
* Complexité: O(1)
*/
int fifo_empty(Fifo *fifo)
{
assert((fifo != NULL) && (fifo->items != NULL));
return fifo_length(fifo) == 0;
}
