From cb87de5508c429c7de02dcb410d4031096ac6663 Mon Sep 17 00:00:00 2001 From: bmy <2583236812@qq.com> Date: Sun, 30 Jun 2024 16:29:24 +0800 Subject: [PATCH] =?UTF-8?q?=E5=90=8C=E6=AD=A5=E9=80=90=E9=A3=9E=E5=BA=93?= =?UTF-8?q?=E9=83=A8=E5=88=86=E6=8E=A5=E5=8F=A3=E5=88=B0v370=E7=89=88?= =?UTF-8?q?=E6=9C=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- libraries/zf_common/zf_common_fifo.c | 437 ++++++++++---------- libraries/zf_common/zf_common_fifo.h | 56 +-- libraries/zf_device/libzf_device_config.a | Bin 55532 -> 55092 bytes libraries/zf_device/zf_device_mt9v03x_dvp.h | 2 +- 4 files changed, 255 insertions(+), 240 deletions(-) diff --git a/libraries/zf_common/zf_common_fifo.c b/libraries/zf_common/zf_common_fifo.c index 7021b67..714138a 100644 --- a/libraries/zf_common/zf_common_fifo.c +++ b/libraries/zf_common/zf_common_fifo.c @@ -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; } diff --git a/libraries/zf_common/zf_common_fifo.h b/libraries/zf_common/zf_common_fifo.h index 32c6a60..8397edc 100644 --- a/libraries/zf_common/zf_common_fifo.h +++ b/libraries/zf_common/zf_common_fifo.h @@ -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 - diff --git a/libraries/zf_device/libzf_device_config.a b/libraries/zf_device/libzf_device_config.a index 9fd9a2a37ecd05b17cb1295a7f128d284d7d9b0c..4a0a36d76e6659cd7e3cd1705dc94955247fc9be 100644 GIT binary patch delta 13147 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 X!%8cguTGAd(ILb#=w)oGx7z+6`I?SK delta 13499 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 JlA}IO_&+< diff --git a/libraries/zf_device/zf_device_mt9v03x_dvp.h b/libraries/zf_device/zf_device_mt9v03x_dvp.h index 7598d94..c81d278 100644 --- a/libraries/zf_device/zf_device_mt9v03x_dvp.h +++ b/libraries/zf_device/zf_device_mt9v03x_dvp.h @@ -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) // 曝光时间 摄像头收到后会自动计算出最大曝光时间，如果设置过大则设置为计算出来的最大曝光值