/** * @brief Wait polling the SPI until the internal WIP flag is RESET. * The flag is SET when a write operation is running. * @param None * @retval None */ void EepromWaitEndWriteOperation(void) { uint8_t cmd = EEPROM_CMD_RDSR; uint8_t dummy = 0xFF; uint8_t status; /* Put the SPI chip select low to start the transaction */ EepromSPICSLow(Get_vectEepromSpiCsPort(),Get_vectEepromSpiCsPin()); /* Send command */ while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_TXE) == RESET); SPI_SendData(Get_EepromSpiPort(), cmd); while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_RXNE) == RESET); SPI_ReceiveData(Get_EepromSpiPort()); /* Polling on status register */ do{ while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_TXE) == RESET); SPI_SendData(Get_EepromSpiPort(), dummy); while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_RXNE) == RESET); status = SPI_ReceiveData(Get_EepromSpiPort()); }while(status&EEPROM_STATUS_WIP); while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ EepromSPICSHigh(Get_vectEepromSpiCsPort(),Get_vectEepromSpiCsPin()); }/* end EepromWaitEndWriteOperation() */
/** * @brief Wait polling the SPI until the internal WIP flag is RESET. * The flag is SET when a write operation is running. * @param None * @retval None */ void EepromWaitEndWriteOperation(void) { uint8_t cmd = EEPROM_CMD_RDSR; uint8_t dummy = 0xFF; uint8_t status; // SPI_ENTER_CRITICAL(); /* Put the SPI chip select low to start the transaction */ EepromSPICSLow(); // for(volatile uint16_t i=0;i<CS_TO_SCLK_DELAY;i++); /* Send command */ while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, cmd); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); SPI_ReceiveData(s_EepromSpiPort); /* Polling on status register */ do{ while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, dummy); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); status = SPI_ReceiveData(s_EepromSpiPort); }while(status&EEPROM_STATUS_WIP); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ EepromSPICSHigh(); // SPI_EXIT_CRITICAL(); }
/** * @brief Write data into TX FIFO * @param cNbBytes: number of bytes to be written into TX FIFO * @param pcBuffer: pointer to data to write * @retval SPIRIT status */ SpiritStatus SpiritSpiWriteLinearFifo(uint8_t cNbBytes, uint8_t* pcBuffer) { uint16_t tmpstatus = 0x0000; uint8_t header[2]; int i, index; SpiritStatus *status=(SpiritStatus *)&tmpstatus; /* Built the header bytes */ header[0]=WRITE_HEADER; header[1]=LINEAR_FIFO_ADDRESS; SPI_ENTER_CRITICAL(); /* Put the SPI chip select low to start the transaction */ SpiritSPICSLow(); { volatile uint16_t iv; for(iv=0; iv < CS_TO_SCLK_DELAY; iv++); } /* Write the header bytes and read the SPIRIT status bytes */ for(i=0; i<2; i++) { while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); SPI_SendData(SPIRIT_SPI_PERIPH_NB, header[i]); while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_RXNE) == RESET); tmpstatus += ((uint16_t)(SPI_ReceiveData(SPIRIT_SPI_PERIPH_NB)))<<((1-i)*8); } /* Write the data into the FIFO according to the number of bytes */ for(index=0; index<cNbBytes; index++) { while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); SPI_SendData(SPIRIT_SPI_PERIPH_NB, pcBuffer[index]); } /* To be sure to don't rise the Chip Select before the end of last sending */ while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); if(SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_RXNE) == SET) { SPI_ReceiveData(SPIRIT_SPI_PERIPH_NB); } /* Put the SPI chip select high to end the transaction */ SpiritSPICSHigh(); SPI_EXIT_CRITICAL(); return *status; }
/** * @brief Write a page of the EEPROM. * A page size is 32 bytes. * The pages are 256. * Page 0 address: 0x0000 * Page 1 address: 0x0020 * ... * Page 255 address: 0x1FE0 * It is allowed to write only a page for each operation. If the bytes * exceed the single page location, the other bytes are written at the * beginning. * @param None * @retval None */ void EepromWrite(uint16_t nAddress, uint8_t cNbBytes, uint8_t* pcBuffer) { uint8_t cmd = EEPROM_CMD_WRITE; uint8_t address[2]; /* Wait the end of a previous write operation */ EepromWaitEndWriteOperation(); /* SET the WREN flag */ EepromWriteEnable(); for(uint8_t k=0; k<2; k++) { address[k] = (uint8_t)(nAddress>>((1-k)*8)); } // SPI_ENTER_CRITICAL(); /* Put the SPI chip select low to start the transaction */ EepromSPICSLow(); // for(volatile uint16_t i=0;i<CS_TO_SCLK_DELAY;i++); /* Write the header bytes and read the SPIRIT status bytes */ while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, cmd); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); SPI_ReceiveData(s_EepromSpiPort); for(int i=0; i<2; i++) { while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, address[i]); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); SPI_ReceiveData(s_EepromSpiPort); } /* Writes the registers according to the number of bytes */ for(int index=0; index<cNbBytes; index++) { while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, pcBuffer[index]); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); SPI_ReceiveData(s_EepromSpiPort); } while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ EepromSPICSHigh(); // SPI_EXIT_CRITICAL(); }
/** * @brief Read single or multiple SPIRIT register * @param cRegAddress: base register's address to be read * @param cNbBytes: number of registers and bytes to be read * @param pcBuffer: pointer to the buffer of registers' values read * @retval SPIRIT status */ SpiritStatus SpiritSpiReadRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t* pcBuffer) { uint16_t tmpstatus = 0x0000; uint8_t header[2]; uint8_t dummy=0xFF; int i, index; SpiritStatus *status=(SpiritStatus *)&tmpstatus; /* Built the header bytes */ header[0]=READ_HEADER; header[1]=cRegAddress; SPI_ENTER_CRITICAL(); /* Put the SPI chip select low to start the transaction */ SpiritSPICSLow(); { volatile uint16_t iv; for(iv = 0; iv < CS_TO_SCLK_DELAY; iv++); } /* Write the header bytes and read the SPIRIT status bytes */ for(i=0; i<2; i++) { while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); SPI_SendData(SPIRIT_SPI_PERIPH_NB, header[i]); while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_RXNE) == RESET); tmpstatus += ((uint16_t)(SPI_ReceiveData(SPIRIT_SPI_PERIPH_NB)))<<((1-i)*8); } /* Read the registers according to the number of bytes */ for(index=0; index<cNbBytes; index++) { while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); SPI_SendData(SPIRIT_SPI_PERIPH_NB, dummy); while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_RXNE) == RESET); *pcBuffer = SPI_ReceiveData(SPIRIT_SPI_PERIPH_NB); pcBuffer++; } while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ SpiritSPICSHigh(); SPI_EXIT_CRITICAL(); return *status; }
/** * @brief Read data from RX FIFO * @param cNbBytes: number of bytes to read from RX FIFO * @param pcBuffer: pointer to data read from RX FIFO * @retval SPIRIT status */ StatusBytes SdkEvalSpiReadFifo(uint8_t cNbBytes, uint8_t* pcBuffer) { uint16_t tmpstatus = 0x0000; StatusBytes *status=(StatusBytes *)&tmpstatus; uint8_t header[2]; uint8_t dummy=0xFF; /* Built the header bytes */ header[0]=READ_HEADER; header[1]=LINEAR_FIFO_ADDRESS; SPI_ENTER_CRITICAL(); /* Put the SPI chip select low to start the transaction */ SdkEvalSPICSLow(); for(volatile uint16_t i=0;i<CS_TO_SCLK_DELAY;i++); /* Write the header bytes and read the SPIRIT status bytes */ for(int i=0; i<2; i++) { while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_SpiPort, header[i]); while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_RXNE) == RESET); tmpstatus += ((uint16_t)(SPI_ReceiveData(s_SpiPort)))<<((1-i)*8); } /* Read the data from the FIFO according to the number of bytes */ for(int index=0; index<cNbBytes; index++) { while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_SpiPort, dummy); while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_RXNE) == RESET); *pcBuffer = SPI_ReceiveData(s_SpiPort); pcBuffer++; } /* To be sure to don't rise the Chip Select before the end of last sending */ while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ SdkEvalSPICSHigh(); SPI_EXIT_CRITICAL(); return *status; }
/******************************************************************************* * Read a Byte from MiniSD Card Return: Data *******************************************************************************/ unsigned char MSD_ReadByte(void) { while (SPI_GetFlagStatus(SPI2, SPI_FLAG_TXE) == RESET); SPI_SendData(SPI2, DUMMY); while (SPI_GetFlagStatus(SPI2, SPI_FLAG_RXNE) == RESET); return SPI_ReceiveData(SPI2); }
/******************************************************************************* * Write a Byte to MiniSD Card Input: Data *******************************************************************************/ unsigned char MSD_WriteByte(u8 Data) { while (SPI_GetFlagStatus(SPI2, SPI_FLAG_TXE) == RESET); SPI_SendData(SPI2, Data); while (SPI_GetFlagStatus(SPI2, SPI_FLAG_RXNE) == RESET); return SPI_ReceiveData(SPI2); }
PUBLIC t_spi_error SER_SPI_ReceiveData(IN t_spi_device_id spi_device_id, IN t_uint8 *data_dest_address, IN t_uint32 elements_to_be_retrieved, IN t_spi_config *rx_spi_config ) { t_spi_error spi_error = SPI_OK; if ((t_uint32) spi_device_id >= NUM_SPI_INSTANCES) { spi_error = SPI_INVALID_PARAMETER; return(spi_error); } if (NULL == data_dest_address) { spi_error = SPI_INVALID_PARAMETER; return(spi_error); } g_ser_spi_context[spi_device_id].receive_it_mode = TRUE; g_ser_spi_context[spi_device_id].rcv_flag = TRUE; g_ser_spi_context[spi_device_id].receive_size = elements_to_be_retrieved; spi_error = SPI_ReceiveData(spi_device_id,data_dest_address,elements_to_be_retrieved,rx_spi_config); return(spi_error); }
/******************************************************************************* SPI_FLASH_SendByte *******************************************************************************/ u8 SPI_FLASH_SendByte(u8 byte) { while(SPI_GetFlagStatus(SPI3, SPI_FLAG_TXE) == RESET); SPI_SendData(SPI3, byte); while(SPI_GetFlagStatus(SPI3, SPI_FLAG_RXNE) == RESET); return SPI_ReceiveData(SPI3); }
unsigned char SpiTxRx_Byte(unsigned char data) { #if 1 u16 tmpdata; while(SPI_GetFlagStatus(SPI2, SPI_FLAG_TXE) == RESET); SPI_SendData(SPI2, data); while (SPI_GetFlagStatus(SPI2, SPI_FLAG_RXNE) == RESET); tmpdata = SPI_ReceiveData(SPI2); return tmpdata; #endif #if 0 // INT8U i,temp; // temp = 0; /*等待发送寄存器空*/ while((SPI2->SR & (uint8_t)SPI_FLAG_TXE)==RESET); /*发送一个字节*/ SPI1->DR = data; /* 等待接收寄存器有效*/ while((SPI2->SR & (uint8_t) SPI_FLAG_RXNE)==RESET); return(SPI2->DR); #endif }
/*---------------------------------------------------------------------------- SPI Serial Device "LPC17xx" Write and Read a byte on SPI interface *----------------------------------------------------------------------------*/ static uint8_t SpiWriteRead (uint8_t Data) { //dummy to clear status SPI_GetStatus(SpiInfo.pSpi); //read for empty buffer SPI_ReceiveData(SpiInfo.pSpi); // Send data... SPI_SendData(SpiInfo.pSpi, Data); // Wait for transfer complete while (SPI_CheckStatus(SPI_GetStatus(SpiInfo.pSpi), SPI_STAT_SPIF) == RESET); return ((uint8_t)SPI_ReceiveData(SpiInfo.pSpi)); }
/** * @brief Reset the ERSR status bit. * @param None * @retval Status */ uint8_t EepromResetSrwd(void) { uint8_t status; uint8_t cmd[] = {EEPROM_CMD_WRSR, EEPROM_STATUS_SRWD}; // SPI_ENTER_CRITICAL(); EepromWriteEnable(); /* Put the SPI chip select low to start the transaction */ EepromSPICSLow(); // for(volatile uint16_t i=0;i<CS_TO_SCLK_DELAY;i++); /* Send command */ for(uint8_t k=0;k<2;k++) { while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, cmd[k]); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); status = SPI_ReceiveData(s_EepromSpiPort); } while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ EepromSPICSHigh(); // SPI_EXIT_CRITICAL(); return status; }
uint8_t SPISendByte(uint8_t Data) { #ifdef USE_SPI_MODULE /*!< Wait until the transmit buffer is empty */ while (SPI_GetFlagStatus(SPI_FLAG_TXE) == RESET) {} /*!< Send the byte */ SPI_SendData(Data); /*!< Wait to receive a byte*/ while (SPI_GetFlagStatus(SPI_FLAG_RXNE) == RESET) {} /*!< Return the byte read from the SPI bus */ return SPI_ReceiveData(); #else uint8_t i; for(i=0;i<8;i++) { GPIO_WriteLow(ENC_SCK_PORT,ENC_SCK_PIN); if(Data & 0x80) GPIO_WriteHigh(ENC_MOSI_PORT,ENC_MOSI_PIN); else GPIO_WriteLow(ENC_MOSI_PORT,ENC_MOSI_PIN); GPIO_WriteHigh(ENC_SCK_PORT,ENC_SCK_PIN); Data <<=1; } GPIO_WriteLow(ENC_SCK_PORT,ENC_SCK_PIN); return 0; #endif }
/** * @brief Reset the ERSR status bit. * @param None * @retval Status */ uint8_t EepromResetSrwd(void) { uint8_t status; uint8_t cmd[] = {EEPROM_CMD_WRSR, EEPROM_STATUS_SRWD}; EepromWriteEnable(); /* Put the SPI chip select low to start the transaction */ EepromSPICSLow(Get_vectEepromSpiCsPort(),Get_vectEepromSpiCsPin()); /* Send command */ for(uint8_t k=0;k<2;k++) { while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_TXE) == RESET); SPI_SendData(Get_EepromSpiPort(), cmd[k]); while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_RXNE) == RESET); status = SPI_ReceiveData(Get_EepromSpiPort()); } while (SPI_GetFlagStatus(Get_EepromSpiPort(), SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ EepromSPICSHigh(Get_vectEepromSpiCsPort(),Get_vectEepromSpiCsPin()); return status; }/* end EepromResetSrwd() */
uint16_t spirit1_arch_refresh_status(void) { volatile uint16_t mcstate = 0x0000; uint8_t header[2]; int i; header[0]=0x01; header[1]=0; /* CS is active low */ SPIRIT_SPI_PERIPH_CS_PORT->BSRRH = SPIRIT_SPI_PERIPH_CS_PIN; { volatile uint32_t iv; for(iv = 0; iv < CS_TO_SCLK_DELAY; iv++); } /* send arbitrary header bytes and read out MC_STATE from SPI rx buffer */ for(i = 0; i < 2; i++) { while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); SPI_SendData(SPIRIT_SPI_PERIPH_NB, header[i]); while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_RXNE) == RESET); mcstate += ((uint16_t)(SPI_ReceiveData(SPIRIT_SPI_PERIPH_NB)))<<((1-i)*8); } /* finish up */ while (SPI_GetFlagStatus(SPIRIT_SPI_PERIPH_NB, SPI_FLAG_TXE) == RESET); SPIRIT_SPI_PERIPH_CS_PORT->BSRRL = SPIRIT_SPI_PERIPH_CS_PIN; return mcstate; }
// return true or -1 when failure uint8_t spiTransfer2(uint8_t *out, uint8_t *in, int len) { uint16_t spiTimeout; uint8_t b; while (len--) { b = in ? *(in++) : 0xFF; spiTimeout = SPI2_TIMEOUT; while (SPI_I2S_GetFlagStatus(SPI_BUSE2, SPI_I2S_FLAG_TXE) == RESET) { if ((spiTimeout--) == 0) return spiTimeoutUserCallback2(); } SPI_SendData(SPI_BUSE2, b); spiTimeout = SPI2_TIMEOUT; while (SPI_I2S_GetFlagStatus(SPI_BUSE2, SPI_I2S_FLAG_RXNE) == RESET) { if ((spiTimeout--) == 0) return spiTimeoutUserCallback2(); } b = SPI_ReceiveData(SPI_BUSE2); if (out) *(out++) = b; } return 1; }
unsigned char SPI2_SendByte(unsigned char data) { while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET); SPI_SendData(SPI2, data); while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET); return SPI_ReceiveData(SPI2); }
/** * @brief 通过SPI0发送、读取一个字节 * @param txData 要发送的字节 * @retval 读取的字节 */ u8 SPI0_ReadWriteByte(u8 txData) { u8 timeout = 200; /* 检查SPI是否可发送 */ while (!SPI_GetFlagStatus(HT_SPI0, SPI_FLAG_TXBE)) { if(--timeout == 0) return 0; } /* 通过SPI0发送一个字节 */ SPI_SendData(HT_SPI0, (u32)txData); timeout = 200; /* 检查SPI是否可接收 */ while (!SPI_GetFlagStatus(HT_SPI0, SPI_FLAG_RXBNE)) { if(--timeout == 0) return 0; } /* 返回通过SPI0接收的字节 */ return SPI_ReceiveData(HT_SPI0); }
/** * @brief Write single or multiple SPIRIT register * @param cRegAddress: base register's address to be write * @param cNbBytes: number of registers and bytes to be write * @param pcBuffer: pointer to the buffer of values have to be written into registers * @retval SPIRIT status */ StatusBytes SdkEvalSpiWriteRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t* pcBuffer) { uint8_t header[2]; uint16_t tmpstatus = 0x0000; StatusBytes *status=(StatusBytes *)&tmpstatus; /* Built the header bytes */ header[0]=WRITE_HEADER; header[1]=cRegAddress; SPI_ENTER_CRITICAL(); /* Puts the SPI chip select low to start the transaction */ SdkEvalSPICSLow(); for(volatile uint16_t i=0;i<CS_TO_SCLK_DELAY;i++); /* Writes the header bytes and read the SPIRIT status bytes */ for(int i=0; i<2; i++) { while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_SpiPort, header[i]); while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_RXNE) == RESET); tmpstatus += ((uint16_t)(SPI_ReceiveData(s_SpiPort)))<<((1-i)*8); } /* Writes the registers according to the number of bytes */ for(int index=0; index<cNbBytes; index++) { while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_SpiPort, pcBuffer[index]); while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_RXNE) == RESET); SPI_ReceiveData(s_SpiPort); } /* To be sure to don't rise the Chip Select before the end of last sending */ while (SPI_GetFlagStatus(s_SpiPort, SPI_FLAG_TXE) == RESET); /* Puts the SPI chip select high to end the transaction */ SdkEvalSPICSHigh(); SPI_EXIT_CRITICAL(); return *status; }
//spi basic read/write function u8 EF_spiFlashRW(u8 data) { while( DMA_Tx_Busy == 1) __nop(); while( SPI_GetFlagStatus(SPIFLASH_SPI,SPI_I2S_FLAG_TXE)==RESET ) __nop(); SPI_SendData(SPIFLASH_SPI,(u16)data); while( SPI_GetFlagStatus(SPIFLASH_SPI,SPI_I2S_FLAG_RXNE)==RESET ) __nop(); return (u8)SPI_ReceiveData(SPIFLASH_SPI); }
void WriteReg(char add, char data) { unsigned char y; ss_low; //lo while (SPI_GetFlagStatus(SPI1,SPI_FLAG_TXE)== RESET); SPI_SendData(SPI1, add); // putcSPI1(add); //SEND ADR BYTE while (SPI_GetFlagStatus(SPI1,SPI_FLAG_RXNE) == RESET); y = SPI_ReceiveData(SPI1); while (SPI_GetFlagStatus(SPI1,SPI_FLAG_TXE)== RESET); SPI_SendData(SPI1, data); //SEND PROXY DATA while (SPI_GetFlagStatus(SPI1,SPI_FLAG_RXNE) == RESET); y = SPI_ReceiveData(SPI1); //getcSPI1(); ss_high; // hi }
/** * @brief Read a page of the EEPROM. * A page size is 32 bytes. * The pages are 256. * Page 0 address: 0x0000 * Page 1 address: 0x0020 * ... * Page 255 address: 0x1FE0 * @param None * @retval None */ void EepromRead(uint16_t nAddress, uint8_t cNbBytes, uint8_t* pcBuffer) { uint8_t cmd[3]; cmd[0] = EEPROM_CMD_READ; for(uint8_t k=0; k<2; k++) { cmd[k+1] = (uint8_t)(nAddress>>((1-k)*8)); } /* Wait the end of a previous write operation */ EepromWaitEndWriteOperation(); // SPI_ENTER_CRITICAL(); /* Put the SPI chip select low to start the transaction */ EepromSPICSLow(); // for(volatile uint16_t i=0;i<CS_TO_SCLK_DELAY;i++); /* Write the header bytes and read the SPIRIT status bytes */ for(uint8_t i=0; i<3; i++) { while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, cmd[i]); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); SPI_ReceiveData(s_EepromSpiPort); } /* Read the registers according to the number of bytes */ for(int index=0; index<cNbBytes; index++) { while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); SPI_SendData(s_EepromSpiPort, 0xFF); while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_RXNE) == RESET); *pcBuffer = SPI_ReceiveData(s_EepromSpiPort); pcBuffer++; } while (SPI_GetFlagStatus(s_EepromSpiPort, SPI_FLAG_TXE) == RESET); /* Put the SPI chip select high to end the transaction */ EepromSPICSHigh(); // SPI_EXIT_CRITICAL(); }
char Read(char add) { unsigned char y; add = add + 0x80; //MSB OF ADR IS HIGH FOR READ ss_low; //lo while (SPI_GetFlagStatus(SPI1,SPI_FLAG_TXE)== RESET); SPI_SendData(SPI1, add); // putcSPI1(add); //SEND ADR BYTE while (SPI_GetFlagStatus(SPI1,SPI_FLAG_RXNE) == RESET); y = SPI_ReceiveData(SPI1); while (SPI_GetFlagStatus(SPI1,SPI_FLAG_TXE)== RESET); SPI_SendData(SPI1, 0); //SEND PROXY DATA while (SPI_GetFlagStatus(SPI1,SPI_FLAG_RXNE) == RESET); y = SPI_ReceiveData(SPI1); //getcSPI1(); ss_high; // hi return y; }
uint8_t HardwareSPI::transfer(uint8_t data) { // Wait for TX empty while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET) ; SPI_SendData(SPIx, data); // Wait for RX not empty while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET) ; return SPI_ReceiveData(SPIx); }
/*************************************************************************** Declaration : char spi_byte(char data_byte) Description : Transmit and receive one byte on the SPI port ***************************************************************************/ char spi_byte(char data_byte) { while(SPI_GetFlagStatus(SPI1, SPI_FLAG_TXE) == RESET); /* Send byte through the SPI1 peripheral */ SPI_SendData(SPI1, data_byte); /* Wait to receive a byte */ while(SPI_GetFlagStatus(SPI1, SPI_FLAG_RXNE) == RESET); data_byte=SPI_ReceiveData(SPI1); /* Return the byte read from the SPI bus */ return data_byte; }
char SendStrobe(char strobe) { unsigned char out; ss_low; //lo while (SPI_GetFlagStatus(SPI1,SPI_FLAG_TXE)== RESET); SPI_SendData(SPI1, strobe); //SEND STROBE BYTE while (SPI_GetFlagStatus(SPI1,SPI_FLAG_RXNE) == RESET); out = SPI_ReceiveData(SPI1); ss_high; // hi return out; }
/************************************************************************* * Function Name: MmcReceiveBlock * Parameters: pInt8U pData, Int32U Size * * Return: none * * Description: Read block by SPI * *************************************************************************/ void MmcReceiveBlock (pInt8U pData, Int32U Size) { #if SPI_DMA_ENA > 0 SPI2_DmaTransfer(pData,Size,SPI_RECEIVE); #else Int32U InCount = Size; while (InCount--) { SPI_SendData(SPI2, 0xFF); while(SPI_GetFlagStatus(SPI2, SPI_FLAG_RXNE) == RESET); *pData++ = SPI_ReceiveData(SPI2); } #endif // SPI_DMA_ENA > 0 }
/************************************************************************* * Function Name: MmcSendBlock * Parameters: pInt8U pData, Int32U Size * * Return: none * * Description: Send block by SPI * *************************************************************************/ void MmcSendBlock (pInt8U pData, Int32U Size) { #if SPI_DMA_ENA > 0 SPI2_DmaTransfer(pData,Size,SPI_TRANSMIT); #else Int32U OutCount = Size; while (OutCount--) { SPI_SendData(SPI2, *pData++); while(SPI_GetFlagStatus(SPI2, SPI_FLAG_RXNE) == RESET); volatile Int32U Dummy = SPI_ReceiveData(SPI2); } #endif // SPI_DMA_ENA > 0 }
/** * @brief Sends a byte through the SPI interface and return the byte received * from the SPI bus. * @param byte: byte to send. * @retval The value of the received byte. */ uint8_t sEE_SendByte(uint8_t byte) { /*!< Loop while DR register in not empty */ while (SPI_I2S_GetFlagStatus(sEE_SPI, SPI_I2S_FLAG_TXE) == RESET); /*!< Send byte through the SPI peripheral */ SPI_SendData(sEE_SPI, byte); /*!< Wait to receive a byte */ while (SPI_I2S_GetFlagStatus(sEE_SPI, SPI_I2S_FLAG_RXNE) == RESET); /*!< Return the byte read from the SPI bus */ return (uint8_t)SPI_ReceiveData(sEE_SPI); }