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 9fd9a2a..4a0a36d 100644
Binary files a/libraries/zf_device/libzf_device_config.a and b/libraries/zf_device/libzf_device_config.a differ
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)                           	// 曝光时间         摄像头收到后会自动计算出最大曝光时间，如果设置过大则设置为计算出来的最大曝光值