//===================================================== // nRF905 的检测程序,首先写入地址,然后再读出地址, // 如果读出来的值与原来的一样,那么就返回1 ,否则返回0 //===================================================== u8 nRF905_Check(void) { u8 i,AddressTemp[4]={0}; CSN = 0;//SPI valid SpiWrite(WTA);//写地址 for(i=0;i<4;i++) { SpiWrite(TxRxAddress[i]); } CSN = 1; delay_us(500); CSN = 0; SpiWrite(RTA);//读地址 for(i=0;i<4;i++) { AddressTemp[i]=SpiRead(); } CSN = 1; for(i=0;i<4;i++) { if(AddressTemp[i] != TxRxAddress[i]) { break; } } if(i!=4) return 0; return 1; }
/**************************************************** SpiTsWrite ****************************************************/ int SpiTsWrite(struct DibBridgeContext *pContext, unsigned int addr,unsigned char* buf, unsigned int size) { unsigned char command[6]; unsigned int commandsize; /****** Build Command ****** - b31: 0 => Start Bit - b30: 1 => Write - b29-28: => Transfer Size - b27: => Auto Increment - b26-b0: => Formatted Address - b15-b0: => Transfer Size ***************************/ command[0] = (addr & 0x3F000000) >> 24; command[1] = (addr & 0x00FF0000) >> 16; command[2] = (addr & 0x0000FF00) >> 8; command[3] = (addr & 0x000000FF) >> 0; command[0] |= 0x40; /* Write */ commandsize = size; command[4] = (commandsize & 0xFF00) >> 8; command[5] = (commandsize & 0x00FF); /** Write Command **/ SpiWrite(pContext,command,6); SpiWrite(pContext,buf,size); return 0; }
//***************************************************************************** // //! hci_patch_send //! //! @param usOpcode command operation code //! @param pucBuff pointer to the command's arguments buffer //! @param patch pointer to patch content buffer //! @param usDataLength data length //! //! @return none //! //! @brief Prepeare HCI header and initiate an HCI patch write operation // //***************************************************************************** void hci_patch_send(unsigned char ucOpcode, unsigned char *pucBuff, char *patch, unsigned short usDataLength) { unsigned char *data_ptr = (pucBuff + SPI_HEADER_SIZE); unsigned short usTransLength; unsigned char *stream = (pucBuff + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_PATCH); UINT8_TO_STREAM(stream, ucOpcode); stream = UINT16_TO_STREAM(stream, usDataLength + SIMPLE_LINK_HCI_PATCH_HEADER_SIZE); if (usDataLength <= SL_PATCH_PORTION_SIZE) { UINT16_TO_STREAM(stream, usDataLength); stream = UINT16_TO_STREAM(stream, usDataLength); memcpy((pucBuff + SPI_HEADER_SIZE) + HCI_PATCH_HEADER_SIZE, patch, usDataLength); // Update the opcode of the event we will be waiting for SpiWrite(pucBuff, usDataLength + HCI_PATCH_HEADER_SIZE); } else { usTransLength = (usDataLength/SL_PATCH_PORTION_SIZE); UINT16_TO_STREAM(stream, usDataLength + SIMPLE_LINK_HCI_PATCH_HEADER_SIZE + usTransLength*SIMPLE_LINK_HCI_PATCH_HEADER_SIZE); stream = UINT16_TO_STREAM(stream, SL_PATCH_PORTION_SIZE); memcpy(pucBuff + SPI_HEADER_SIZE + HCI_PATCH_HEADER_SIZE, patch, SL_PATCH_PORTION_SIZE); usDataLength -= SL_PATCH_PORTION_SIZE; patch += SL_PATCH_PORTION_SIZE; // Update the opcode of the event we will be waiting for SpiWrite(pucBuff, SL_PATCH_PORTION_SIZE + HCI_PATCH_HEADER_SIZE); while (usDataLength) { cc3k_int_poll(); if (usDataLength <= SL_PATCH_PORTION_SIZE) { usTransLength = usDataLength; usDataLength = 0; } else { usTransLength = SL_PATCH_PORTION_SIZE; usDataLength -= usTransLength; } *(unsigned short *)data_ptr = usTransLength; memcpy(data_ptr + SIMPLE_LINK_HCI_PATCH_HEADER_SIZE, patch, usTransLength); patch += usTransLength; // Update the opcode of the event we will be waiting for SpiWrite((unsigned char *)data_ptr, usTransLength + sizeof(usTransLength)); } } }
void Config905(void) { uchar i; CSN=0; // Spi enable for write a spi command SpiWrite(WC); // Write config command写放配置命令 for (i=0;i<RxTxConf.n;i++) // Write configration words 写放配置字 { SpiWrite(RxTxConf.buf[i]); } CSN=1; // Disable Spi }
//******************************* //this function to initial start address //******************************* static void SetPACA(unsigned char PA, unsigned char CA) { // Set PA SpiWrite(0xB0 | PA); // Set CA MSB SpiWrite(0x10 | (CA >> 4) & 0xF); // Set CA LSB SpiWrite(0x00 | (CA & 0xF)); }
void LCD_ClearScreen(void) { int i = 0; /*CLEAR ALL PANNAL*/ SetPACA(0x0, 0x0); for (i = 0; i < 132 *8; i++) { SpiWrite(0x100); } SpiWrite(0x10f); }
void enc28j60WriteOp(unsigned char op, unsigned char address, unsigned char data) { unsigned char dat = 0; ENC28J60_CSL(); // issue write command dat = op | (address & ADDR_MASK); SpiWrite(dat); // write data dat = data; SpiWrite(dat); ENC28J60_CSH(); }
void enc28j60WriteBuffer(unsigned int len, unsigned char* data) { ENC28J60_CSL(); // issue write command SpiWrite(ENC28J60_WRITE_BUF_MEM); while(len) { len--; SpiWrite(*data); data++; } ENC28J60_CSH(); }
//***************************************************************************** // //! HCI data command builder. //! //! \param usOpcode command operation code //! \param ucPayload pointer to the data buffer //! \param usLength buffer length //! //! \return none //! //! \brief Initiate an HCI data write operation // //***************************************************************************** long hci_data_send(unsigned char ucOpcode, unsigned char *ucArgs, unsigned short usArgsLength, unsigned short usDataLength, const unsigned char *ucTail, unsigned short usTailLength) { hci_data_hdr_t *hci_data_hdr_ptr; hci_data_hdr_ptr = (hci_data_hdr_t *)((ucArgs) + SPI_HEADER_SIZE); // // Fill in the HCI header of data packet // hci_data_hdr_ptr->ucType = HCI_TYPE_DATA; hci_data_hdr_ptr->ucOpcode = ucOpcode; hci_data_hdr_ptr->ucArgsize = usArgsLength; hci_data_hdr_ptr->usLength = usArgsLength + usDataLength + usTailLength; // // Send the packet over the SPI // SpiWrite(ucArgs, sizeof(hci_data_hdr_t) + usArgsLength + usDataLength + usTailLength); return(ESUCCESS); }
void A7201_init(void) { SPI_IO_Init(); SPI_CE_L(); //pCE = 0; //pTX_RX = 0; //SPI_S_H(); //pSPIS = 1; // SPI mode SPI_STB_L(); SPI_CLK_L(); Reg1_H = 0x77; Reg1_L = 0xA9; // RX, FSK, HiBand, Clock out disable, Up side band, TX power max, AGC enable Reg1_L &= (~BAND_L); //HI_BAND // HI_BAND = 434MHz band, LO_BAND = 315MHz band Reg1_L |= FASK_L; //FSK //1:FSK or 0 ASK Reg1_L |= IFB0_L; //IF filter bandwidth selection[mid. (ASK = 250KHz, FSK = 150KHz)] Reg1_H |= IFB1_H; SpiWrite ( 0xFA, 0x32 ); // For Power On(Initial) // initUart1(); // 8M/12/32 = 20.8K bps /* while(1) { ReceiveData(); } */ }
static void ShowChar(unsigned char x, unsigned char y, unsigned char ascii_word) { int i = 0, k = 0; unsigned char temp; k = (ascii_word - 32) * 16; for (i = 0;i < 8;i++) { SetPACA((x*2), (129 - (y*8) - i)); temp = Ascii[k+i]; SpiWrite(0x100 | temp); } for (i = 0;i < 8;i++) { SetPACA((x*2) + 1, (129 - (y*8) - i)); temp = Ascii[k+i+8]; SpiWrite(0x100 | temp); } }
//===================================================== //使用905发送数据 // //===================================================== void TxPacket(void) { u16 i; CSN = 0; SpiWrite(WTP); for(i=0;i<32;i++) { SpiWrite(TxBuf[i]); } CSN = 1; delay_us(100);// CSN = 0; SpiWrite(WTA); for(i=0;i<4;i++) { SpiWrite(RxTxconf.buf[i+5]); } CSN = 1; TRX_CE = 1; delay_us(100);// TRX_CE = 0; }
//***************************************************************************** // //! hci_data_command_send //! //! @param usOpcode command operation code //! @param pucBuff pointer to the data buffer //! @param ucArgsLength arguments length //! @param ucDataLength data length //! //! @return none //! //! @brief Prepeare HCI header and initiate an HCI data write operation // //***************************************************************************** void hci_data_command_send(UINT16 usOpcode, UINT8 *pucBuff, UINT8 ucArgsLength,UINT16 ucDataLength) { UINT8 *stream = (pucBuff + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_DATA); UINT8_TO_STREAM(stream, usOpcode); UINT8_TO_STREAM(stream, ucArgsLength); stream = UINT16_TO_STREAM(stream, ucArgsLength + ucDataLength); // Send the command over SPI on data channel SpiWrite(pucBuff, ucArgsLength + ucDataLength + SIMPLE_LINK_HCI_DATA_CMND_HEADER_SIZE); return; }
//===================================================== //主机通过SPI接口向905配置寄存器写入配置信息 // //===================================================== void Config905(void) { unsigned char i; CSN = 0; SpiWrite(WC); for(i=0;i<RxTxconf.n;i++) { SpiWrite(RxTxconf.buf[i]); } CSN = 1; //=================== delay_ms(100); /*CSN = 0; SpiWrite(RC); for(i=0;i<RxTxconf.n;i++) { RxBuf[i] = SpiRead(); } CSN = 1; */ //=================== }
//===================================================== //使用905接收数据 // //===================================================== void RxPacket(void) { unsigned char i; TRX_CE = 0; //设置905进入待机模式 CSN = 0; SpiWrite(RRP); //准备读取接收到的数据 for(i=0;i<32;i++) { RxBuf[i] = SpiRead(); //通过SPI口从905读取数据 } CSN = 1; while(DR||AM); TRX_CE = 1; }
void LCD_Init(void) { /* Use SPI0 for LCD */ SPI = SPI0; /* Initial SPI data format and SPI clock */ SPI->CNTRL = SPI_CNTRL_CLK_IDLE_HIGH | SPI_CNTRL_TX_FALLING | SPI_CNTRL_RX_RISING | SPI_CNTRL_TX_BIT_LEN(9); SPI->DIVIDER = SPI_DIVIDER_DIV(4); /* SPI clock freq = system clock / 4 */ SPI->SSR = SPI_SSR_HW_AUTO_ACTIVE_LOW; // Set BR SpiWrite(0xEB); // Set PM SpiWrite(0x81); SpiWrite(0xA0); SpiWrite(0xC0); // Set Display Enable SpiWrite(0xAF); }
void enc28j60ReadBuffer(unsigned int len, unsigned char* data) { ENC28J60_CSL(); // issue read command SpiWrite(ENC28J60_READ_BUF_MEM); while(len) { len--; // read data *data = SpiRead(); data++; } *data='\0'; ENC28J60_CSH(); }
//***************************************************************************** // //! hci_command_send //! //! @param usOpcode command operation code //! @param pucBuff pointer to the command's arguments buffer //! @param ucArgsLength length of the arguments //! //! @return none //! //! @brief Initiate an HCI command. // //***************************************************************************** UINT16 hci_command_send(UINT16 usOpcode, UINT8 *pucBuff, UINT8 ucArgsLength) { UINT8 *stream; stream = (pucBuff + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_CMND); stream = UINT16_TO_STREAM(stream, usOpcode); UINT8_TO_STREAM(stream, ucArgsLength); //Update the opcode of the event we will be waiting for SpiWrite(pucBuff, ucArgsLength + SIMPLE_LINK_HCI_CMND_HEADER_SIZE); return(0); }
void TxPacket(void) { uchar i; //Config905(); CSN=0; // Spi enable for write a spi command SpiWrite(WTP); // Write payload command for (i=0;i<32;i++) { SpiWrite(TxBuf[i]); // Write 32 bytes Tx data } CSN=1; // Spi disable Delay(1); CSN=0; // Spi enable for write a spi command SpiWrite(WTA); // Write address command for (i=0;i<4;i++) // Write 4 bytes address { SpiWrite(RxTxConf.buf[i+5]); } CSN=1; // Spi disable TRX_CE=1; // Set TRX_CE high,start Tx data transmission Delay(1); // while (DR!=1); TRX_CE=0; // Set TRX_CE low }
unsigned char enc28j60ReadOp(unsigned char op, unsigned char address) { unsigned char dat = 0; ENC28J60_CSL(); SpiWrite(op | (address & ADDR_MASK)); dat =SpiRead(); // do dummy read if needed (for mac and mii, see datasheet page 29) if(address & 0x80) { dat =SpiRead(); } // release CS ENC28J60_CSH(); return dat; }
//***************************************************************************** // //! hci_command_send //! //! @param usOpcode command operation code //! @param pucBuff pointer to the command's arguments buffer //! @param ucArgsLength length of the arguments //! //! @return none //! //! @brief Initiate an HCI command. // //***************************************************************************** unsigned short hci_command_send(unsigned short usOpcode, unsigned char *pucBuff, unsigned char ucArgsLength) { unsigned char *stream; stream = (pucBuff + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_CMND); stream = UINT16_TO_STREAM(stream, usOpcode); UINT8_TO_STREAM(stream, ucArgsLength); // TM_DEBUG("getting ready to send a buffer of data"); //Update the opcode of the event we will be waiting for SpiWrite(pucBuff, ucArgsLength + SIMPLE_LINK_HCI_CMND_HEADER_SIZE); // TM_DEBUG("done sending a buffer of data"); return(0); }
//***************************************************************************** // //! HCI data command send. //! //! \param usOpcode command operation code //! \param ucPayload pointer to the data buffer //! \param usLength buffer length //! //! \return none //! //! \brief Initiate an HCI data write operation // //***************************************************************************** void hci_data_command_send(unsigned short usOpcode, unsigned char *pucBuff, unsigned char ucArgsLength,unsigned short ucDataLength) { unsigned char *stream = (pucBuff + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_DATA); UINT8_TO_STREAM(stream, usOpcode); UINT8_TO_STREAM(stream, ucArgsLength); stream = UINT16_TO_STREAM(stream, ucArgsLength + ucDataLength); // // Send teh command over SPI on data channel // SpiWrite(pucBuff, ucArgsLength + ucDataLength + SIMPLE_LINK_HCI_DATA_CMND_HEADER_SIZE); return; }
//***************************************************************************** // //! HCI data command send. //! //! \param usOpcode command operation code //! \param ucPayload pointer to the data buffer //! \param usLength buffer length //! //! \return none //! //! \brief Initiate an HCI data write operation // //***************************************************************************** void hci_data_command_send(unsigned short usOpcode, unsigned char *pucBuff, unsigned char ucArgsLength,unsigned short ucDataLength) { hci_data_cmd_hdr_t *hci_cmnd_hdr_ptr; hci_cmnd_hdr_ptr = (hci_data_cmd_hdr_t *)(pucBuff + SPI_HEADER_SIZE); hci_cmnd_hdr_ptr->ucType = HCI_TYPE_DATA; hci_cmnd_hdr_ptr->ucOpcode = usOpcode; hci_cmnd_hdr_ptr->ucArgLength = ucArgsLength; hci_cmnd_hdr_ptr->usTotalLength = ucArgsLength + ucDataLength; // // Send teh command over SPI on data channel // SpiWrite(pucBuff, ucArgsLength + ucDataLength + sizeof(hci_data_cmd_hdr_t)); return; }
//***************************************************************************** // //! Initiate an HCI cmnd. //! //! \param usOpcode command operation code //! \param ucArgs pointer to the command's arguments buffer //! \param ucArgsLength length of the arguments //! //! \return ESUCCESS if command transfer complete,EFAIL otherwise. //! //! \brief Initiate an HCI cmnd. // //***************************************************************************** unsigned short hci_command_send(unsigned short usOpcode, unsigned char *pucBuff, unsigned char ucArgsLength) { hci_cmnd_hdr_t *hci_cmnd_hdr_ptr; hci_cmnd_hdr_ptr = (hci_cmnd_hdr_t *)(pucBuff + SPI_HEADER_SIZE); hci_cmnd_hdr_ptr->ucType = HCI_TYPE_CMND; hci_cmnd_hdr_ptr->usOpcode = usOpcode; hci_cmnd_hdr_ptr->ucLength = ucArgsLength; // // Update the opcode of the event we will be waiting for // SpiWrite(pucBuff, ucArgsLength + sizeof(hci_cmnd_hdr_t)); return(0); }
DRESULT disk_write ( BYTE drv, /* Physical drive nmuber (0) */ const BYTE *buff, /* Pointer to the data to be written */ DWORD sector, /* Start sector number (LBA) */ BYTE count /* Sector count (1..255) */ ) { DRESULT res; uint32_t size; uint32_t scount; if (drv) { res = (DRESULT)STA_NOINIT; return res; } if(count==0||count>=2) { res = (DRESULT) STA_NOINIT; return res; } size=count*512; if(bUseSDCard) SpiWrite(sector, size,(uint8_t *)buff); else { scount = size / (4*1024); if ((size % (4*1024)) != 0) scount++; spiFlashSectorErase(sector*512, scount); spiFlashCheckBusy(); spiFlashPageProgram(sector*512, size,(uint8_t *)buff); } res = RES_OK; return res; }
//***************************************************************************** // //! hci_data_send //! //! @param usOpcode command operation code //! @param ucArgs pointer to the command's arguments buffer //! @param usArgsLength length of the arguments //! @param ucTail pointer to the data buffer //! @param usTailLength buffer length //! //! @return none //! //! @brief Initiate an HCI data write operation // //***************************************************************************** INT32 hci_data_send(UINT8 ucOpcode, UINT8 *ucArgs, UINT16 usArgsLength, UINT16 usDataLength, const UINT8 *ucTail, UINT16 usTailLength) { UINT8 *stream; stream = ((ucArgs) + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_DATA); UINT8_TO_STREAM(stream, ucOpcode); UINT8_TO_STREAM(stream, usArgsLength); stream = UINT16_TO_STREAM(stream, usArgsLength + usDataLength + usTailLength); // Send the packet over the SPI SpiWrite(ucArgs, SIMPLE_LINK_HCI_DATA_HEADER_SIZE + usArgsLength + usDataLength + usTailLength); return(ESUCCESS); }
void RxPacket(void) { uchar i; TRX_CE=0; // Set nRF905 in standby mode CSN=0; // Spi enable for write a spi command SpiWrite(RRP); // Read payload command for (i=0;i<32;i++) { RxBuf[i]=SpiRead(); // Read data and save to buffer } CSN=1; // Disable spi while(DR||AM) //等待... /////////////如果接收不到程序将停滞 数据准备就绪以及地址匹配 ; //即如果没有匹配的905模块时,这一句需要注释掉 TRX_CE=1; //允许发生或接收 ?????????????????????????? if(RxBuf[0] == 1) { LED1 = 0 ; } /* if(RxBuf[1] == 1) { LED2 = 0 ; } if(RxBuf[2] == 1) { LED3 = 0 ; } if(RxBuf[3] == 1) { LED4 = 0 ; }*/ Delay(500); // ...light led LED1 = 1 ; LED2 = 1 ; LED3 = 1 ; LED4 = 1 ; }
//***************************************************************************** // //! hci_data_send //! //! @param usOpcode command operation code //! @param ucArgs pointer to the command's arguments buffer //! @param usArgsLength length of the arguments //! @param ucTail pointer to the data buffer //! @param usTailLength buffer length //! //! @return none //! //! @brief Initiate an HCI data write operation // //***************************************************************************** long hci_data_send(unsigned char ucOpcode, unsigned char *ucArgs, unsigned short usArgsLength, unsigned short usDataLength, const unsigned char *ucTail, unsigned short usTailLength) { unsigned char *stream; stream = ((ucArgs) + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_DATA); UINT8_TO_STREAM(stream, ucOpcode); UINT8_TO_STREAM(stream, usArgsLength); stream = UINT16_TO_STREAM(stream, usArgsLength + usDataLength + usTailLength); // Send the packet over the SPI SpiWrite(ucArgs, SIMPLE_LINK_HCI_DATA_HEADER_SIZE + usArgsLength + usDataLength + usTailLength); return(ESUCCESS); }
//***************************************************************************** // //! hci_command_send //! //! @param usOpcode command operation code //! @param pucBuff pointer to the command's arguments buffer //! @param ucArgsLength length of the arguments //! //! @return none //! //! @brief Initiate an HCI command. // //***************************************************************************** unsigned short hci_command_send(unsigned short usOpcode, unsigned char *pucBuff, unsigned char ucArgsLength) { unsigned char *stream; stream = (pucBuff + SPI_HEADER_SIZE); UINT8_TO_STREAM(stream, HCI_TYPE_CMND); stream = UINT16_TO_STREAM(stream, usOpcode); UINT8_TO_STREAM(stream, ucArgsLength); //PORTD |= (1 << PD7) | (1 << PD6); //PORTB |= (1 << PB4); //Update the opcode of the event we will be waiting for SpiWrite(pucBuff, ucArgsLength + SIMPLE_LINK_HCI_CMND_HEADER_SIZE); //PORTD &= ~((1 << PD6) | (1 << PD7)); return(0); }
/**************************************************** SpiTsInitMode ****************************************************/ static int SpiTsInitMode(struct DibBridgeContext *pContext) { unsigned char initbuffer[20]; #if (DIBCTRL_ADDR == DIBCTRL_DEFAULT_ADDR) initbuffer[0]=0x10; initbuffer[1]=0x20; #else initbuffer[0]=0x0F; initbuffer[1]=0xE0; #endif initbuffer[2]=0x00; initbuffer[3]=0x2C; initbuffer[4]=0x16; initbuffer[5]=0x00; initbuffer[6]=0x00; initbuffer[7]=0x00; initbuffer[8]=0x00; initbuffer[9]=0x3F; initbuffer[10]=0x00; initbuffer[11]=0x00; initbuffer[12]=0x00; initbuffer[13]=0x00; initbuffer[14]=0x00; initbuffer[15]=0x03; initbuffer[16]=0xFF; initbuffer[17]=0xFF; initbuffer[18]=0xFF; initbuffer[19]=0xFF; SpiWrite(pContext,initbuffer, 20); return 0; }