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."

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