BOOL CPU_SPI_Xaction_nWrite8_nRead8( SPI_XACTION_8& Transaction )
{
LPC_SSP_T *spi = SPI_REG(Transaction.SPI_mod);
UINT8* outBuf = Transaction.Write8;
UINT8* inBuf = Transaction.Read8;
INT32 outLen = Transaction.WriteCount;
INT32 num, ii, i = 0;
if (Transaction.ReadCount) { // write & read
num = Transaction.ReadCount + Transaction.ReadStartOffset;
ii = -Transaction.ReadStartOffset;
} else { // write only
num = outLen;
ii = 0x80000000; // disable write to inBuf
}
UINT8 out = outBuf[0];
UINT16 in;
SPI_Write(spi, out); // write first word
while (++i < num) {
if (i < outLen) out = outBuf[i]; // get new output data
while (!(SPI_Readable(spi))); // wait for Rx buffer
in = SPI_Read(spi); // read input
SPI_Write(spi, out); // start output
if (ii >= 0) inBuf[ii] = (UINT8)in; // save input data
ii++;
}
while (!(SPI_Readable(spi))); // wait for Rx buffer
in = SPI_Read(spi); // read last input
if (ii >= 0) inBuf[ii] = (UINT8)in; // save last input
return TRUE;
}
unsigned int SPI_Read16(unsigned int addr)
{
unsigned int L = 0;
L = SPI_Read(addr) << 8;
L |= SPI_Read(addr + 1);
return L;
}
//******************************************************************
//Function : to read a single block from SD card
//Arguments : none
//return : unsigned char; will be 0 if no error,
// otherwise the response byte will be sent
//******************************************************************
unsigned char SD_readSingleBlock(char *inputbuffer,uint32_t startBlock)
{
unsigned char response;
uint16_t i, retry=0;
response = SD_sendCommand(READ_SINGLE_BLOCK, startBlock); //read a Block command
if(response != 0x00)
{
return response; //check for SD status: 0x00 - OK (No flags set)
}
SPI_EnableChipSelect();
retry = 0;
while(SPI_Read() != 0xfe) //wait for start block token 0xfe (0x11111110)
{
if(retry++ > 0xfffe)
{
SPI_DisableChipSelect();
return 1; //return if time-out
}
}
for(i=0; i<512; i++) //read 512 bytes
inputbuffer[i] = SPI_Read();
SPI_Read(); //receive incoming CRC (16-bit), CRC is ignored here
SPI_Read();
SPI_Read(); //extra 8 clock pulses
SPI_DisableChipSelect();
return 0;
}
void test_spi(void)
{
uint8_t i, tmp;
int n;
i = 0;
yushan_spi_write(0x0808, 0x0);
mdelay(10);
SPI_Read(0x0808, 1, (uint8_t *)(&tmp));
if(i != tmp) {
printk("SPI test fail 1: i %x read tmp is %x\n",i, tmp);
return;
}
#if 1
for(n=0; n<5; n++) {
pr_info("spi test loop count=%d\n",n);
i = 0x66;
yushan_spi_write(0x0808, i);
mdelay(10);
SPI_Read(0x808, 1, (uint8_t *)(&tmp));
if(i != tmp) {
printk("SPI test fail 2: i %x read tmp is %x\n",i, tmp);
} else {
pr_info("SPI test write %x :OK\n",i);
}
i = 0x55;
yushan_spi_write(0x0808, i);
mdelay(10);
SPI_Read(0x0808, 1, (uint8_t *)(&tmp));
if(i != tmp) {
printk("SPI test fail 3: i %x read tmp is %x\n",i, tmp);
} else {
pr_info("SPI test write %x :OK\n",i);
}
i = 0xaa;
yushan_spi_write(0x0808, i);
mdelay(10);
SPI_Read(0x0808, 1, (uint8_t *)(&tmp));
if(i != tmp) {
printk("SPI test fail 4: i %x read tmp is %x\n",i, tmp);
} else {
pr_info("SPI test write %x :OK\n",i);
}
}
#endif
}
uchar SPIRD(uchar rs) //写SPI移入数据, RS=0输入指令, RS=1输入数据
{
uchar rdata;
SPI_Write(0xf8+(1<<2)+(rs<<1)); //数据格式：11111 | RW | RS | 0 |
rdata=SPI_Read()&0xf0; //读取数据字高4位，数据格式： D7-D4| 0000 |
rdata=rdata|((SPI_Read()&0xf0)>>4); //读取数据字低4位，数据格式: D3-D0| 0000 |
return rdata;
}
void checkstatus()
{
unsigned char temp1,temp2;
temp1=SPI_Read(STATUS);
temp2=SPI_Read(FIFO_STATUS);
if(temp1==0x40)
{
//Delaynms(100);
LED0=~LED0;
LED1=~LED1;
}
}
void handlepost(){
printf(" HP \n");
if (ledmode==1){
ledmode=0;
asm(" req\n");
} else {
ledmode=1;
asm(" seq\n");
}
cmdip[0]=SPI_Read(S0_DIPR + 0);cmdip[1]=SPI_Read(S0_DIPR + 1);cmdip[2]=SPI_Read(S0_DIPR + 2);cmdip[3]=SPI_Read(S0_DIPR + 3);
sendform();
}
void flush(rsize){ //flush the receive buffer
unsigned int ptr,offaddr;
ptr = SPI_Read(S0_RX_RD); // Read the Rx Read Pointer
offaddr = (((ptr & 0x00FF) << 8 ) + SPI_Read(S0_RX_RD + 1));
offaddr+=rsize; //how much to skip
// Increase the S0_RX_RD value, so it point to the next receive
SPI_Write(S0_RX_RD,(offaddr >> 8) );
SPI_Write(S0_RX_RD + 1,(offaddr & 0x00FF));
SPI_Write(S0_CR,CR_RECV); // Now Send the RECV command
delay(5); // Wait for Receive Process
}
//******************************************************************
//Function : to write to a single block of SD card
//Arguments : none
//return : unsigned char; will be 0 if no error,
// otherwise the response byte will be sent
//******************************************************************
unsigned char SD_writeSingleBlock(char *inputbuffer,uint32_t startBlock)
{
unsigned char response;
uint16_t i, retry=0;
response = SD_sendCommand(WRITE_SINGLE_BLOCK, startBlock); //write a Block command
if(response != 0x00) return response; //check for SD status: 0x00 - OK (No flags set)
SPI_EnableChipSelect();
SPI_Write(0xfe); //Send start block token 0xfe (0x11111110)
for(i=0; i<512; i++) //send 512 bytes data
SPI_Write(inputbuffer[i]);
SPI_Write(0xff); //transmit dummy CRC (16-bit), CRC is ignored here
SPI_Write(0xff);
response = SPI_Read();
if( (response & 0x1f) != 0x05) //response= 0xXXX0AAA1 ; AAA='010' - data accepted
{ //AAA='101'-data rejected due to CRC error
SPI_DisableChipSelect(); //AAA='110'-data rejected due to write error
return response;
}
while(!SPI_Read()) //wait for SD card to complete writing and get idle
{
if(retry++ > 0xfffe)
{
SPI_DisableChipSelect();
return 1;
}
}
SPI_DisableChipSelect();
SPI_Write(0xff); //just spend 8 clock cycle delay before reasserting the CS line
SPI_EnableChipSelect(); //re-asserting the CS line to verify if card is still busy
while(!SPI_Read()) //wait for SD card to complete writing and get idle
{
if(retry++ > 0xfffe)
{
SPI_DisableChipSelect();
return 1;
}
}
SPI_DisableChipSelect();
return 0;
}
bool NRFLib::receive_message(unsigned char buf[]) {
if (_txmode)
RXMode();
unsigned char status = SPI_Read(STATUS); // read register STATUS's value
unsigned char fifo = SPI_Read(0x17);
//if(status&RX_DR){ // if receive data ready (TX_DS) interrupt
if (!(fifo&1)) {
SPI_Read_Buf(RD_RX_PLOAD, buf, _payload); // read playload to rx_buf
//flushRX(); // clear RX_FIFO
SPI_RW_Reg(WRITE_REG+STATUS,0x70); //0x70); // clear RX_DR or TX_DS or MAX_RT interrupt flag
return true;
}
return false;
}
/**
@brief Reads the accelerometer data.
@return none
**/
void Sensor_Scan(void)
{
if (Sensor_Delay(0, &ui32ScanSensorCounter, SCAN_SENSOR_TIME)) {
Sensor_Delay(1, &ui32ScanSensorCounter, SCAN_SENSOR_TIME);
i16SensorX = SPI_Read(XDATA_L_REG, SPI_READ_TWO_REG);
i16SensorY = SPI_Read(YDATA_L_REG, SPI_READ_TWO_REG);
i16SensorZ = SPI_Read(ZDATA_L_REG, SPI_READ_TWO_REG);
i16SensorT = SPI_Read(TEMP_L_REG, SPI_READ_TWO_REG);
}
}
uint16_t ADT7310_QueryValue() {
uint16_t SensorValue;
// send read command 0x50 and two dummy bytes
ADT7310_CS_OUT &= ~ADT7310_CS_PIN; // low active --> activate
SPI_Write(0x50);
while (SPI_IsBusy()) {}
SPI_Write(0xFF);
while (SPI_IsBusy()) {}
SensorValue = SPI_Read() << 8; // read MSB
SPI_Write(0xFF);
while (SPI_IsBusy()) {}
ADT7310_CS_OUT |= ADT7310_CS_PIN; // low active --> deactivate
SensorValue |= SPI_Read(); // read LSB
return SensorValue;
}
/**************************************************
函数：nrf24l01_rxPacket(uchar * rx_buf)
描述：
向rx_buf 指向的缓冲区位置按照RX_PLOAD_WIDTH宽度数据接收
**************************************************/
int nrf24l01_rxPacket(uchar * rx_buf)
{
int rx_result=0;
sta=SPI_Read(STATUS);
#ifdef DEBUG
printk("Statue is %x",sta);
#endif
if(sta & (1<<RX_DR) ) //收到数据
{
#ifdef DEBUG
printk("Data received!\n");
#endif
// CE_L;
// udelay(10);
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,RX_PLOAD_WIDTH); //从节点读取数据到RxBuffer
rx_result = 1;
}
SPI_RW_Reg(WRITE_REG + STATUS, sta); // 清除RX_DS中断标志
return rx_result;
}
void W5100_Init(void){// Ethernet Setup
unsigned char mac_addr[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
unsigned char ip_addr[] = {169,254,180,2};//{192,168,0,182};//
unsigned char sub_mask[] = {255,255,255,0};
unsigned char gtw_addr[] = {192,168,0,1};
SPI_Write(MR,0x80); // setting bit 7 of the mode register does a software reset of the w5100
delay(1);
//set the wiznet gateway address register
SPI_Write(GAR + 0,gtw_addr[0]); SPI_Write(GAR + 1,gtw_addr[1]);
SPI_Write(GAR + 2,gtw_addr[2]); SPI_Write(GAR + 3,gtw_addr[3]);
delay(1);
// Set the Wiznet W5100 MAC address - Source Address Register (SAR): 0x0009 to 0x000E
SPI_Write(SAR + 0,mac_addr[0]); SPI_Write(SAR + 1,mac_addr[1]);
SPI_Write(SAR + 2,mac_addr[2]); SPI_Write(SAR + 3,mac_addr[3]);
SPI_Write(SAR + 4,mac_addr[4]); SPI_Write(SAR + 5,mac_addr[5]);
delay(1);
// Set the Wiznet W5100 Sub Mask Address (SUBR): 0x0005 to 0x0008
SPI_Write(SUBR + 0,sub_mask[0]); SPI_Write(SUBR + 1,sub_mask[1]);
SPI_Write(SUBR + 2,sub_mask[2]); SPI_Write(SUBR + 3,sub_mask[3]);
delay(1);
// Set the Wiznet W5100 IP Address (SIPR): 0x000F to 0x0012
SPI_Write(SIPR + 0,ip_addr[0]); SPI_Write(SIPR + 1,ip_addr[1]);
SPI_Write(SIPR + 2,ip_addr[2]); SPI_Write(SIPR + 3,ip_addr[3]);
delay(1);
// Set the Wiznet W5100 RX and TX Memory Size, we use 2KB for Rx/Tx 4 channels
SPI_Write(RMSR,0x55);
SPI_Write(TMSR,0x55);
printf("Done Wiznet W5100 Initialization on IP address %d.%d.%d.%d\n\n",SPI_Read(SIPR + 0),SPI_Read(SIPR + 1),SPI_Read(SIPR + 2),SPI_Read(SIPR + 3));
}
void main(void){
int socket0status;
//ledmode=0; digitalWrite(0,LOW); cmdip[0]=0; pagehits=0;
delay(100);
printf("\nOlduino Web Server v5.1\n");
W5100_Init(); //initialize the wiznet chip
while(1){ // Loop forever
socket0status=SPI_Read(S0_SR);
//printf("s0s=%x ",socket0status);
switch (socket0status){
case SOCK_CLOSED: //initial condition
socket0_init(); //initialize socket 0
break;
case SOCK_ESTABLISHED: //someone wants to talk to the server
handlesession();
break;
//following are cases where we have to reset and reopen the socket
case SOCK_FIN_WAIT: case SOCK_CLOSING: case SOCK_TIME_WAIT:
case SOCK_CLOSE_WAIT: case SOCK_LAST_ACK:
close0();
break;
}
delay(100);
}
}
unsigned char nRF24L01_debug(void)
{
#ifdef nRF24L01_RX_Debug
unsigned char RxBuf[RX_PLOAD_WIDTH]={0};
SetRX_Mode();
while(1){
SetRX_Mode();
if(nRF24L01_RxPacket(RxBuf)){
//add your code
return 1;
}
}
#endif
#ifdef nRF24L01_TX_Debug
unsigned char sta=0;
unsigned char TxBuf[TX_PLOAD_WIDTH]={0};
nRF24L01_TxPacket(TxBuf);
while(1){
nRF24L01_TxPacket(TxBuf);
sta = SPI_Read(STATUS);
if(sta == 0x2e){
//add your code
return 1;
}
SPI_RW_Reg(WRITE_REG+STATUS, 0xff);
xSysCtlDelay(10000);
}
#endif
}
int main (void)
{
unsigned char i = 0;
unsigned char sta;
init_uart (BAUD_SETTING);
stdout = &mystdout;
for (i = 0; i < 32; i++)
{
tx_buf [i] = i;
}
NRF24L01_SPI_Init ();
// init_nrf24l01_io ();
// ifnnrf_tx_mode ();
// _delay_ms (10);
// sta = SPI_Read (FIFO_STATUS);
while (1)
{
ifnnrf_tx_mode ();
_delay_ms (10);
sta = SPI_Read (STATUS);
ifnnrf_CLERN_ALL ();
printf ("the status reg = 0x%x\n",sta);
_delay_ms (1000);
}
}
uchar nRF24L01_RxPacket(uchar *rx_buf)
{
uchar revale=0;
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0,RX_ADDRESS, RX_ADR_WIDTH);
CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // IRQ收发完成中断响应，16位CRC ，主接收
CE = 1;
inerDelay_us(130);
sta=SPI_Read(STATUS); // 读取状态寄存其来判断数据接收状况
if(RX_DR) // 判断是否接收到数据
{
CE = 0; //SPI使能
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,RX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
revale =1; //读取数据完成标志
write_com(0x80);
write_str(" Hum");
write_data(':');
write_data(rx_buf[1]/10%10+48);
write_data(rx_buf[1]%10+48);
write_data('%');
write_com(0x80+0x40);
write_str(" Tem");
write_data(':');
write_data(rx_buf[2]/10%10+48);
write_data(rx_buf[2]%10+48);
write_data(0xdf);
write_data('c');
}
SPI_RW_Reg(WRITE_REG+STATUS,sta); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
return revale;
}
int rawchip_match_id(void)
{
int rc = 0;
uint32_t chipid = 0;
int retry_spi_cnt = 0, retry_readid_cnt = 0;
CDBG("%s\n", __func__);
for (retry_spi_cnt = 0, retry_readid_cnt = 0; (retry_spi_cnt < 3 && retry_readid_cnt < 3); ) {
rc = SPI_Read(rawchip_info.rawchip_id_info->rawchip_id_reg_addr, 4, (uint8_t*)(&chipid));
if (rc < 0) {
pr_err("%s: read id failed\n", __func__);
retry_spi_cnt++;
pr_info("%s: retry: %d\n", __func__, retry_spi_cnt);
mdelay(5);
continue;
} else
rawchip_id = chipid;
pr_info("rawchip id: 0x%x requested id: 0x%x\n", chipid, rawchip_info.rawchip_id_info->rawchip_id);
if (chipid != rawchip_info.rawchip_id_info->rawchip_id) {
pr_err("rawchip_match_id chip id does not match\n");
retry_readid_cnt++;
pr_info("%s: retry: %d\n", __func__, retry_readid_cnt);
mdelay(5);
rc = -ENODEV;
continue;
} else
break;
}
return rc;
}
uint8_t SPI_ClearBuffer(void)
{
uint8_t rbuf; //Place holder to clear Rx Buffer
uint8_t timeout; //Read Function Completion Status
timeout = SPI_Read (&rbuf);
return(timeout);
}
void NRF24_Check_Event(void)
{
rt_uint8_t buff[34];
rt_uint8_t sta = SPI_Read(NRF_READ_REG + NRFRegSTATUS);
//rt_kprintf("sta=0x%x\n",sta);
if(sta & (0x01 << 6))
{
rt_uint8_t rx_len = SPI_Read(R_RX_PL_WID);
if(rx_len<33)
{
SPI_Read_Buf(RD_RX_PLOAD,buff,rx_len);// read receive payload from RX_FIFO buffer
rt_kprintf("Data_Receive:");
for(rt_uint8_t i=0;i<32;i++)
{
rt_kprintf("%c",buff[i]);
}
rt_kprintf("\n");
//LED1_ONOFF();
Data_Receive_Anl(buff,rx_len);
}
else
{
SPI_RW_Reg(FLUSH_RX,0xff);//Çå¿Õ»º³åÇø
}
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
if(sta & (1<<5))
{
//LED1_ONOFF();
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
if(sta & (1<<4))
{
if(sta & 0x01) //TX FIFO FULL
{
SPI_RW_Reg(FLUSH_TX,0xff);
}
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
SPI_RW_Reg(RF_WRITE_REG + NRFRegSTATUS, sta);
}
/**
@brief Software reset routine
@return none
**/
static void AD7091R_SoftwareReset(void)
{
CONVST_PORT->GPCLR = CONVST_PIN; /* Start conversion -> CONVST low */
CONVST_PORT->GPSET = CONVST_PIN; /* Pull CONVST high */
SPI_Read(AD7091R_OPERATION_MODE, ONE_BYTE); /* Read a dummy conversion result */
}
/*
*********************************************************************************************************
* AD7799_CMD_Read()
*
* Description : Read AD7799 registers via SPI interface.
*
* Argument(s) : None.
*
* Return(s) : Byte return from AD7799
*
* Caller(s) :
*
* Note(s) : None.
*********************************************************************************************************
*/
static unsigned char AD7799_CMD_Read( void )
{
unsigned char ReadData;
SPI_Write(spi_adc, NPCS_AD7799, 0x00);
ReadData = SPI_Read( spi_adc );
return ReadData;
}
void SPI_Read_Burst_Reg(uint8_t addr, uint8_t *buffer, uint8_t count)
{
uint8_t i;
RF_CS_PORT->ODR &=~ RF_CS_PIN;
while (RF_MISO_PORT->IDR & RF_MISO_PIN);
SPI_Write(addr | READ_BURST);
for (i = 0; i < count; i++)
buffer[i] = SPI_Read();
RF_CS_PORT->ODR |= RF_CS_PIN;
}
uint8_t SPI_Read_Status(uint8_t addr)
{
uint8_t x;
RF_CS_PORT->ODR &=~ RF_CS_PIN;
while (RF_MISO_PORT->IDR & RF_MISO_PIN);
x = SPI_Write(addr | READ_BURST);
x = SPI_Read();
RF_CS_PORT->ODR |= RF_CS_PIN;
return x;
}
/**************************************************************************//**
* @brief Reads data from a register
*
* @param regAddr - The adress of the register to be read
*
* @return Returns the read data or negative error code
******************************************************************************/
int32_t ad9643_read(uint32_t regAddr)
{
int32_t ret;
uint32_t data;
regAddr += 0x8000;
ret = SPI_Read(SPI_SEL_AD9643, regAddr, &data);
return (ret < 0 ? ret : (int32_t)data);
}
char Init_LIS35(void)
{
char Reg;
SPI_Write(CTRL_REG2,0x40); //boot
SPI_Write(CTRL_REG1,0x47); ///aktywacja wszystkich osi
SPI_Read(CTRL_REG1,&Reg);
if(Reg==0x47) return 1;
else return 0;
}
/***************************************************************************//**
* @brief Reads the value of the selected register.
*
* @param regAddress - The address of the register to read.
*
* @return registerValue - The register's value or negative error code.
*******************************************************************************/
int32_t ad9122_read(uint8_t registerAddress)
{
uint8_t regAddr = 0;
uint32_t registerValue = 0;
int32_t ret;
regAddr = 0x80 + (0x7F & registerAddress);
ret = SPI_Read(SPI_SEL_AD9122, regAddr, ®isterValue);
return (ret < 0 ? ret : (int32_t)registerValue);
}
// Reads response of a multi-byte SPI transaction.
unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char bytes)
{
unsigned char status,i;
PIO_Clear(&CSN); // Set CSN low, init SPI tranaction
SPI_Write(AT91C_BASE_SPI0, 0, reg); // Select register to write to and read status unsigned char
while(!SPI_IsFinished(AT91C_BASE_SPI0)); // Wait for write to complete
status = SPI_Read(AT91C_BASE_SPI0); // read status of the 24l01
for(i=0;i<bytes;i++)
{
SPI_Write(AT91C_BASE_SPI0, 0, 0); // write dummy byte
while(!SPI_IsFinished(AT91C_BASE_SPI0)); // Wait for write to complete
pBuf[i] = SPI_Read(AT91C_BASE_SPI0); // Read unsigned char from nRF24L01
}
PIO_Set(&CSN); // Set CSN high again
return(status); // return nRF24L01 status unsigned char
}
bool ADXL345_SPI_IsDataReady(alt_u32 device_base){
bool bReady = FALSE;
alt_u8 data8;
if (SPI_Read(device_base, ADXL345_REG_INT_SOURCE,&data8)){
if (data8 & XL345_DATAREADY)
bReady = TRUE;
}
return bReady;
}
