btl143/QDAC-firmware
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

同步逐飞库部分接口到v370版本

Browse Source
This commit is contained in:
bmy
2024-06-30 16:29:24 +08:00
parent 0f45c981a6
commit cb87de5508
4 changed files with 255 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

437
libraries/zf_common/zf_common_fifo.c
View File

@@ -34,6 +34,7 @@
********************************************************************************************************************/
#include "zf_common_debug.h"
#include "zf_common_fifo.h"
//-------------------------------------------------------------------------------------------------------------------
@@ -81,33 +82,26 @@ static void fifo_end_offset (fifo_struct *fifo, uint32 offset)
//-------------------------------------------------------------------------------------------------------------------
fifo_state_enum fifo_clear (fifo_struct *fifo)
{
zf_assert(fifo != NULL);
fifo_state_enum return_state = FIFO_SUCCESS;
zf_assert(NULL != fifo);
fifo_state_enum return_state = FIFO_SUCCESS; // 操作结果初值
do
{
if(FIFO_CLEAR & fifo->execution)
{
return_state = FIFO_CLEAR_UNDO;
break;
}
fifo->execution |= FIFO_CLEAR;
fifo->head = 0;
fifo->end = 0;
fifo->size = fifo->max;
// if(FIFO_IDLE != fifo->execution) // 判断是否当前 FIFO 是否空闲
// {
// return_state = FIFO_RESET_UNDO; // 重置操作未完成
// break;
// }
fifo->execution |= FIFO_RESET; // 重置操作置位
fifo->head = 0; // 重置 FIFO 所有数值复位
fifo->end = 0; // 重置 FIFO 所有数值复位
fifo->size = fifo->max; // 重置 FIFO 所有数值复位
switch(fifo->type)
{
case FIFO_DATA_8BIT:
memset(fifo->buffer, 0, fifo->max);
break;
case FIFO_DATA_16BIT:
memset(fifo->buffer, 0, fifo->max * 2);
break;
case FIFO_DATA_32BIT:
memset(fifo->buffer, 0, fifo->max * 4);
break;
case FIFO_DATA_8BIT: memset(fifo->buffer, 0, fifo->max); break;
case FIFO_DATA_16BIT: memset(fifo->buffer, 0, fifo->max * 2); break;
case FIFO_DATA_32BIT: memset(fifo->buffer, 0, fifo->max * 4); break;
}
// memset(fifo->buffer, 0, fifo->max);
fifo->execution &= ~FIFO_CLEAR;
fifo->execution = FIFO_IDLE; // 操作状态复位
}while(0);
return return_state;
}
@@ -122,7 +116,7 @@ fifo_state_enum fifo_clear (fifo_struct *fifo)
uint32 fifo_used (fifo_struct *fifo)
{
zf_assert(fifo != NULL);
return (fifo->max - fifo->size);
return (fifo->max - fifo->size); // 返回当前 FIFO 缓冲区中数据个数
}
//-------------------------------------------------------------------------------------------------------------------
@@ -135,40 +129,34 @@ uint32 fifo_used (fifo_struct *fifo)
//-------------------------------------------------------------------------------------------------------------------
fifo_state_enum fifo_write_element (fifo_struct *fifo, uint32 dat)
{
zf_assert(fifo != NULL);
fifo_state_enum return_state = FIFO_SUCCESS;
zf_assert(NULL != fifo);
fifo_state_enum return_state = FIFO_SUCCESS; // 操作结果初值
do
{
if(FIFO_WRITE & fifo->execution)
if((FIFO_RESET | FIFO_WRITE) & fifo->execution) // 不在写入与重置状态 避免写入竞争与指向错误
{
return_state = FIFO_WRITE_UNDO;
return_state = FIFO_WRITE_UNDO; // 写入操作未完成
break;
}
fifo->execution |= FIFO_WRITE;
fifo->execution |= FIFO_WRITE; // 写入操作置位
if(1 <= fifo->size) // 剩余空间足够装下本次数据
{
switch(fifo->type)
{
case FIFO_DATA_8BIT:
((uint8 *)fifo->buffer)[fifo->head] = dat;
break;
case FIFO_DATA_16BIT:
((uint16 *)fifo->buffer)[fifo->head] = dat;
break;
case FIFO_DATA_32BIT:
((uint32 *)fifo->buffer)[fifo->head] = dat;
break;
case FIFO_DATA_8BIT: ((uint8 *)fifo->buffer)[fifo->head] = dat; break;
case FIFO_DATA_16BIT: ((uint16 *)fifo->buffer)[fifo->head] = dat; break;
case FIFO_DATA_32BIT: ((uint32 *)fifo->buffer)[fifo->head] = dat; break;
}
fifo_head_offset(fifo, 1); // 头指针偏移
fifo->size -= 1; // 缓冲区剩余长度减小
}
else
{
return_state = FIFO_SPACE_NO_ENOUGH;
return_state = FIFO_SPACE_NO_ENOUGH; // 当前 FIFO 缓冲区满 不能再写入数据 返回空间不足
}
fifo->execution &= ~FIFO_WRITE;
fifo->execution &= ~FIFO_WRITE; // 写入操作复位
}while(0);
return return_state;
@@ -185,25 +173,25 @@ fifo_state_enum fifo_write_element (fifo_struct *fifo, uint32 dat)
//-------------------------------------------------------------------------------------------------------------------
fifo_state_enum fifo_write_buffer (fifo_struct *fifo, void *dat, uint32 length)
{
zf_assert(fifo != NULL);
fifo_state_enum return_state = FIFO_SUCCESS;
zf_assert(NULL != fifo);
fifo_state_enum return_state = FIFO_SUCCESS; // 操作结果初值
uint32 temp_length = 0;
do
{
if(NULL == dat)
{
return_state = FIFO_BUFFER_NULL;
return_state = FIFO_BUFFER_NULL; // 用户缓冲区异常
break;
}
if(FIFO_WRITE & fifo->execution)
if((FIFO_RESET | FIFO_WRITE) & fifo->execution) // 不在写入与重置状态 避免写入竞争与指向错误
{
return_state = FIFO_WRITE_UNDO;
return_state = FIFO_WRITE_UNDO; // 写入操作未完成
break;
}
fifo->execution |= FIFO_WRITE;
fifo->execution |= FIFO_WRITE; // 写入操作置位
if(length <= fifo->size) // 剩余空间足够装下本次数据
if(length <= fifo->size) // 剩余空间足够装下本次数据
{
temp_length = fifo->max - fifo->head; // 计算头指针距离缓冲区尾还有多少空间
@@ -212,6 +200,7 @@ fifo_state_enum fifo_write_buffer (fifo_struct *fifo, void *dat, uint32 length)
switch(fifo->type)
{
case FIFO_DATA_8BIT:
{
memcpy(
&(((uint8 *)fifo->buffer)[fifo->head]),
dat, temp_length); // 拷贝第一段数据
@@ -221,8 +210,9 @@ fifo_state_enum fifo_write_buffer (fifo_struct *fifo, void *dat, uint32 length)
&(((uint8 *)dat)[temp_length]),
length - temp_length); // 拷贝第二段数据
fifo_head_offset(fifo, length - temp_length); // 头指针偏移
break;
}break;
case FIFO_DATA_16BIT:
{
memcpy(
&(((uint16 *)fifo->buffer)[fifo->head]),
dat, temp_length * 2); // 拷贝第一段数据
@@ -232,8 +222,9 @@ fifo_state_enum fifo_write_buffer (fifo_struct *fifo, void *dat, uint32 length)
&(((uint16 *)dat)[temp_length]),
(length - temp_length) * 2); // 拷贝第二段数据
fifo_head_offset(fifo, length - temp_length); // 头指针偏移
break;
}break;
case FIFO_DATA_32BIT:
{
memcpy(
&(((uint32 *)fifo->buffer)[fifo->head]),
dat, temp_length * 4); // 拷贝第一段数据
@@ -243,7 +234,7 @@ fifo_state_enum fifo_write_buffer (fifo_struct *fifo, void *dat, uint32 length)
&(((uint32 *)dat)[temp_length]),
(length - temp_length) * 4); // 拷贝第二段数据
fifo_head_offset(fifo, length - temp_length); // 头指针偏移
break;
}break;
}
}
else
@@ -251,35 +242,36 @@ fifo_state_enum fifo_write_buffer (fifo_struct *fifo, void *dat, uint32 length)
switch(fifo->type)
{
case FIFO_DATA_8BIT:
{
memcpy(
&(((uint8 *)fifo->buffer)[fifo->head]),
dat, length); // 一次完整写入
fifo_head_offset(fifo, length); // 头指针偏移
break;
}break;
case FIFO_DATA_16BIT:
{
memcpy(
&(((uint16 *)fifo->buffer)[fifo->head]),
dat, length * 2); // 一次完整写入
fifo_head_offset(fifo, length); // 头指针偏移
break;
}break;
case FIFO_DATA_32BIT:
{
memcpy(
&(((uint32 *)fifo->buffer)[fifo->head]),
dat, length * 4); // 一次完整写入
fifo_head_offset(fifo, length); // 头指针偏移
break;
}break;
}
// memcpy(&fifo->buffer[fifo->head], dat, length); // 一次完整写入
// fifo_head_offset(fifo, length); // 头指针偏移
}
fifo->size -= length; // 缓冲区剩余长度减小
}
else
{
return_state = FIFO_SPACE_NO_ENOUGH;
return_state = FIFO_SPACE_NO_ENOUGH; // 当前 FIFO 缓冲区满 不能再写入数据 返回空间不足
}
fifo->execution &= ~FIFO_WRITE;
fifo->execution &= ~FIFO_WRITE; // 写入操作复位
}while(0);
return return_state;
@@ -296,50 +288,52 @@ fifo_state_enum fifo_write_buffer (fifo_struct *fifo, void *dat, uint32 length)
//-------------------------------------------------------------------------------------------------------------------
fifo_state_enum fifo_read_element (fifo_struct *fifo, void *dat, fifo_operation_enum flag)
{
zf_assert(fifo != NULL);
fifo_state_enum return_state = FIFO_SUCCESS;
zf_assert(NULL != fifo);
fifo_state_enum return_state = FIFO_SUCCESS; // 操作结果初值
do
{
if(NULL == dat)
{
return_state = FIFO_BUFFER_NULL;
break;
return_state = FIFO_BUFFER_NULL; // 用户缓冲区异常
}
fifo->execution |= FIFO_READ;
if(1 > fifo_used(fifo))
else
{
return_state = FIFO_DATA_NO_ENOUGH; // 标志数据不够
}
switch(fifo->type)
{
case FIFO_DATA_8BIT:
*((uint8 *)dat) = ((uint8 *)fifo->buffer)[fifo->end];
break;
case FIFO_DATA_16BIT:
*((uint16 *)dat) = ((uint16 *)fifo->buffer)[fifo->end];
break;
case FIFO_DATA_32BIT:
*((uint32 *)dat) = ((uint32 *)fifo->buffer)[fifo->end];
break;
}
if(flag == FIFO_READ_AND_CLEAN) // 如果选择读取并更改 FIFO 状态
{
if(FIFO_CLEAR & fifo->execution)
if((FIFO_RESET | FIFO_CLEAR) & fifo->execution) // 判断是否当前 FIFO 是否在执行清空或重置操作
{
return_state = FIFO_CLEAR_UNDO;
return_state = FIFO_READ_UNDO; // 读取操作未完成
break;
}
fifo->execution |= FIFO_CLEAR;
if(1 > fifo_used(fifo))
{
return_state = FIFO_DATA_NO_ENOUGH; // 缓冲区没有数据 返回数据长度不足
break; // 直接退出操作
}
fifo->execution |= FIFO_READ; // 读操作置位
switch(fifo->type)
{
case FIFO_DATA_8BIT: *((uint8 *)dat) = ((uint8 *)fifo->buffer)[fifo->end]; break;
case FIFO_DATA_16BIT: *((uint16 *)dat) = ((uint16 *)fifo->buffer)[fifo->end]; break;
case FIFO_DATA_32BIT: *((uint32 *)dat) = ((uint32 *)fifo->buffer)[fifo->end]; break;
}
fifo->execution &= ~FIFO_READ; // 读操作复位
}
if(FIFO_READ_AND_CLEAN == flag) // 如果选择读取并更改 FIFO 状态
{
if((FIFO_RESET | FIFO_CLEAR | FIFO_READ) == fifo->execution) // 不在 重置 清空 读取 状态 避免异常
{
return_state = FIFO_CLEAR_UNDO; // 清空操作未完成
break;
}
fifo->execution |= FIFO_CLEAR; // 清空作置位
fifo_end_offset(fifo, 1); // 移动 FIFO 头指针
fifo->size += 1;
fifo->execution &= ~FIFO_CLEAR;
fifo->size += 1; // 释放对应长度空间
fifo->execution &= ~FIFO_CLEAR; // 清空作复位
}
}while(0);
fifo->execution &= FIFO_READ;
return return_state;
}
@@ -356,78 +350,87 @@ fifo_state_enum fifo_read_element (fifo_struct *fifo, void *dat, fifo_operation_
//-------------------------------------------------------------------------------------------------------------------
fifo_state_enum fifo_read_buffer (fifo_struct *fifo, void *dat, uint32 *length, fifo_operation_enum flag)
{
zf_assert(fifo != NULL);
zf_assert(length != NULL);
fifo_state_enum return_state = FIFO_SUCCESS;
uint32 temp_length;
uint32 fifo_data_length;
zf_assert(NULL != fifo);
zf_assert(NULL != length);
fifo_state_enum return_state = FIFO_SUCCESS; // 操作结果初值
uint32 temp_length = 0;
uint32 fifo_data_length = 0;
do
{
if(NULL == dat)
{
return_state = FIFO_BUFFER_NULL;
break;
}
fifo->execution |= FIFO_READ;
fifo_data_length = fifo_used(fifo);
if(*length > fifo_data_length)
{
*length = fifo_data_length; // 纠正读取的长度
return_state = FIFO_DATA_NO_ENOUGH; // 标志数据不够
}
temp_length = fifo->max - fifo->end; // 计算尾指针距离缓冲区尾还有多少空间
if(*length <= temp_length) // 足够一次性读取完毕
{
switch(fifo->type)
{
case FIFO_DATA_8BIT:
memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->end]), *length);
break;
case FIFO_DATA_16BIT:
memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->end]), *length * 2);
break;
case FIFO_DATA_32BIT:
memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->end]), *length * 4);
break;
}
}
else
{
switch(fifo->type)
if((FIFO_RESET | FIFO_CLEAR) & fifo->execution) // 判断是否当前 FIFO 是否在执行清空或重置操作
{
case FIFO_DATA_8BIT:
memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->end]), temp_length);
memcpy(&(((uint8 *)dat)[temp_length]), fifo->buffer, *length - temp_length);
break;
case FIFO_DATA_16BIT:
memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->end]), temp_length * 2);
memcpy(&(((uint16 *)dat)[temp_length]), fifo->buffer, (*length - temp_length) * 2);
break;
case FIFO_DATA_32BIT:
memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->end]), temp_length * 4);
memcpy(&(((uint32 *)dat)[temp_length]), fifo->buffer, (*length - temp_length) * 4);
break;
}
}
if(flag == FIFO_READ_AND_CLEAN) // 如果选择读取并更改 FIFO 状态
{
if(FIFO_CLEAR & fifo->execution)
{
return_state = FIFO_CLEAR_UNDO;
*length = fifo_data_length; // 纠正读取的长度
return_state = FIFO_READ_UNDO; // 读取操作未完成
break;
}
fifo->execution |= FIFO_CLEAR;
fifo_data_length = fifo_used(fifo); // 获取当前数据有多少
if(*length > fifo_data_length) // 判断长度是否足够
{
*length = fifo_data_length; // 纠正读取的长度
return_state = FIFO_DATA_NO_ENOUGH; // 标志数据不够
if(0 == fifo_data_length) // 如果没有数据 就直接退出
{
fifo->execution &= ~FIFO_READ; // 读操作复位
break;
}
}
fifo->execution |= FIFO_READ; // 读操作置位
temp_length = fifo->max - fifo->end; // 计算尾指针距离缓冲区尾还有多少空间
if(*length <= temp_length) // 足够一次性读取完毕
{
switch(fifo->type)
{
case FIFO_DATA_8BIT: memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->end]), *length); break;
case FIFO_DATA_16BIT: memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->end]), *length * 2); break;
case FIFO_DATA_32BIT: memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->end]), *length * 4); break;
}
}
else
{
switch(fifo->type)
{
case FIFO_DATA_8BIT:
{
memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->end]), temp_length);
memcpy(&(((uint8 *)dat)[temp_length]), fifo->buffer, *length - temp_length);
}break;
case FIFO_DATA_16BIT:
{
memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->end]), temp_length * 2);
memcpy(&(((uint16 *)dat)[temp_length]), fifo->buffer, (*length - temp_length) * 2);
}break;
case FIFO_DATA_32BIT:
{
memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->end]), temp_length * 4);
memcpy(&(((uint32 *)dat)[temp_length]), fifo->buffer, (*length - temp_length) * 4);
}break;
}
}
fifo->execution &= ~FIFO_READ; // 读操作复位
}
if(FIFO_READ_AND_CLEAN == flag) // 如果选择读取并更改 FIFO 状态
{
if((FIFO_RESET | FIFO_CLEAR | FIFO_READ) == fifo->execution) // 不在 重置 清空 读取 状态 避免异常
{
return_state = FIFO_CLEAR_UNDO; // 清空操作未完成
break;
}
fifo->execution |= FIFO_CLEAR; // 清空作置位
fifo_end_offset(fifo, *length); // 移动 FIFO 头指针
fifo->size += *length;
fifo->execution &= ~FIFO_CLEAR;
fifo->size += *length; // 释放对应长度空间
fifo->execution &= ~FIFO_CLEAR; // 清空作复位
}
}while(0);
fifo->execution &= FIFO_READ;
return return_state;
}
@@ -446,77 +449,84 @@ fifo_state_enum fifo_read_buffer (fifo_struct *fifo, void *dat, uint32 *length,
//-------------------------------------------------------------------------------------------------------------------
fifo_state_enum fifo_read_tail_buffer (fifo_struct *fifo, void *dat, uint32 *length, fifo_operation_enum flag)
{
zf_assert(fifo != NULL);
zf_assert(length != NULL);
fifo_state_enum return_state = FIFO_SUCCESS;
uint32 temp_length;
uint32 fifo_data_length;
zf_assert(NULL != fifo);
zf_assert(NULL != length);
fifo_state_enum return_state = FIFO_SUCCESS; // 操作结果初值
uint32 temp_length = 0;
uint32 fifo_data_length = 0;
do
{
if(NULL == dat)
{
return_state = FIFO_BUFFER_NULL;
break;
}
fifo->execution |= FIFO_READ;
fifo_data_length = fifo_used(fifo);
if(*length > fifo_data_length)
{
*length = fifo_data_length; // 纠正读取的长度
return_state = FIFO_DATA_NO_ENOUGH; // 标志数据不够
}
if((fifo->head > fifo->end) || (fifo->head >= *length))
{
switch(fifo->type)
{
case FIFO_DATA_8BIT:
memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->head - *length]), *length);
break;
case FIFO_DATA_16BIT:
memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->head - *length]), *length * 2);
break;
case FIFO_DATA_32BIT:
memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->head - *length]), *length * 4);
break;
}
}
else
{
temp_length = *length - fifo->head; // 计算尾指针距离缓冲区尾还有多少空间
switch(fifo->type)
if((FIFO_RESET | FIFO_CLEAR | FIFO_WRITE) & fifo->execution) // 判断是否当前 FIFO 是否在执行清空或重置操作
{
case FIFO_DATA_8BIT:
memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->max - temp_length]), temp_length);
memcpy(&(((uint8 *)dat)[temp_length]), &(((uint8 *)fifo->buffer)[fifo->head - *length]), (*length - temp_length));
break;
case FIFO_DATA_16BIT:
memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->max - temp_length]), temp_length * 2);
memcpy(&(((uint16 *)dat)[temp_length]), &(((uint16 *)fifo->buffer)[fifo->head - *length]), (*length - temp_length) * 2);
break;
case FIFO_DATA_32BIT:
memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->max - temp_length]), temp_length * 4);
memcpy(&(((uint32 *)dat)[temp_length]), &(((uint32 *)fifo->buffer)[fifo->head - *length]), (*length - temp_length) * 4);
break;
}
}
if(flag == FIFO_READ_AND_CLEAN) // 如果选择读取并更改 FIFO 状态
{
if(FIFO_CLEAR & fifo->execution)
{
return_state = FIFO_CLEAR_UNDO;
*length = fifo_data_length; // 纠正读取的长度
return_state = FIFO_READ_UNDO; // 读取操作未完成
break;
}
fifo->execution |= FIFO_CLEAR;
fifo_end_offset(fifo, (fifo->max - fifo->size));
fifo->size = fifo->max;
fifo->execution &= ~FIFO_CLEAR;
fifo_data_length = fifo_used(fifo); // 获取当前数据有多少
if(*length > fifo_data_length) // 判断长度是否足够
{
*length = fifo_data_length; // 纠正读取的长度
return_state = FIFO_DATA_NO_ENOUGH; // 标志数据不够
if(0 == fifo_data_length) // 如果没有数据 就直接退出
{
fifo->execution &= ~FIFO_READ; // 读操作复位
break;
}
}
fifo->execution |= FIFO_READ; // 读操作置位
if((fifo->head > fifo->end) || (fifo->head >= *length))
{
switch(fifo->type)
{
case FIFO_DATA_8BIT: memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->head - *length]), *length); break;
case FIFO_DATA_16BIT: memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->head - *length]), *length * 2);break;
case FIFO_DATA_32BIT: memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->head - *length]), *length * 4);break;
}
}
else
{
temp_length = *length - fifo->head; // 计算尾指针距离缓冲区尾还有多少空间
switch(fifo->type)
{
case FIFO_DATA_8BIT:
{
memcpy(dat, &(((uint8 *)fifo->buffer)[fifo->max - temp_length]), temp_length);
memcpy(&(((uint8 *)dat)[temp_length]), &(((uint8 *)fifo->buffer)[fifo->head - *length]), (*length - temp_length));
}break;
case FIFO_DATA_16BIT:
{
memcpy(dat, &(((uint16 *)fifo->buffer)[fifo->max - temp_length]), temp_length * 2);
memcpy(&(((uint16 *)dat)[temp_length]), &(((uint16 *)fifo->buffer)[fifo->head - *length]), (*length - temp_length) * 2);
}break;
case FIFO_DATA_32BIT:
{
memcpy(dat, &(((uint32 *)fifo->buffer)[fifo->max - temp_length]), temp_length * 4);
memcpy(&(((uint32 *)dat)[temp_length]), &(((uint32 *)fifo->buffer)[fifo->head - *length]), (*length - temp_length) * 4);
}break;
}
}
fifo->execution &= ~FIFO_READ; // 读操作复位
}
if(FIFO_READ_AND_CLEAN == flag) // 如果选择读取并更改 FIFO 状态
{
if((FIFO_RESET | FIFO_CLEAR | FIFO_READ) == fifo->execution) // 不在 重置 清空 读取 状态 避免异常
{
return_state = FIFO_CLEAR_UNDO; // 清空操作未完成
break;
}
fifo_clear(fifo);
}
}while(0);
fifo->execution &= FIFO_READ;
return return_state;
}
@@ -533,22 +543,17 @@ fifo_state_enum fifo_read_tail_buffer (fifo_struct *fifo, void *dat, uint32 *len
//-------------------------------------------------------------------------------------------------------------------
fifo_state_enum fifo_init (fifo_struct *fifo, fifo_data_type_enum type, void *buffer_addr, uint32 size)
{
zf_assert(fifo != NULL);
fifo_state_enum return_value = FIFO_SUCCESS;
zf_assert(NULL != fifo);
fifo_state_enum return_state = FIFO_SUCCESS;
do
{
if(NULL == buffer_addr)
{
return_value = FIFO_BUFFER_NULL;
break;
}
fifo->buffer = buffer_addr;
fifo->execution = FIFO_IDLE;
fifo->type = type;
fifo->head = 0;
fifo->end = 0;
fifo->size = size;
fifo->max = size;
fifo->buffer = buffer_addr;
fifo->execution = FIFO_IDLE;
fifo->type = type;
fifo->head = 0;
fifo->end = 0;
fifo->size = size;
fifo->max = size;
}while(0);
return return_value;
return return_state;
}

56
libraries/zf_common/zf_common_fifo.h
View File

@@ -40,41 +40,52 @@
typedef enum
{
FIFO_SUCCESS,
FIFO_SUCCESS, // FIFO 操作成功
FIFO_WRITE_UNDO,
FIFO_CLEAR_UNDO,
FIFO_BUFFER_NULL,
FIFO_SPACE_NO_ENOUGH,
FIFO_DATA_NO_ENOUGH,
}fifo_state_enum;
FIFO_RESET_UNDO, // FIFO 重置操作未执行
FIFO_CLEAR_UNDO, // FIFO 清空操作未执行
FIFO_BUFFER_NULL, // FIFO 用户缓冲区异常
FIFO_WRITE_UNDO, // FIFO 写入操作未执行
FIFO_SPACE_NO_ENOUGH, // FIFO 写入操作 缓冲区空间不足
FIFO_READ_UNDO, // FIFO 读取操作未执行
FIFO_DATA_NO_ENOUGH, // FIFO 读取操作 数据长度不足
}fifo_state_enum; // FIFO 操作结果
// 操作逻辑
// 整体重置操作 将会强制清空 FIFO 谨慎使用
// 数据写入操作 不能在重置以及写入操作时进行
// 顺序读取操作 不能在清空和重置操作时进行
// 尾部读取操作 不能在清空和重置以及写入操作时进行
// 读取清空操作 不能在清空和重置以及读取操作时进行
// 这是为了防止中断嵌套导致数据混乱
typedef enum
{
FIFO_IDLE = 0x00, // 空闲状态
FIFO_RESET = 0x01, // 正在执行重置缓冲区
FIFO_CLEAR = 0x02, // 正在执行清空缓冲区
FIFO_WRITE = 0x04, // 正在执行写入缓冲区
FIFO_READ = 0x08, // 正在执行读取缓冲区
}fifo_execution_enum; // FIFO 操作状态 为嵌套使用预留 无法完全避免误操作
typedef enum
{
FIFO_IDLE = 0x00,
FIFO_CLEAR = 0x01,
FIFO_WRITE = 0x02,
FIFO_READ = 0x04,
}fifo_execution_enum;
typedef enum
{
FIFO_READ_AND_CLEAN,
FIFO_READ_ONLY,
FIFO_READ_AND_CLEAN, // FIFO 读操作模式 读取后清空释放对应缓冲区
FIFO_READ_ONLY, // FIFO 读操作模式 仅读取
}fifo_operation_enum;
typedef enum
{
FIFO_DATA_8BIT,
FIFO_DATA_16BIT,
FIFO_DATA_32BIT,
FIFO_DATA_8BIT, // FIFO 数据位宽 8bit
FIFO_DATA_16BIT, // FIFO 数据位宽 16bit
FIFO_DATA_32BIT, // FIFO 数据位宽 32bit
}fifo_data_type_enum;
typedef struct
typedef struct __attribute__((packed))
{
uint8 execution; // 执行步骤
fifo_data_type_enum type; // 数据类型
void *buffer; // 缓存指针
void *buffer; // 缓存指针
uint32 head; // 缓存头指针 总是指向空的缓存
uint32 end; // 缓存尾指针 总是指向非空缓存（缓存全空除外）
uint32 size; // 缓存剩余大小
@@ -93,4 +104,3 @@ fifo_state_enum fifo_read_tail_buffer (fifo_struct *fifo, void *dat, uint32 *l
fifo_state_enum fifo_init (fifo_struct *fifo, fifo_data_type_enum type, void *buffer_addr, uint32 size);
#endif

BIN
libraries/zf_device/libzf_device_config.a
View File

Binary file not shown.

2
libraries/zf_device/zf_device_mt9v03x_dvp.h
View File

@@ -95,7 +95,7 @@
#define MT9V03X_IMAGE_SIZE ( MT9V03X_W * MT9V03X_H ) // 整体图像大小不能超过 65535
#define MT9V03X_COF_BUFFER_SIZE ( 64 ) // 配置串口缓冲区大小 不低于 64
#define MT9V03X_AUTO_EXP_DEF (0 ) // 自动曝光设置 默认不开启自动曝光设置 范围 [0-63] 0 为关闭
#define MT9V03X_AUTO_EXP_DEF (0 ) // 自动曝光设置 默认不开启自动曝光设置 范围 [0-63] 0 为关闭
// 如果自动曝光开启 EXP_TIME 命令设置自动曝光时间的上限
// 一般情况是不需要开启自动曝光设置 如果遇到光线非常不均匀的情况可以尝试设置自动曝光，增加图像稳定性
#define MT9V03X_EXP_TIME_DEF (512) // 曝光时间 摄像头收到后会自动计算出最大曝光时间，如果设置过大则设置为计算出来的最大曝光值