Part Number: PROCESSOR-SDK-C665X
Tool/software:
Hello: Attached is the main.c file from my end. I've made several modifications to the data read and write functions for the SPI flash with large capacity bytes, but errors persist. Could you please help identify and modify the code?
The main function calls interfaces for reading and writing 256-byte data and a custom interface for reading and writing large capacity data. Reading and writing 256-byte data is successful. However, there is a verification inconsistency when reading and writing multiple pages of data (large capacity data). Initially, the analysis suggests the issue lies in the address during read and write operations. During the flash_tx_data[0] = SPI_FLASH_PAGE_WRITE; stage, the issue may be originating from there."
flash_tx_data[1] = SPI_FLASH_ADDR_MSB1;
flash_tx_data[2] = SPI_FLASH_ADDR_MSB0;
flash_tx_data[3] = SPI_FLASH_ADDR_LSB | (page<< 8);
Despite several attempts to debug by adjusting the address offset in these four lines of code, I still haven't succeeded. Could you please help me out?(╥﹏╥)o
/****************************************************************************/
/* CSL Header file */
#include <ti/csl/cslr_device.h>
#include <ti/csl/csl_pscAux.h>
#include <ti/csl/csl_chipAux.h>
#include <ti/csl/csl_bootcfgAux.h>
#include <ti/csl/soc.h>
/* Compiler Header files */
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <ti/dsplib/src/DSPF_sp_w_vec/c66/DSPF_sp_w_vec.h>
#include <ti/dsplib/src/DSPF_sp_dotprod/c66/DSPF_sp_dotprod.h>
/* Platform utilities include */
#include "system/platform.h"
/* Driver utilities include */
#include "driver/c66x_gpio.h"
#include "hw_types.h"
#include "hw_emifa2.h"
#include "soc_C665x.h"
#include "uart.h"
#include "emifa.h"
#include "spi.h"
#include "gpio.h"
#include "interrupt.h"
#include "cic_event.h"
#include "timer.h"
#include "Board.h" // board drive header file
// privite header file
#include "common.h"
// function prototype: math_function.c
float gauss(float mean, float sigma);
int ones_32(uint32_t n);
int FFT(COMPLEX x[], uint32_t N);
int IFFT(COMPLEX x[], uint32_t N);
uint32_t floor_log2_32(uint32_t x);
void dot(float x[], float y[], int n, float z[]);
void ComplexDiv(COMPLEX x[], COMPLEX y[], int n, COMPLEX z[]);
void ComplexConj(COMPLEX x[], int n, COMPLEX conj_x[]);
void ComplexMul(COMPLEX x[], COMPLEX y[], int n, COMPLEX z[]);
// function prototype: system_function.c
void satr(float *inputSignal, float AmpLimit, float *wSatCoeff);
void HP2(float x, float *y, float a, float *x_record, float *y_record);
void LP2(float x, float *y, float a, float *x_record, float *y_record);
void Delay(volatile unsigned int wait_time);
// System key-coefficient Definition
#define L_len (10240) // raw data length
#define L_window (1024) // window length
#define L_sec (800) // sec length
#define Ls (200) // length of cutoffed impulse response signal
#define Lw (200)
#define ch_num (4)
/****************************************************************************/
// 宏定义
/****************************************************************************/
#define EMIF_BUFFER_LENGTH 8
#define FanON 1
#define KICK0 0x02620038
#define KICK1 0x0262003C
#define PIN_CONTROL_0 0x02620580
#define GPIO_REG_BASE 0x02320000
#define GPIO_OUTDATA 0x14
#define INTC0_SPIINT0 (0x00000036)
#define INTC0_SPIINT1 (0x00000037)
#define INTC0_SPIXEVT (0x00000038)
#define INTC0_SPIREVT (0x00000039)
#define uiCIC_out_num (0)
// 各管脚复用定义
#define PINMUX_DAC_RESET_GPIO17 17 // 17是DAC_RESET
#define PINMUX_FANCONTR_GPIO18 18 // 18是风扇
#define PINMUX_CONVST_GPIO19 19 // 19是ADC_CONVST
#define PINMUX_RESET_GPIO22 22 // 22是ADC_RESET
#define PINMUX_LED_GPIO23 23 // 23是用户LED
#define PINMUX_DAC_LDAC_GPIO27 27 // 27是DAC_LDAC
#define PINMUX_DAC_CS1_GPIO29 29 // 29是DAC_CS1
#define PINMUX_DAC_MOSI_GPIO30 30 // 30是DAC_MOSI
#define PINMUX_DAC_MISO_GPIO31 31 // 31是DAC_MISO
#define DAC_ENABLED 0
// SPI 管脚配置
#define SIMO_SOMI_CLK_CS 0x00000E02
#define CHAR_LENGTH 0x8
#define FQ_CS1_H 0x2
#define CHANNEL_NUM 8
// 宏定义测试电压
#define SPI_VOLTAGE_TEST 0x1000
#define SYS_INT_T64P2_TINTALL (66)
// 定时器周期
#define TMR_PERIOD_1S 166666666
#define TMR_FRAME 1
#define TMR_PERIOD_FREQ512 166666666 / 512
#define TMR_PERIOD_FREQ800 166666666 / 800
#define TMR_PERIOD_FREQ1K 166666666 / 1024
#define TMR_PERIOD_FREQ2K 166666666 / 2000
#define TMR_PERIOD_FREQ4K 166666666 / 4000
#define TMR_PERIOD_FREQ8K 166666666 / 8000
#define TIMER_FREQ TMR_PERIOD_FREQ1K
/****************************************************************************/
/* */
/* 宏定义 */
/* */
/****************************************************************************/
// SPI 管脚配置
#define FLASH_SIMO_SOMI_CLK_CS 0x00000E01 // FLASH 地址
#define CHAR_LENGTH 0x8
#define SPI_FLASH_ADDR_MSB1 0x0A
#define SPI_FLASH_ADDR_MSB0 0x00
#define SPI_FLASH_ADDR_LSB 0x00
#define SPI_FLASH_SECTOR_ERASE 0xD8 // 扇区擦除命令
#define SPI_FLASH_PAGE_WRITE 0x02 // 页写入命令
#define SPI_FLASH_STATUS_RX 0x05 // 读状态寄存器命令
#define SPI_FLASH_WRITE_EN 0x06 // 写使能命令
#define SPI_FLASH_READ 0x03 // 读命令
#define WRITE_IN_PROGRESS 0x01 // 写操作执行中
#define PAGE_SIZE 256
#define TOTAL_DATA_SIZE ch_num*ch_num*Ls
//#define TOTAL_DATA_SIZE 61440 //60KB
#define NUM_PAGES (TOTAL_DATA_SIZE/PAGE_SIZE)
/****************************************************************************/
// 全局变量
/****************************************************************************/
DSPType DSPChipType; // DSP 芯片型号
BoardUART uart0cfg; // 串口配置
unsigned short emif_wbuffer[EMIF_BUFFER_LENGTH] = {0};
short emif_rbuffer[EMIF_BUFFER_LENGTH] = {0};
short xinput[EMIF_BUFFER_LENGTH] = {0};
unsigned short Output[EMIF_BUFFER_LENGTH] = {0};
unsigned char flag = 1;
unsigned int m, n, i, j;
volatile unsigned int intflag = 1;
volatile unsigned int TimeFlag = 1;
volatile unsigned int SPIFlag = 1;
unsigned int tx_len;
unsigned char tx_data[3] = {0};
unsigned char *p_tx;
// flash相关全局变量
volatile unsigned int flash_flag = 1;
unsigned int flash_tx_len;
unsigned int flash_rx_len;
unsigned char flash_rvrf_data[260];
unsigned char flash_tx_data[260];
unsigned char flash_rx_data[260];
unsigned char *flash_p_tx;
unsigned char *flash_p_rx;
unsigned char flash_write_data[TOTAL_DATA_SIZE]={0};
unsigned char flash_read_data[TOTAL_DATA_SIZE]={0};
//函数声明
void PeriphInit();
void SPIPinMuxSet(void);
void InterruptInit(void);
void SPIDataFormatConfig(unsigned int dataFormat);
void SpiTransferData(void);
void SPIInterruptInit(void);
void SPIInit(void);
void SPIIsr(void);
void ResetDownUp(void);
void AD7606ToEMIF();
//
void FlashPeriphInit();
void FlashSPIPinMuxSet(void);
void FlashSPIDataFormatConfig(unsigned int dataFormat);
void ReadFromFlash(void);
void IsFlashBusy(void);
void WritetoFlash(void);
void WriteLargeDatatoFlash(void);
void ReadLargeDataFromFlash(void);
void WriteEnable(void);
void SpiTransfer(void);
void SectorErase(void);
int VerifyData(void);
int VerifyLargeData(void);
void StatusGet(void);
void FlashSPIInterruptInit(void);
void FlashSPIInit(void);
void FlashSPIIsr(void);
/****************************************************************************/
// SPI 管脚复用配置
void SPIPinMuxSet(void) {
// 解锁关键寄存器
KickUnlock();
GPIOPinMuxSet(SOC_DSC_BASE_REGS + SOC_DSC_PIN_CONTROL_0, PINMUX_DAC_CS1_GPIO29, DAC_ENABLED);
GPIOPinMuxSet(SOC_DSC_BASE_REGS + SOC_DSC_PIN_CONTROL_0, PINMUX_DAC_MOSI_GPIO30, DAC_ENABLED);
GPIOPinMuxSet(SOC_DSC_BASE_REGS + SOC_DSC_PIN_CONTROL_0, PINMUX_DAC_MISO_GPIO31, DAC_ENABLED);
// 锁定关键寄存器
KickLock();
}
/****************************************************************************/
// DSP 中断初始化
void InterruptInit(void) {
// 初始化 DSP 中断控制器
IntDSPINTCInit();
// 使能 DSP 全局中断
IntGlobalEnable();
}
/****************************************************************************/
// SPI 中断初始化
void SPIInterruptInit(void) {
CICDisableGlobalHostInt(SOC_CIC_0_REGS);
CICEventMap(SOC_CIC_0_REGS, INTC0_SPIINT1, uiCIC_out_num);
CICEnableGlobalHostInt(SOC_CIC_0_REGS);
// 注册中断服务函数
IntRegister(C66X_MASK_INT4, SPIIsr);
// 映射中断事件
IntEventMap(C66X_MASK_INT4, SYS_INT_CIC0_OUT0_20);
// 使能可屏蔽中断
IntEnable(C66X_MASK_INT4);
}
/****************************************************************************/
// SPI 初始化
void SPIInit(void) {
unsigned char cs = 0x0;
unsigned char dcs = 0x2;
unsigned int val = SIMO_SOMI_CLK_CS;
SPIReset(SOC_SPI_0_REGS);
SPIOutOfReset(SOC_SPI_0_REGS);
SPIModeConfigure(SOC_SPI_0_REGS, SPI_MASTER_MODE);
SPIClkConfigure(SOC_SPI_0_REGS, 166666666, 40000000, SPI_DATA_FORMAT0);
SPIPinControl(SOC_SPI_0_REGS, 0, 0, &val);
SPIDefaultCSSet(SOC_SPI_0_REGS, dcs);
SPIDataFormatConfig(SPI_DATA_FORMAT0); // 配置 SPI 数据格式
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), cs); // 配置 SPI 数据格式及片选信号
// 映射中断到 INT1
SPIIntLevelSet(SOC_SPI_0_REGS, SPI_RECV_INTLVL | SPI_TRANSMIT_INTLVL);
// 使能 SPI
SPIEnable(SOC_SPI_0_REGS);
}
/****************************************************************************/
// 配置 SPI 数据格式
void SPIDataFormatConfig(unsigned int dataFormat) {
SPIConfigClkFormat(SOC_SPI_0_REGS, (SPI_CLK_POL_LOW | SPI_CLK_INPHASE), dataFormat); // 配置 SPI 时钟
SPIShiftMsbFirst(SOC_SPI_0_REGS, dataFormat); // 配置 SPI 发送时 MSB 优先
SPICharLengthSet(SOC_SPI_0_REGS, CHAR_LENGTH, dataFormat); // 设置字符长度
}
/****************************************************************************/
// SPI 中断服务函数
void SPIIsr(void) {
SPIFlag = 1;
CICClearSystemEvent(SOC_CIC_0_REGS, INTC0_SPIINT1);
}
/****************************************************************************/
// 初始化 PSC电源模块
void PSCInit() {
CSL_PSC_enablePowerDomain(CSL_PSC_PD_ALWAYSON);
CSL_PSC_startStateTransition(CSL_PSC_PD_ALWAYSON);
while (!CSL_PSC_isStateTransitionDone(CSL_PSC_PD_ALWAYSON)) ;
}
/****************************************************************************/
// 初始化 EMIFA
/****************************************************************************/
void EMIFASetup(void) {
EMIFAAsyncDevDataBusWidthSelect(SOC_EMIFA_0_REGS, EMIFA_CHIP_SELECT_2,EMIFA_DATA_BUSWITTH_16BIT); /* 配置数据总线 16bit */
EMIFAAsyncDevOpModeSelect(SOC_EMIFA_0_REGS, EMIFA_CHIP_SELECT_2,EMIFA_ASYNC_INTERFACE_NORMAL_MODE); /* 选择 Normal 模式 */
EMIFAExtendedWaitConfig(SOC_EMIFA_0_REGS, EMIFA_CHIP_SELECT_2,EMIFA_EXTENDED_WAIT_DISABLE); /* 禁止 WAIT 引脚 */
EMIFAWaitTimingConfig(SOC_EMIFA_0_REGS, EMIFA_CHIP_SELECT_2,EMIFA_ASYNC_WAITTIME_CONFIG(2, 3, 2, 2, 3, 2, 0)); /* 配置 W_SETUP/R_SETUP W_STROBE/R_STROBE W_HOLD/R_HOLD 等参数 */
}
// SPI写数据至AD5676
void DataToDAC5676(unsigned char ch, unsigned short value) {
tx_data[0] = 0x30 + ch; // 控制4位+地址4位总共8位，ch位0-7表示通道
tx_data[1] = value >> 8; // D15-D8
tx_data[2] = value & 0xff; // D7-D0
tx_len = 3;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), FQ_CS1_H);
SpiTransferData();
}
/****************************************************************************/
// SPI 传输
void SpiTransferData(void) {
p_tx = &tx_data[0];
while (SPIFlag) {
tx_len--;
SPITransmitData1(SOC_SPI_0_REGS, *p_tx);
p_tx++;
if (!tx_len) {
SPIFlag = 0;
}
}
SPIFlag = 1;
SPIDat1Config(SOC_SPI_0_REGS, SPI_DATA_FORMAT0, 0x0);
}
/****************************************************************************/
// 外设初始化
void UartInit() {
// 串口初始化
uart0cfg.ID = BoardUART0;
uart0cfg.BaudRate = BAUD_115200;
uart0cfg.config = UART_WORDL_8BITS;
uart0cfg.OverSampRate = UART_OVER_SAMP_RATE_16;
UARTInit(&uart0cfg);
SPIPinMuxSet(); // SPI管脚复用
}
/****************************************************************************/
// AD7606 initialization
void AD7606GPIOInit(void) {
HWREG(KICK0) = 0x83E70B13;
HWREG(KICK1) = 0x95A4F1E0;
*((uint32_t *)PIN_CONTROL_0) |= ((1 << PINMUX_RESET_GPIO22) | (1 << PINMUX_CONVST_GPIO19)); /* Set pin as GPIO mode */
HWREG(GPIO_REG_BASE + GPIO_DIR) &= ~((1 << PINMUX_RESET_GPIO22) | (1 << PINMUX_CONVST_GPIO19)); /* Set GPIO as output mode */
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= ((1 << PINMUX_RESET_GPIO22) | (1 << PINMUX_CONVST_GPIO19)); /* Gpio output low level,turn off LED */
}
/****************************************************************************/
// AD7606复位，管脚RESET，先拉高再拉低
void AD7606Reset() {
HWREG(KICK0) = 0x83E70B13;
HWREG(KICK1) = 0x95A4F1E0;
*((uint32_t *)PIN_CONTROL_0) |= ((1 << PINMUX_RESET_GPIO22)); /* Set pin as GPIO mode */
HWREG(GPIO_REG_BASE + GPIO_DIR) &= ~((1 << PINMUX_RESET_GPIO22)); /* Set GPIO as output mode */
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= (1 << PINMUX_RESET_GPIO22); /* Gpio output high level,Turn on LED */
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) &= ~((1 << PINMUX_RESET_GPIO22)); /* Gpio output low level,turn off LED */
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= (1 << PINMUX_RESET_GPIO22);
}
/****************************************************************************/
// AD7606开始工作
void AD7606Start() {
// CONVST，先拉高再拉低
HWREG(KICK0) = 0x83E70B13;
HWREG(KICK1) = 0x95A4F1E0;
/* Set pin as GPIO mode */
*((uint32_t *)PIN_CONTROL_0) |= ((1 << PINMUX_CONVST_GPIO19));
HWREG(GPIO_REG_BASE + GPIO_DIR) &= ~((1 << PINMUX_CONVST_GPIO19));
// 点亮LED灯
/* Gpio output low level,turn off LED */
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) &= ~((1 << PINMUX_CONVST_GPIO19));
/* Gpio output high level,Turn on LED */
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= (1 << PINMUX_CONVST_GPIO19);
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) &= ~((1 << PINMUX_CONVST_GPIO19));
}
/****************************************************************************/
// DA5676通复位
void ResetDownUp(void) {
HWREG(KICK0) = 0x83E70B13;
HWREG(KICK1) = 0x95A4F1E0;
HWREG(PIN_CONTROL_0) |= (1 << PINMUX_DAC_RESET_GPIO17);
HWREG(GPIO_REG_BASE + GPIO_DIR) &= ~((1 << PINMUX_DAC_RESET_GPIO17));
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= ((1 << PINMUX_DAC_RESET_GPIO17));
// SPI初始化时RESET信号拉低拉高
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) &= ~(1 << PINMUX_DAC_RESET_GPIO17);
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= ((1 << PINMUX_DAC_RESET_GPIO17));
}
/****************************************************************************/
// DA5676开始加载数据
void LDACDownUp(void) {
HWREG(KICK0) = 0x83E70B13;
HWREG(KICK1) = 0x95A4F1E0;
HWREG(PIN_CONTROL_0) |= (1 << PINMUX_DAC_LDAC_GPIO27);
HWREG(GPIO_REG_BASE + GPIO_DIR) &= ~((1 << PINMUX_DAC_LDAC_GPIO27));
// SPI初始化时LDAC信号拉低拉高
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) &= ~(1 << PINMUX_DAC_LDAC_GPIO27);
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= ((1 << PINMUX_DAC_LDAC_GPIO27));
}
// AD7606采集信号，EMIF接收并打印数据，ChannelNum为读取的通道数
void AD7606ToEMIF() {
// emif_rbuffer[0-7] int, -32768-32768, voltage signal input
for (i = 0; i < 8; i++) {
emif_rbuffer[i] = ((short *)SOC_EMIFA_CS2_ADDR)[i];
}
AD7606Start();
}
/****************************************************************************/
// 定时器 / 计数器初始化
void TimerInit(unsigned int period) {
TimerConfigure(SOC_TMR_2_REGS, TMR_CFG_64BIT_CLK_INT); // 配置 定时器 / 计数器 2 为 64 位模式
TimerPeriodSet(SOC_TMR_2_REGS, TMR_TIMER12, period); // 设置周期
TimerEnable(SOC_TMR_2_REGS, TMR_TIMER12, TMR_ENABLE_CONT); // 使能 定时器 / 计数器 2
}
unsigned long tFrame = 0;
unsigned long tIndex = 0;
/****************************************************************************/
// 定时器中断服务函数
void TimerIsr(void) {
TimerIntDisable(SOC_TMR_2_REGS, TMR_INT_TMR12_NON_CAPT_MODE); // 禁用定时器 / 计数器中断
IntEventClear(SYS_INT_T64P2_TINTALL); // 清除中断标志
TimerIntStatusClear(SOC_TMR_2_REGS, TMR_INT_TMR12_NON_CAPT_MODE);
TimerIntEnable(SOC_TMR_2_REGS, TMR_INT_TMR12_NON_CAPT_MODE); // 使能 定时器 / 计数器 中断
TimeFlag = 1; // 定时器中断标识
tFrame++;
}
/****************************************************************************/
// 定时器 / 计数器中断初始化
void TimerInterruptInit(void) {
IntRegister(C66X_MASK_INT5, TimerIsr); // 注册中断服务函数
IntEventMap(C66X_MASK_INT5, SYS_INT_T64P2_TINTALL); // 映射中断到 DSP 可屏蔽中断
IntEnable(C66X_MASK_INT5); // 使能 DSP 可屏蔽中断
TimerIntEnable(SOC_TMR_2_REGS, TMR_INT_TMR12_NON_CAPT_MODE); // 使能 定时器 / 计数器 中断
}
/****************************************************************************/
COMPLEX Fx[L_window], Fy[ch_num][L_window]; // Frequency spectrum of input and output signal, length L_window
COMPLEX Fx_Conj[L_window]; // Conjugated Frequency spectrum of input signal x
COMPLEX Sxx[L_window], Sxy[ch_num][L_window]; // auto-correlation and cross-correlation power spectrum
COMPLEX average_Sxx[L_window] = {0}, average_Sxy[ch_num][L_window] = {0}; // averaged auto-correlation and cross-correlation power spectrum
COMPLEX frf[ch_num][L_window];
// Data Alignment
#pragma DATA_ALIGN(s, 8);
#pragma DATA_ALIGN(dr, 8);
#pragma DATA_ALIGN(e, 8);
#pragma DATA_ALIGN(u, 8);
#pragma DATA_ALIGN(w, 8);
#pragma DATA_ALIGN(dw, 8);
#pragma DATA_ALIGN(z, 8);
#pragma DATA_ALIGN(y, 8);
#pragma DATA_ALIGN(zSum, 8);
#pragma DATA_ALIGN(uNew, 8);
// Global array initialization
float xSequence[L_len] = {0}, ySequence[ch_num][L_len] = {0}; // raw data of input/output signal
float HanningWindow_len[L_len] = {0};
float xSecSequence[L_window] = {0}, ySecSequence[ch_num][L_window] = {0}; // Sectioned input/output signal, section length = window length
float xWindow[L_window] = {0}, yWindow[ch_num][L_window] = {0}; // Windowsed sectioned input/output signal
float s[ch_num][ch_num][Ls] = {1}; // s: impulse response of secondary path
float s1[ch_num][ch_num][Ls] = {0};
float s2[ch_num][ch_num][Ls] = {2};
float HanningWindow[L_window] = {0};
float dr[ch_num][Ls] = {0};
float u[ch_num][Ls] = {0};
float w[ch_num][Lw] = {0};
float dw[ch_num][Lw] = {0};
float z[ch_num][ch_num][Lw] = {0};
float e[ch_num] = {0};
float y[ch_num] = {0};
float zSum[ch_num] = {0};
float uNew[ch_num] = {0};
// Global variable initialization
float mu = 0.0005;
float Id_Amp = 0.3;
float SatrLimit = 4.5;
unsigned int TimeLag = 0;
int movlen = L_sec / 2;//窗移动的长度
int movlwind = FloatSize * (L_sec - L_sec / 2);// memmove移动长度
float wSatCoeff[ch_num] = {1,1,1,1};
void flattenArray(float s[ch_num][ch_num][Ls], unsigned char flash_write_data[]) {
int index = 0;
int i, j, k;
for (i = 0; i < ch_num; i++) {
for (j = 0; j < ch_num; j++) {
for (k = 0; k < Ls; k++) {
// Copy the bytes of the float into the char array
memcpy(&flash_write_data[index], &s[i][j][k], sizeof(float));
index += sizeof(float);
}
}
}
}
void restoreArray(unsigned char flash_read_data[], float s[ch_num][ch_num][Ls]) {
int index = 0;
int i, j, k;
for (i = 0; i < ch_num; i++) {
for (j = 0; j < ch_num; j++) {
for (k = 0; k < Ls; k++) {
// Copy the bytes from the char array back into the float
memcpy(&s[i][j][k], &flash_read_data[index], sizeof(float));
index += sizeof(float);
}
}
}
}
/****************************************************************************/
// 主函数
int main(void)
{
HWREG(KICK0) = 0x83E70B13;
HWREG(KICK1) = 0x95A4F1E0;
HWREG(PIN_CONTROL_0) |= (1 << PINMUX_LED_GPIO23) | (1 << PINMUX_FANCONTR_GPIO18);
HWREG(GPIO_REG_BASE + GPIO_DIR) &= ~((1 << PINMUX_LED_GPIO23) | (1 << PINMUX_FANCONTR_GPIO18));
HWREG(PIN_CONTROL_0) |= (1 << 1) |(1 << 3);
HWREG(GPIO_REG_BASE + GPIO_DIR) &= ~( (1 << 1)| (1 << 3) ) ;
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) &= ~(1 << 1) ;
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) &= ~(1 << 3) ;
Version(); // 驱动库版本
DSPChipType = DSPTypeGet(); // 取得芯片型号
PSCInit(); // 使能PSC模块
UartInit(); // 串口初始化
HWREG(GPIO_REG_BASE + GPIO_OUTDATA) |= (1 << PINMUX_FANCONTR_GPIO18);
// 打印串口终端信息
UARTPuts(&uart0cfg, "-------------HOUDE 8 channel software----------------.\r\n", -2);
char flashchoice;
volatile unsigned int flashstatus = 0;
FlashPeriphInit(); // 外设初始化
InterruptInit(); // DSP 中断初始化
FlashSPIInterruptInit(); // SPI 中断初始化
FlashSPIInit(); // SPI 初始化
UARTPuts(&uart0cfg, "SPI FLASH 256 byte Application......start\r\n\r\n", -1);
WriteEnable();
// UARTPuts(&uart0cfg,"Do you want to erase a sector of the flash before writing to it ?.", -1);
// UARTPuts(&uart0cfg,"\r\nInput y(Y)/n(N) to proceed.\r\n", -1);
// flashchoice = UARTCharGet(SOC_UART_0_REGS);
// UARTCharPut(SOC_UART_0_REGS, flashchoice);
//
// if(('y' == flashchoice) || ('Y' == flashchoice)){
SectorErase(); // 擦除 Flash
// }
WriteEnable(); // 写使能
WritetoFlash(); // 写 Flash
ReadFromFlash(); // 读 Flash
VerifyData(); // 数据校验
Delay(0x1fffff);
UARTPuts(&uart0cfg,"SPI FLASH 256 byte Application Finish.\r\n", -1);
// WriteLargeDatatoFlash(); // 写 Flash，将flash_write_data数组写入板卡
// UARTPuts(&uart0cfg,"Do you want to erase a sector of the flash before writing to it ?.", -1);
// UARTPuts(&uart0cfg,"\r\nInput y(Y)/n(N) to proceed.\r\n", -1);
// flashchoice = UARTCharGet(SOC_UART_0_REGS);
// UARTCharPut(SOC_UART_0_REGS, flashchoice);
// if(('y' == flashchoice) || ('Y' == flashchoice)){
// SectorErase(); // 擦除 Flash
// }
// WriteEnable(); // 写使能
// WriteLargeDatatoFlash(); // 写 Flash，将flash_write_data数组写入板卡
// ReadLargeDataFromFlash(); // 读 Flash，此时flash_read_data数组从板卡中读取值
// VerifyLargeData(); // 数据校验
// Delay(0x1fffff);
// UARTPuts(&uart0cfg,"SPI FLASH large data Application Finish.\r\n", -1);
// memset(flash_write_data,0x02,TOTAL_DATA_SIZE);
UARTPuts(&uart0cfg, "SPI FLASH large data Application......start\r\n\r\n", -1);
WriteEnable();
SectorErase();
WriteEnable();
s[0][0][0] = 1;
flattenArray(s, flash_write_data);
UARTPuts(&uart0cfg," flash_write_data ", -1);
UARTprintf(&uart0cfg, "%x", flash_write_data[0]);
UARTPuts(&uart0cfg,"\r\n", -1);
WriteLargeDatatoFlash(); // 写 Flash，将flash_write_data数组写入板卡
Delay(0x1fffff);
UARTPuts(&uart0cfg,"SPI FLASH large data Application Finish.\r\n", -1);
ReadLargeDataFromFlash(); // 读 Flash，此时flash_read_data数组从板卡中读取值
restoreArray(flash_read_data, s1);
UARTPuts(&uart0cfg," flash_read_data ", -1);
UARTprintf(&uart0cfg, "%x", flash_read_data[0]);
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg,"VerifyLargeData writearry flash_write_data and readarry flash_read_data.\r\n", -1);
VerifyLargeData();
UARTPuts(&uart0cfg,"VerifyLargeData writearry S and readarry S1.\r\n", -1);
VerifyLargeDatatest();
AD7606GPIOInit(); // AD7606初始化
EMIFASetup(); // 初始化 EMIFA
AD7606Reset(); // AD7606 复位
InterruptInit(); // DSP 中断初始化
SPIInterruptInit(); // SPI 中断初始化
SPIInit(); // SPI 初始化
ResetDownUp(); // DA5676复位
TimerInit(TIMER_FREQ); // 定时器初始化
TimerInterruptInit(); // 定时器 / 计数器中断初始化
// 输入数据
int ch_idx = 0;
int lf = sizeof(float);
int moveLs = (Ls - 1);
int moveLw = (Lw - 1);
int i, j;
int freq_idx = 0, count = 0;
int n_average = 18; // 平均次数
int dpLength = Lw;
int dpCoeff = 1;
float zeros[Lw] = {0};
float x_record_HP[ch_num][2] = {0};
float y_record_HP[ch_num][2] = {0};
float x_record_LP[ch_num][2] = {0};
float y_record_LP[ch_num][2] = {0};
float input_temp = 0;
float input_temp_LP = 0;
// Hanning window init.
for (freq_idx = 0; freq_idx < L_window; freq_idx++) {
HanningWindow[freq_idx] = 0.5 - 0.5 * cos(2 * pi * freq_idx / (L_window - 1));
}
// powerup interval ~ 20s
while(count < 24000) {
if (TimeFlag == 1) {
for (ch_idx = 0; ch_idx < ch_num; ch_idx++) {
Output[ch_idx] = (short)( (0 / 5.0) * 65535 + 0x8000);
DataToDAC5676(ch_idx, Output[ch_idx]);
LDACDownUp();
}
TimeFlag = 0;
count++;
}
}
UARTPuts(&uart0cfg,"start correct data.\r\n", -1);
// Identification loop
for (ch_idx = 0; ch_idx < ch_num; ch_idx++)
{
Delay(250000000); // identification interval ~ 5s
// init input signal
count = 0;
for (count = 0; count < L_len; count++) {
xSequence[count] = gauss(0, Id_Amp);
}
// Collect signal
count = 0;
while (count < L_len) {
if (TimeFlag == 1) {
for (j = 0; j < ch_num; j ++){
Output[j] = (j == ch_idx) ?
(short)((xSequence[count] / 5.0) * 65535 + 0x8000):
(short)((0 / 5.0) * 65535 + 0x8000);
DataToDAC5676(j, Output[j]);
LDACDownUp();
}
// output signal
AD7606ToEMIF();
for (j = 0; j < ch_num; j++) {
input_temp = emif_rbuffer[j] / 65535.0 * 5.0;
HP2(input_temp, &input_temp_LP, coeff_a, x_record_HP[j], y_record_HP[j]);
LP2(input_temp_LP, &ySequence[j][count], coeff_b, x_record_LP[j], y_record_LP[j]);
}
count += 1;
TimeFlag = 0;
}
}
// set output value to zero
Output[ch_idx] = (unsigned short)(0 * 65535 + 0x8000);
DataToDAC5676(ch_idx, Output[ch_idx]);
LDACDownUp();
// 初始化xSecSequence，ySecSequence[i]
memcpy(xSecSequence, xSequence, FloatSize * L_sec);
for (i = 0; i < ch_num; i++) {
memcpy(ySecSequence[i], ySequence[i], FloatSize * L_sec);
}
// Power spectrum Identification
for (count = 0; count < L_len; count += movlen) {
// windowing
dot(xSecSequence, HanningWindow, L_window, xWindow);
// FFT
for (freq_idx = 0; freq_idx < L_window; freq_idx++) {
Fx[freq_idx].real = xWindow[freq_idx];
Fx[freq_idx].imag = 0;
}
FFT(Fx, L_window);
ComplexConj(Fx, L_window, Fx_Conj); // Conjugate
ComplexMul(Fx, Fx_Conj, L_window, Sxx); // Auto-correlation of input signal
// Averaging Sxx
for (freq_idx = 0; freq_idx < L_window; freq_idx++) {
average_Sxx[freq_idx].real = ((n_average - 1) * average_Sxx[freq_idx].real + Sxx[freq_idx].real) / n_average; // 平均
average_Sxx[freq_idx].imag = ((n_average - 1) * average_Sxx[freq_idx].imag + Sxx[freq_idx].imag) / n_average;
}
// ---------------
// Output channel
// ---------------
for (i = 0; i < ch_num; i++) {
dot(ySecSequence[i], HanningWindow, L_window, yWindow[i]); // windowing
// Convert the time-domain to complex form
for (freq_idx = 0; freq_idx < L_window; freq_idx++) {
Fy[i][freq_idx].real = yWindow[i][freq_idx];
Fy[i][freq_idx].imag = 0;
}
FFT(Fy[i], L_window);
}
// -----
// Cross-correlation
// -----
for (i = 0; i < ch_num; i++) {
ComplexMul(Fy[i], Fx_Conj, L_window, Sxy[i]);
// Averaging
for (freq_idx = 0; freq_idx < L_window; freq_idx++) {
average_Sxy[i][freq_idx].real = ((n_average - 1) * average_Sxy[i][freq_idx].real + Sxy[i][freq_idx].real) / n_average;
average_Sxy[i][freq_idx].imag = ((n_average - 1) * average_Sxy[i][freq_idx].imag + Sxy[i][freq_idx].imag) / n_average;
}
}
memmove(xSecSequence, xSecSequence + movlen, movlwind);
memcpy(xSecSequence + L_sec - movlen, xSequence + count, movlwind);
for (i = 0; i < ch_num; i++) {
memmove(ySecSequence[i], ySecSequence[i] + movlen, movlwind);
// Insert the newest output signal
memcpy(ySecSequence[i] + L_sec - movlen, ySequence[i] + count, movlwind);
}
}
// Impulse response processing
for (i = 0; i < ch_num; i++) {
ComplexDiv(average_Sxy[i], average_Sxx, L_window, frf[i]);
IFFT(frf[i], L_window); // IFFT
for (freq_idx = 0; freq_idx < Ls; freq_idx++) {
s[ch_idx][i][freq_idx] = frf[i][freq_idx].real * 1.0;
}
}
}
SectorErase(); // 擦除 Flash
WriteEnable(); // 写使能
flattenArray(s, flash_write_data);
WriteLargeDatatoFlash(); // 写 Flash，将flash_write_data数组写入板卡
Delay(0x1fffff);
UARTPuts(&uart0cfg,"SPI FLASH large data Application Finish.\r\n", -1);
ReadLargeDataFromFlash(); // 读 Flash，此时flash_read_data数组从板卡中读取值
restoreArray(flash_read_data, s);
Delay(0x1fffff);
// -----
// Control loop
// -----
memset(x_record_HP, 0, sizeof(x_record_HP));
memset(y_record_HP, 0, sizeof(y_record_HP));
memset(x_record_LP, 0, sizeof(x_record_LP));
memset(y_record_LP, 0, sizeof(y_record_LP));
input_temp_LP = 0;
UARTPuts(&uart0cfg,"start enter AD7606ToEMIF loop .\r\n", -1);
while (1) {
if (TimeFlag == 1) {
tIndex = tFrame;
//UARTPuts(&uart0cfg,"start AD7606ToEMIF.", -1);
AD7606ToEMIF(); // 8通道数据ADC采集
for (ch_idx = 0; ch_idx < ch_num; ch_idx++) {
input_temp = emif_rbuffer[ch_idx] / 65535.0 * 5.0;
HP2(input_temp, &input_temp_LP, coeff_a, x_record_HP[ch_idx], y_record_HP[ch_idx]);
LP2(input_temp_LP, &e[ch_idx], coeff_b, x_record_LP[ch_idx], y_record_LP[ch_idx]);
}
// control begin
for (i = 0; i < ch_num; i++) {
y[i] = 0;
for (j = 0; j < ch_num; j++) {
y[i] += DSPF_sp_dotprod(s[i][j], u[j], Ls);
}
}
for (i = 0; i < ch_num; i++) {
memset(dw[i], 0, lf * Lw);
zSum[i] = 0;
for (j = 0; j < ch_num; j++) {
DSPF_sp_w_vec(z[j][i], dw[i], -e[j], dw[i], Lw);
zSum[i] += DSPF_sp_dotprod(z[j][i], z[j][i], dpLength);
}
DSPF_sp_w_vec(dw[i], w[i], mu / (dpCoeff * zSum[i] + 1e-8), w[i], Lw);
DSPF_sp_w_vec(w[i], zeros, wSatCoeff[i], w[i], Lw);
uNew[i] = DSPF_sp_dotprod(dr[i], w[i], Lw);
}
for (i = 0; i < ch_num; i++) {
for (j = 0; j < ch_num; j++) {
memmove(z[i][j] + 1, z[i][j], lf * moveLw);
z[i][j][0] = DSPF_sp_dotprod(s[i][j], dr[j], Lw);
}
}
for (ch_idx = 0; ch_idx < ch_num; ch_idx++) {
memmove(dr[ch_idx] + 1, dr[ch_idx], lf * moveLs);
dr[ch_idx][0] = e[ch_idx] - y[ch_idx];
memmove(u[ch_idx] + 1, u[ch_idx], lf * moveLs);
satr(&uNew[ch_idx], SatrLimit, &wSatCoeff[ch_idx]);
u[ch_idx][0] = uNew[ch_idx];
}
for (ch_idx = 0; ch_idx < ch_num; ch_idx++) {
Output[ch_idx] = (short)((u[ch_idx][0] / 5.0) * 65535 + 0x8000);
DataToDAC5676(ch_idx, Output[ch_idx]);
LDACDownUp();
}
TimeLag = tFrame - tIndex;
TimeFlag = 0;
}
}
}
/****************************************************************************/
/* */
/* 外设初始化 */
/* */
/****************************************************************************/
void FlashPeriphInit()
{
// 串口初始化
uart0cfg.ID = BoardUART0;
uart0cfg.BaudRate = BAUD_115200;
uart0cfg.config = UART_WORDL_8BITS;
uart0cfg.OverSampRate = UART_OVER_SAMP_RATE_16;
UARTInit(&uart0cfg);
FlashSPIPinMuxSet();
}
/****************************************************************************/
/* */
/* SPI 管脚复用配置 */
/* */
/****************************************************************************/
void FlashSPIPinMuxSet(void)
{
// 解锁关键寄存器
KickUnlock();
GPIOPinMuxSet(SOC_DSC_BASE_REGS + SOC_DSC_PIN_CONTROL_0, GPIO28_SPICS0, GPIO_FUNCTION_ENABLED);
GPIOPinMuxSet(SOC_DSC_BASE_REGS + SOC_DSC_PIN_CONTROL_0, GPIO29_SPICS1, GPIO_FUNCTION_ENABLED);
// GPIOPinMuxSet(SOC_DSC_BASE_REGS + SOC_DSC_PIN_CONTROL_0, GPIO30_SPIDIN, GPIO_FUNCTION_ENABLED);
// GPIOPinMuxSet(SOC_DSC_BASE_REGS + SOC_DSC_PIN_CONTROL_0, GPIO31_SPIDOUT, GPIO_FUNCTION_ENABLED);
// 锁定关键寄存器
KickLock();
}
/****************************************************************************/
/* */
/* 读状态寄存器 */
/* */
/****************************************************************************/
void StatusGet(void){
flash_tx_data[0] = SPI_FLASH_STATUS_RX;
flash_tx_len = flash_rx_len = 2;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x01);
SpiTransfer();
}
/****************************************************************************/
/* */
/* 写使能 */
/* */
/****************************************************************************/
void WriteEnable(void){
flash_tx_data[0] = SPI_FLASH_WRITE_EN;
flash_tx_len = flash_rx_len = 1;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x01);
SpiTransfer();
}
/****************************************************************************/
/* */
/* 忙检测 */
/* */
/****************************************************************************/
void IsFlashBusy(void){
do{
StatusGet();
}while(flash_rx_data[1] & 0x01);
}
/****************************************************************************/
/* */
/* 扇区擦除 */
/* */
/****************************************************************************/
void SectorErase(void){
flash_tx_data[0] = SPI_FLASH_SECTOR_ERASE;
flash_tx_data[1] = SPI_FLASH_ADDR_MSB1;
flash_tx_data[2] = SPI_FLASH_ADDR_MSB0;
flash_tx_data[3] = SPI_FLASH_ADDR_LSB;
flash_tx_len = flash_rx_len = 4;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x01);
SpiTransfer();
IsFlashBusy();
}
/****************************************************************************/
/* */
/* 写扇区(256字节) */
/* */
/****************************************************************************/
void WritetoFlash(void)
{
unsigned int index;
flash_tx_data[0] = SPI_FLASH_PAGE_WRITE;
flash_tx_data[1] = SPI_FLASH_ADDR_MSB1;
flash_tx_data[2] = SPI_FLASH_ADDR_MSB0;
flash_tx_data[3] = SPI_FLASH_ADDR_LSB;
// 准备要写入的数据
for (index = 4; index < 260; index++){
flash_tx_data[index] = index;
}
for(index = 4; index < 260; index++){
flash_rvrf_data[index] = index;
}
flash_tx_len = flash_rx_len = index;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
SpiTransfer();
IsFlashBusy();
}
void WriteLargeDatatoFlash(void){
unsigned int index;
unsigned int offset=0;
unsigned int page;
for(page=0;page<NUM_PAGES;page++){
flash_tx_data[0] = SPI_FLASH_PAGE_WRITE ;
flash_tx_data[1] = SPI_FLASH_ADDR_MSB1;
flash_tx_data[2] = SPI_FLASH_ADDR_MSB0;
flash_tx_data[3] = SPI_FLASH_ADDR_LSB | (page<< 8);
// 准备要写入的数据
for (index = 4; index < PAGE_SIZE +4; index++) {
if(offset<TOTAL_DATA_SIZE) {
flash_tx_data[index] =flash_write_data[offset];
offset++;
}
}
flash_tx_len = flash_rx_len = PAGE_SIZE +4;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
SpiTransfer();
IsFlashBusy();
}
}
void ReadLargeDataFromFlash(void){
unsigned int index;
unsigned int offset=0;
unsigned int page;
for(page=0;page<NUM_PAGES;page++){
flash_tx_data[0] = SPI_FLASH_READ;
flash_tx_data[1] = SPI_FLASH_ADDR_MSB1 ;
flash_tx_data[2] = SPI_FLASH_ADDR_MSB0;
flash_tx_data[3] = SPI_FLASH_ADDR_LSB | (page<< 8);
// 准备要读取的数据
for (index = 4; index < PAGE_SIZE +4; index++){
flash_tx_data[index] =0;//填充数据
}
flash_tx_len = flash_rx_len = PAGE_SIZE +4;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x1);
SpiTransfer();
for (index = 4; index < PAGE_SIZE +4; index++) {
if(offset<TOTAL_DATA_SIZE){
flash_read_data[offset] =flash_rx_data[index];
offset++;
}
}
IsFlashBusy();
}
}
/****************************************************************************/
/* */
/* 读数据 */
/* */
/****************************************************************************/
void ReadFromFlash(void) {
unsigned int index;
flash_tx_data[0] = SPI_FLASH_READ;
flash_tx_data[1] = SPI_FLASH_ADDR_MSB1;
flash_tx_data[2] = SPI_FLASH_ADDR_MSB0;
flash_tx_data[3] = SPI_FLASH_ADDR_LSB;
// 情况变量
for (index = 4; index < 260; index++) {
flash_tx_data[index] = 0;
}
flash_tx_len = flash_rx_len = index;
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), 0x01);
SpiTransfer();
}
/****************************************************************************/
/* */
/* 数据校验 */
/* */
/****************************************************************************/
int VerifyData(void){
unsigned int index;
for(index = 4; index < 260; index++){
if(flash_rvrf_data[index] != flash_rx_data[index]){
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg,"VerifyData: Comparing the data written to and read", -1);
UARTPuts(&uart0cfg," from Flash.\r\nThe two data blocks are unequal.", -1);
UARTPuts(&uart0cfg," Mismatch found at index ", -1);
UARTprintf(&uart0cfg, "%d", (int)index - 3);
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg,"Verify Failed.\r\n", -1);
return 0;
}
}
if (index == 260){
UARTPuts(&uart0cfg,"\r\nThe data in the Flash and the one written ", -1);
UARTPuts(&uart0cfg,"to it are equal.\r\n", -1);
UARTPuts(&uart0cfg,"Verify successfully.\r\n", -1);
return 1;
}
return 0;
}
int VerifyLargeData(void){
unsigned int offset;
for(offset = 0; offset < TOTAL_DATA_SIZE; offset++){
if(flash_write_data[offset] != flash_read_data[offset]){
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg,"VerifyData: Comparing the data written to and read", -1);
UARTPuts(&uart0cfg," from Flash.\r\nThe two data blocks are unequal.", -1);
UARTPuts(&uart0cfg," Mismatch found at offset ", -1);
UARTprintf(&uart0cfg, "%d", (int)offset);
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg," flash_write_data ", -1);
UARTprintf(&uart0cfg, "%x", flash_write_data[offset]);
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg," flash_read_data ", -1);
UARTprintf(&uart0cfg, "%x", flash_read_data[offset]);
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg,"Verify Failed.\r\n", -1);
return 0;
}
}
if (offset == TOTAL_DATA_SIZE) {
UARTPuts(&uart0cfg,"\r\nThe data in the Flash and the one written ", -1);
UARTPuts(&uart0cfg,"to it are equal.\r\n", -1);
UARTPuts(&uart0cfg,"Verify successfully.\r\n", -1);
return 1;
}
return 0;
}
int VerifyLargeDatatest(void){
unsigned int offset;
for(offset = 0; offset < TOTAL_DATA_SIZE; offset++){
if(s[offset] != s1[offset]){
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg,"VerifyData: Comparing the data written to and read", -1);
UARTPuts(&uart0cfg," from Flash.\r\nThe two data blocks are unequal.", -1);
UARTPuts(&uart0cfg," Mismatch found at offset ", -1);
UARTprintf(&uart0cfg, "%d", (int)offset);
UARTPuts(&uart0cfg,"\r\n", -1);
UARTPuts(&uart0cfg,"Verify Failed.\r\n", -1);
return 0;
}
}
if (offset == TOTAL_DATA_SIZE) {
UARTPuts(&uart0cfg,"\r\nThe data in the Flash and the one written ", -1);
UARTPuts(&uart0cfg,"to it are equal.\r\n", -1);
UARTPuts(&uart0cfg,"Verify successfully.\r\n", -1);
return 1;
}
return 0;
}
/****************************************************************************/
/* */
/* SPI 中断初始化 */
/* */
/****************************************************************************/
void FlashSPIInterruptInit(void)
{
CICDisableGlobalHostInt(SOC_CIC_0_REGS);
CICEventMap(SOC_CIC_0_REGS, INTC0_SPIINT1, uiCIC_out_num);
CICEnableGlobalHostInt(SOC_CIC_0_REGS);
// 注册中断服务函数
IntRegister(C66X_MASK_INT4, FlashSPIIsr);
// 映射中断事件
IntEventMap(C66X_MASK_INT4, SYS_INT_CIC0_OUT0_20);
// 使能可屏蔽中断
IntEnable(C66X_MASK_INT4);
}
/****************************************************************************/
/* */
/* SPI 初始化 */
/* */
/****************************************************************************/
void FlashSPIInit(void)
{
unsigned char cs = 0x1;
unsigned char dcs = 0x1;
unsigned int val = FLASH_SIMO_SOMI_CLK_CS;
SPIReset(SOC_SPI_0_REGS);
SPIOutOfReset(SOC_SPI_0_REGS);
SPIModeConfigure(SOC_SPI_0_REGS, SPI_MASTER_MODE);
SPIClkConfigure(SOC_SPI_0_REGS, 166666666, 1000000, SPI_DATA_FORMAT0);
SPIPinControl(SOC_SPI_0_REGS, 0, 0, &val);
SPIDefaultCSSet(SOC_SPI_0_REGS, dcs);
FlashSPIDataFormatConfig(SPI_DATA_FORMAT0); // 配置 SPI 数据格式
SPIDat1Config(SOC_SPI_0_REGS, (SPI_CSHOLD | SPI_DATA_FORMAT0), cs); // 配置 SPI 数据格式及片选信号
SPIIntLevelSet(SOC_SPI_0_REGS, SPI_RECV_INTLVL | SPI_TRANSMIT_INTLVL); // 映射中断到 INT1
SPIEnable(SOC_SPI_0_REGS); // 使能 SPI
}
/****************************************************************************/
/* */
/* 配置 SPI 数据格式 */
/* */
/****************************************************************************/
void FlashSPIDataFormatConfig(unsigned int dataFormat)
{
SPIConfigClkFormat(SOC_SPI_0_REGS,(SPI_CLK_POL_HIGH | SPI_CLK_INPHASE),dataFormat); // 配置 SPI 时钟
SPIShiftMsbFirst(SOC_SPI_0_REGS, dataFormat); // 配置 SPI 发送时 MSB 优先
SPICharLengthSet(SOC_SPI_0_REGS, CHAR_LENGTH, dataFormat); // 设置字符长度
}
/****************************************************************************/
/* */
/* SPI 传输 */
/* */
/****************************************************************************/
void SpiTransfer(void)
{
flash_p_tx = &flash_tx_data[0];
flash_p_rx = &flash_rx_data[0];
SPIIntEnable(SOC_SPI_0_REGS, (SPI_RECV_INT | SPI_TRANSMIT_INT));
while(flash_flag);
flash_flag = 1;
SPIDat1Config(SOC_SPI_0_REGS, SPI_DATA_FORMAT0, 0x0);
}
/****************************************************************************/
/* */
/* SPI 中断服务函数 */
/* */
/****************************************************************************/
void FlashSPIIsr(void)
{
unsigned int intCode = 0;
intCode = SPIInterruptVectorGet(SOC_SPI_0_REGS);
while (intCode){
if(intCode == SPI_TX_BUF_EMPTY){
flash_tx_len--;
SPITransmitData1(SOC_SPI_0_REGS, *flash_p_tx);
flash_p_tx++;
if (!flash_tx_len){
SPIIntDisable(SOC_SPI_0_REGS, SPI_TRANSMIT_INT);
}
}
if(intCode == SPI_RECV_FULL){
flash_rx_len--;
*flash_p_rx = (char)SPIDataReceive(SOC_SPI_0_REGS);
flash_p_rx++;
if (!flash_rx_len) {
SPIIntDisable(SOC_SPI_0_REGS, SPI_RECV_INT);
flash_flag = 0;
}
}
intCode = SPIInterruptVectorGet(SOC_SPI_0_REGS);
}
// IntEventClear(C66X_MASK_INT4);
// IntEventClear(SYS_INT_CIC0_OUT0_20);
CICClearSystemEvent(SOC_CIC_0_REGS, INTC0_SPIINT1);
}
