This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

c6748 spi flash 数据模式转换



startware里面spiflash数据模式是字符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;
}

  • /****************************************************************************/
    /*                                                                          */
    /*              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);
        }
    }

  • 你可以先把数取下来,然后再转换