怎样将数据从flash的缓存中读到MCU的函数呢

一、小型硬件系统固件该怎么写？

在没有嵌入式操作系统的时候，对于任务稍微多一点的硬件系统，比如这样一个小系统
任务包括：
1、模拟信号采集（使用MCU的ADC，或者专用的信号前端使用SPI/I2C通信）
2、数字信号处理（有各种各样的算法）
3、数据保存（SPI的Nandflash）
4、交互（蓝牙、USB)
5、调试打印（UART/RTT)
对于我来说就是中断+状态机

• 中断：很简单，任务多了肯定不能全在主循环做完，特别是硬件器件（如SPI, I2C, UART）操作时，不用中断几乎无法实现功能。
  所以像上面的小系统，有这样的优先级
  
  

[tr]任务优先级[/tr]

模拟信号采集	1（最高）
交互的中断级（比如蓝牙的Link layer）	2
数据保存的中断级（SPI传输）	3
调试打印	4
算法、交互的实现、数据保存的实现	5（主循环）

• 状态机：是很常用的方法，其实也很简单，就是给每个任务设一个状态，比如
  
  

[tr]状态操作[/tr]

蓝牙开始连接	初始化什么的
蓝牙保持连接	数据传输
蓝牙断开	其他一些造作
…	…

不管是硬件还是通信协议软件，都有自己的状态，针对不同状态做不同的事
中断+状态机 我们可以没有任何延时函数，遇到延时就改变状态，等到下次循环到了再处理这种状态来实现延时，其他时间就让系统进入休眠。这样的模式对于低功耗系统，特别是穿戴领域非常重要，想想又提高电池续航了
二、状态机越来越复杂？

利用状态机确实能够保证不用暴力延时了（比如循环计数100000次代表1ms延时），但是有没有想过，有些情况状态会越来越复杂。
以flash驱动为例：

• 第一次驱动实现
  对于flash至少需要读和写操作，同时由于flash的操作比较慢，需要要延时，那么这里就有了5种状态
  
  

[tr]状态说明[/tr]

空闲	没有任何读写操作时
开始读取	发送了参数，等待读取完成
读取完成
开始写入	发送了参数，等待写入完成
写入完成

• 第二次驱动实现：
  由于SPI通信也是需要时间的，硬件SPI通信直接用DMA实现，释放了CPU做其他事情，也降低了能耗。但是这样以来就多了另外两种状态：
  
  

[tr]状态[/tr]

SPI发送完成

SPI接受完成

• 第三次驱动实现：
  由于nandflash器件的特性，需要按叶读写擦除，在读写的时候nandflash有内部缓存，比如读取时先要将数据按页读到缓存中，在通过SPI读到MCU中。写也一样，需要先通过SPI写到缓存中，然后从缓存写到flash上。这些操作也是很高高延时，为实现数据可靠，我们仅仅加长状态延时会造成读写效率低下，为提高读写效率自然引入新的状态，也就是flash自己状态寄存器中的状态
  
  

[tr]状态[/tr]

flash读取到缓存完成

缓存写入到flash完成

flash块擦除完成

• 第四次驱动实现：
  要知道一个可靠的驱动，不但要保证能够得到需要的，而且要处理各种异常，让驱动程序快速恢复。现在我们来看，每种状态都可能会有异常，比如
     [tr]异常[/tr]
  

  flash读取到缓存失败

  缓存写入到flash失败

  SPI发送失败

  SPI接收失败

  擦除失败

  这里又涉及到了各种异常处理，还是nandflash重要的坏块管理
  
  

看起来整个驱动越来复杂，后面应用部分操作还会造成其他异常，这对于驱动维护非常伤脑筋了。
在这个时候想要是不用状态机，一件事情按顺序完成不就好了，简单明了好维护。但是想想这样就又回到了利用延时来做，单一任务倒是没问题，其他任务怎么办。正好嵌入式操作系统可以解决呀。

• 嵌入式操作系统，对于我们驱动来说那就是单一任务，对于其他任务也不会有影响。因为嵌入式操作系统的延时函数不是单纯的暴力延时，而是做任务切换。
  
  

三、嵌入式操作系统增加了开销，增加了功耗怎么办？

对于一般低功耗产品倒是可以基本接受，但是在穿戴领域和高计算量的情况，已经到了扣指令，恨不得C语言都不要用了直接用汇编的地步，这就成了困扰。
这个时候就在想有没有什么办法既可以让驱动单任务一直运行，又可以抛弃嵌入式操作系统的方法呢？
其实也可以实现，只要借鉴先嵌入式操作系统的实现原理，然后自己实现个任务切换功能就好了，至于其他的什么内存管理啊，任务调度算法什么的对于这个小小的硬件系统，真心用不上。
原理很简单，只要会一点汇编就OK了，利用一小小片内存：

• 一段内存 简单点就是几十个字节的全局数组就行了，在需要延时的时候，将相关的寄存器保存到这段内存中，当定时中断或者SPI的完成中断来了就还原寄存器继续往下执行驱动。
  
  

这里用三个特殊函数实现：
[tr]函数说明[/tr]

newModule	新建一个读或者写操作
suspendModule	挂起（等待SPI或者延时完成）
resumModule	恢复（SPI或者延时完成）

这样利用这三个函数，在一次操作时，
四、举个例子，将数据从flash的缓存中读到MCU的函数


int NandFlash_read_from_cache(uint32_t address, uint8_t *buffer, uint32_t len)
{
        //发送读取命令，也就是发送参数给硬件SPI器件
        len = spi_read(address, buffer, len);
        //进入挂起函数，等待完成
        suspendModule(STACK_SUSPEND);
        //到这里时一次读操作就已经完成了
        return len;
}       
   

这里的suspendModule函数应该怎么实现呢？

• 方法一、检查SPI硬件寄存器是否完成，像这样
  
  

void suspendModule(stackStatus_t status)
{
        while(true)
        {
                if(SPI->status|SPI_SEND_OK)
                        break;
        }
}


显然这样会一直占用CPU，无法低功耗，而且其他任务也不能运行。

• 方法二、使用嵌入式操作系统的延时函数，这里以freertos的vTaskDelay()为例
  
  

void suspendModule(stackStatus_t status)
{
        while(true)
        {
                if(SPI->status|SPI_SEND_OK)
                        break;
                vTaskDelay(1);
        }
}
这里vTaskDelay虽然也是延时，但是操作系统实际是切换任务去做其事情了，不会一直占用CPU。

• 方法三、感觉1ms的延时时间过长，使用信号量在中断时直接同步
  
  

void SPI_IRQHandler(void)
{
        static BaseType_t xHigherPriorityTaskWoken;
        xHigherPriorityTaskWoken = pdFALSE;
        // Unblock the task by releasing the semaphore.
        xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );
        portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
void suspendModule(stackStatus_t status)
{
        xSemaphoreTake(xSemaphore,portMAX_DELAY);
}

• 方法四、也就是改进型方法三
  为了避免操作系统庞大的开销，但是又想利用操作系统中单个任务实现方法，那就借用嵌入式操作系统的原理仅针对次任务做优化，像这样
  
  

void SPI_IRQHandler(void)
{
        resumModule();
}


int NandFlash_read_from_cache(uint32_t address, uint8_t *buffer, uint32_t num)
{
        //发送读取命令，也就是发送参数给硬件SPI器件
        int len = spi_read(address, buffer, num);
        //进入挂起函数，等待完成
        suspendModule(STACK_SUSPEND);
        //到这里时一次读操作就已经完成了
        return len;
}


__asm void suspendModule(stackStatus_t status)
{
        extern origin_sp;
        extern stack_index;
        extern stackStatus;
        extern driver_stack;
       
              PRESERVE8
              
              LDR  R1,=stackStatus
              STRB R0,[R1]
              LDR  R1,=origin_sp                //读取原始堆栈指针
              LDR  R0,[R1]
              MOV  R1,SP
              SUB  R0,R0,R1
              LDR  R1,=stack_index        //需要备份的堆栈字节数
              STRB R0,[R1]
                                                       
              //保存现场
              LDR   R1,=driver_stack
                          ADD   R0,R1,R0
                      STMIA R1!, {R4-R12,LR}        //子程序中的10个通用寄存器备份
                          B     suspendStart
suspendStatck POP   {R2}
              STR   R2,[R1,#4]!
suspendStart  CMP   R0,R1
              BGT   suspendStatck
         


              //返回
              DSB
              ISB
              POP  {R4-R12,PC}                //恢复之间入栈的通用寄存器
              ALIGN
}


__asm void resumModule(void)
{
        extern origin_sp;
        extern stack_index;
        extern driver_stack;
       
            PRESERVE8
       
            LDR   R1,=origin_sp
            STR   sp,[R1]
            PUSH {R4-R12,LR}
               
            LDR   R1,=stack_index
                        LDRB  R0,[R1]
            CBZ   R0,jobExit1
       
            //恢复现场
            LDR   R1,=driver_stack
                        ADD   R2,R1,R0
                        LDMIA R1!, {R4-R12,LR}
                        B     resumStart
resumStatck LDR   R0,[R2]
                        PUSH  {R0}
                        SUB   R2,R2,#4
resumStart        CMP   R2,R1
                        BGT   resumStatck
                                               
                        DSB
                        ISB
                        BX    LR
jobExit1    POP  {R4-R12,PC}
                        ALIGN
}
函数 suspendModule 做的就是将相关寄存器存入内存中，然后去完成其他任务。
函数resumModule做的就是在完成操作中断来临时，恢复相关寄存器，继续完成NandFlash_read_from_cache剩下的事。
可以看到，对于函数NandFlash_read_from_cache来说就是一次操作，使用者也不用考虑独占CPU其他任务不能使用的问题了。