spiflash数据模式

ThirstyBoyEager

现在例程里面的数据模式是字符char类型，我想改为float类型要改哪些参数？附相关代码如下：

/****************************************************************************/
/*                                                                          */
/*              读状态寄存器                                                */
/*                                                                          */
/****************************************************************************/
void StatusGet(void)
{
    tx_data[0] = SPI_FLASH_STATUS_RX;
    tx_len = rx_len = 2;
    SPIDat1Config(SOC_SPI_1_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
    SpiTransfer();
}

/****************************************************************************/
/*                                                                          */
/*              写使能                                                      */
/*                                                                          */
/****************************************************************************/
void WriteEnable(void)
{
    tx_data[0] = SPI_FLASH_WRITE_EN;
    tx_len = rx_len = 1;
    SPIDat1Config(SOC_SPI_1_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
    SpiTransfer();
}

/****************************************************************************/
/*                                                                          */
/*              忙检测                                                      */
/*                                                                          */
/****************************************************************************/
void IsFlashBusy(void)
{
    do{
         StatusGet();

      }while(rx_data[1] & WRITE_IN_PROGRESS);
}

/****************************************************************************/
/*                                                                          */
/*              扇区擦除                                                    */
/*                                                                          */
/****************************************************************************/
void SectorErase(void)
{
    tx_data[0] =  SPI_FLASH_SECTOR_ERASE;
    tx_data[1] =  SPI_FLASH_ADDR_MSB1;
    tx_data[2] =  SPI_FLASH_ADDR_MSB0;
    tx_data[3] =  SPI_FLASH_ADDR_LSB;

    tx_len = rx_len = 4;
    SPIDat1Config(SOC_SPI_1_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
    SpiTransfer();

    IsFlashBusy();
}

/****************************************************************************/
/*                                                                          */
/*              写扇区(256字节)                                             */
/*                                                                          */
/****************************************************************************/
void WritetoFlash(void)
{
    unsigned int index;

    tx_data[0] =  SPI_FLASH_PAGE_WRITE;
    tx_data[1] =  SPI_FLASH_ADDR_MSB1;
    tx_data[2] =  SPI_FLASH_ADDR_MSB0;
    tx_data[3] =  SPI_FLASH_ADDR_LSB;

    // 准备要写入的数据

    for (index = 10; index < 260; index++)
    {
        tx_data[index] =  index;
    }

    for(index = 4; index < 260; index++)
    {
         vrf_data[index] = index;
    }

    tx_len = rx_len = index;
    SPIDat1Config(SOC_SPI_1_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
    SpiTransfer();

    IsFlashBusy();
}

/****************************************************************************/
/*                                                                          */
/*              读数据                                                      */
/*                                                                          */
/****************************************************************************/
void ReadFromFlash(void)
{
    unsigned int index;

    tx_data[0] =  SPI_FLASH_READ;
    tx_data[1] =  SPI_FLASH_ADDR_MSB1;
    tx_data[2] =  SPI_FLASH_ADDR_MSB0;
    tx_data[3] =  SPI_FLASH_ADDR_LSB;

    // 情况变量
    for (index = 4; index < 260; index++)
    {
        tx_data[index] =  0;
    }

    tx_len = rx_len = index;
    SPIDat1Config(SOC_SPI_1_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
    SpiTransfer();
}

/****************************************************************************/
/*                                                                          */
/*              数据校验                                                    */
/*                                                                          */
/****************************************************************************/
int VerifyData(void)
{
    unsigned int index;

    for(index = 4; index < 260; index++)
    {
        if(vrf_data[index] != rx_data[index])
        {
            UARTPuts("\r\n", -1);
            UARTPuts("VerifyData: Comparing the data written to and read", -1);
            UARTPuts(" from Flash.\r\nThe two data blocks are unequal.", -1);
            UARTPuts(" Mismatch found at index ", -1);
            UARTPutNum((int)index - 3);
            UARTPuts("\r\n", -1);
                        UARTPuts("Verify Failed.\r\n", -1);
            return 0;
        }
    }

    if (index == 260)
    {
        UARTPuts("\r\nThe data in the Flash and the one written ", -1);
        UARTPuts("to it are equal.\r\n", -1);
                UARTPuts("Verify successfully.\r\n", -1);
        return 1;
    }

    return 0;
}

ThirstyBoyEager

/****************************************************************************/
/*                                                                          */
/*              SPI 中断初始化                                              */
/*                                                                          */
/****************************************************************************/
void SPIInterruptInit(void)
{
        // 注册中断服务函数
        IntRegister(C674X_MASK_INT4, SPIIsr);

        // 映射中断事件
        IntEventMap(C674X_MASK_INT4, SYS_INT_SPI1_INT);

        // 使能可屏蔽中断
        IntEnable(C674X_MASK_INT4);
}

/****************************************************************************/
/*                                                                          */
/*              SPI 初始化                                                                     */
/*                                                                          */
/****************************************************************************/
void SPIInit(void)
{
    unsigned char cs  = 0x01;
    unsigned char dcs = 0x01;
    unsigned int  val = SIMO_SOMI_CLK_CS;

    SPIReset(SOC_SPI_1_REGS);

    SPIOutOfReset(SOC_SPI_1_REGS);

    SPIModeConfigure(SOC_SPI_1_REGS, SPI_MASTER_MODE);

    SPIClkConfigure(SOC_SPI_1_REGS, 228000000, 20000000, SPI_DATA_FORMAT0);

    SPIPinControl(SOC_SPI_1_REGS, 0, 0, &val);

    SPIDefaultCSSet(SOC_SPI_1_REGS, dcs);

    // 配置 SPI 数据格式
    SPIDataFormatConfig(SPI_DATA_FORMAT0);

    // 配置 SPI 数据格式及片选信号
    SPIDat1Config(SOC_SPI_1_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), cs);

        // 映射中断到 INT1
    SPIIntLevelSet(SOC_SPI_1_REGS, SPI_RECV_INTLVL | SPI_TRANSMIT_INTLVL);

    // 使能 SPI
    SPIEnable(SOC_SPI_1_REGS);
}
/****************************************************************************/
/*                                                                          */
/*              配置 SPI 数据格式                                           */
/*                                                                          */
/****************************************************************************/
void SPIDataFormatConfig(unsigned int dataFormat)
{
    // 配置 SPI 时钟
    SPIConfigClkFormat(SOC_SPI_1_REGS,
                        (SPI_CLK_POL_HIGH | SPI_CLK_INPHASE),
                         dataFormat);

    // 配置 SPI 发送时 MSB 优先
    SPIShiftMsbFirst(SOC_SPI_1_REGS, dataFormat);

    // 设置字符长度
    SPICharLengthSet(SOC_SPI_1_REGS, CHAR_LENGTH, dataFormat);
}

/****************************************************************************/
/*                                                                          */
/*              SPI 传输                                                    */
/*                                                                          */
/****************************************************************************/
void SpiTransfer(void)
{
    p_tx = &tx_data[0];
    p_rx = &rx_data[0];
    SPIIntEnable(SOC_SPI_1_REGS, (SPI_RECV_INT | SPI_TRANSMIT_INT));
    while(flag);
    flag = 1;

    SPIDat1Config(SOC_SPI_1_REGS, SPI_DATA_FORMAT0, 0x1);
}

/****************************************************************************/
/*                                                                          */
/*              SPI 中断服务函数                                            */
/*                                                                          */
/****************************************************************************/
void SPIIsr(void)
{
    unsigned int intCode = 0;
    IntEventClear(SYS_INT_SPI1_INT);
    intCode = SPIInterruptVectorGet(SOC_SPI_1_REGS);

    while (intCode)
    {
        if(intCode == SPI_TX_BUF_EMPTY)
        {
            tx_len--;
            SPITransmitData1(SOC_SPI_1_REGS, *p_tx);
            p_tx++;
            if (!tx_len)
            {
                SPIIntDisable(SOC_SPI_1_REGS, SPI_TRANSMIT_INT);
            }
        }

        if(intCode == SPI_RECV_FULL)
        {
            rx_len--;
            *p_rx = (char)SPIDataReceive(SOC_SPI_1_REGS);
            p_rx++;
            if (!rx_len)
            {
                flag = 0;
                SPIIntDisable(SOC_SPI_1_REGS, SPI_RECV_INT);
            }
        }

        intCode = SPIInterruptVectorGet(SOC_SPI_1_REGS);
    }
}

希望缄默

强制类型转换试试