int main(void) { uint32_t freq; uint32_t v1; uint32_t v2; UARTInit(TERM_UART, TERM_BAUD); // open UART for comms xprintf(hello); freq = SPIInit(1, 10, 16); xprintf("\n\rSPIInit for SPI1 returns %d", freq); freq = SPIInit(2, 99, 16); xprintf("\n\rSPIInit for SPI2 returns %d", freq); xputs("\n\rSPI1: SCK (N/A) MOSI (pin 0) MISO (pin 1)"); xputs("\n\rSPI2: SCK (pin 14) MOSI (pin 15) MISO (pin 16)"); xputs("\n\rSending 0x5555 to both SPI channels..."); xputs("\n\r\n\r"); while (1) { // SPISend(1, 0x5555); // SPISend(2, 0x5555); v1 = SPIExchange(1, 0x5555); v2 = SPIExchange(2, 0x5555); xprintf("\rSPI1: %04x SPI2: %04x ", v1, v2); } }
//the following command reads multiple blocks from the sd card starting at the specified block/sector void SD_read_multiple_blocks(uint32_t sector,uint8_t* data,int numOfBlocks){ PortEx_OUTCLR(BIT3_bm, PS_BANKB); //pull SD cs low SPIInit(SPI_MODE_0_gc); SPICS(TRUE); while(SD_command(SDHC_CMD_READ_MULTIPLE_BLOCKS,sector,SDHC_DUMMY_BYTE,8) != SDHC_CMD_SUCCESS); //send command to read data //do the following for however many sectors to be read in for (int j=0;j<numOfBlocks;j++){ Buffer[1]=SDHC_DUMMY_BYTE; while(Buffer[1] != SDHC_DATA_TOKEN){ Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //wait for start of data token } for (int i=0;i<SDHC_SECTOR_SIZE;i++){ data[(i+(j*SDHC_SECTOR_SIZE))] = SPI_write(SDHC_DUMMY_BYTE); //read in the data } for (int i=0;i<2;i++){ Buffer[i] = SPI_write(SDHC_DUMMY_BYTE); //read in the 2 CRC bytes } } SD_command(SDHC_CMD_STOP_TRANSMISSION,SDHC_NO_ARGUMENTS,SDHC_DUMMY_BYTE,8); //send command to stop reading data Buffer[0] = SPI_write(SDHC_DUMMY_BYTE); //read the stuff byte Buffer[1] = FILLER_BYTE; while (Buffer[1] != SDHC_DUMMY_BYTE) Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //wait for card to finish internal processes SPICS(FALSE); SPIDisable(); PortEx_OUTSET(BIT3_bm, PS_BANKB); //pull SD cs high }
//the following command reads one sector from the sdhc card void SD_read_block(uint32_t sector,uint8_t* arrayOf512Bytes){ PortEx_OUTCLR(BIT3_bm, PS_BANKB); //pull SD cs low SPIInit(SPI_MODE_0_gc); SPICS(TRUE); for(int i=0;SD_command(SDHC_CMD_READ_SINGLE_BLOCK,sector,SDHC_DUMMY_BYTE,8) != SDHC_CMD_SUCCESS; i++) { //send command to read data if (i >= 10) { //there was no response to the command while(1); } } while(Buffer[0] != SDHC_DATA_TOKEN){ Buffer[0] = SPI_write(SDHC_DUMMY_BYTE); } for (int i=0;i<SDHC_SECTOR_SIZE;i++){ arrayOf512Bytes[i] = SPI_write(SDHC_DUMMY_BYTE); //read in the data } Buffer[12] = FILLER_BYTE; while (Buffer[12] != SDHC_DUMMY_BYTE){ Buffer[12] = SPI_write(SDHC_DUMMY_BYTE); } SPICS(FALSE); SPIDisable(); PortEx_OUTSET(BIT3_bm, PS_BANKB); //pull SD cs high }
// Read from FRAM // FRAM power (VDC-2) must be on with CS_FRAM pulled high to write protect void readFRAM (uint16_t numBytes, uint16_t startAddress) { //save SPI registers uint8_t prev_SPI_settings; ADCPower(TRUE); prev_SPI_settings = SPIC.CTRL; SPIInit(SPI_MODE_0_gc); SPIC.CTRL = FR_SPI_CONFIG_gc; SPICS(TRUE); PORTB.OUTCLR = PIN3_bm; // pull down CS_FRAM to write enable nop(); SPIC.DATA = FR_READ; while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; SPIC.DATA = *(((uint8_t*)&startAddress) + 1);; while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; SPIC.DATA = *(((uint8_t*)&startAddress) + 0);; while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; for(uint16_t i = 0; i < numBytes; i++) { SPIC.DATA = 0xAA; while(!(SPIC.STATUS & SPI_IF_bm)); FRAMReadBuffer[i] = SPIC.DATA; } PORTB.OUTSET = PIN3_bm; // CS_FRAM write protect SPICS(FALSE); SPIC.CTRL = prev_SPI_settings; }
//the following command writes one sector to the sdhc card void SD_write_block(uint32_t sector,uint8_t* data, int lengthOfData){ PortEx_OUTCLR(BIT3_bm, PS_BANKB); //pull SD cs low SPIInit(SPI_MODE_0_gc); SPICS(TRUE); int fillerBytes = SDHC_SECTOR_SIZE - lengthOfData; if (fillerBytes==SDHC_SECTOR_SIZE) fillerBytes = 0; for(int i=0;SD_command(SDHC_CMD_WRITE_SINGLE_BLOCK,sector,SDHC_DUMMY_BYTE,8) != SDHC_CMD_SUCCESS; i++){ //write to specified sector if (i >= 10) { //there was no response to the command while(1); } } Buffer[0] = SPI_write(SDHC_DUMMY_BYTE); //send 1 dummy byte as spacer SPI_write(SDHC_DATA_TOKEN); //send data token for (int i=0;i<lengthOfData;i++){ //write the data segment 1 byte at a time Buffer[i%13] = SPI_write(data[i]); } for (int i=0;i<fillerBytes;i++){ //fill the rest of the sector with filler bytes Buffer[i%13] = SPI_write(FILLER_BYTE); } Buffer[0] = SDHC_DUMMY_BYTE; for(int i=0; (i<2) || (Buffer[0] == SDHC_DUMMY_BYTE);i++){ Buffer[0] = SPI_write(SDHC_DUMMY_BYTE); //send 2 CRC dummy bytes and keep reading bytes until a response is seen } if ((Buffer[0] & SDHC_RESPONSE_STATUS_MASK) == 0x02){ //data was written successfully } while(Buffer[0] != SDHC_DUMMY_BYTE) Buffer[0] = SPI_write(SDHC_DUMMY_BYTE); //wait for card to finish internal processes SPICS(FALSE); SPIDisable(); PortEx_OUTSET(BIT3_bm, PS_BANKB); //pull SD cs high }
uint8 CC2420_Init() { uint8 status; // initialize necessary PINs SPIInit(); MAKE_CC_RSTN_OUTPUT(); MAKE_CC_VREN_OUTPUT(); MAKE_CC_CS_OUTPUT(); MAKE_FIFOP_INPUT(); MAKE_CCA_INPUT(); MAKE_SFD_INPUT(); MAKE_FIFO_INPUT(); MAKE_CC_CS_HIGH(); // power on cc2420 and initialize MAKE_CC_VREN_HIGH(); _delay_us(600); MAKE_CC_RSTN_LOW(); _delay_us(1); MAKE_CC_RSTN_HIGH(); _delay_us(1); // wait for OSC stable //while (!((CC2420_StrobCmd(CC2420_SXOSCON)) & 0x40)); status = CC2420_StrobCmd(CC2420_SXOSCON); while (!(status & 0x40)) { //CC2420_StrobCmd(CC2420_SXOSCOFF); status = CC2420_StrobCmd(CC2420_SXOSCON); } return status; }
/* * 函数:user_spi_pin_init * 说明:SPI引脚初始化 */ void ICACHE_FLASH_ATTR user_spi_pin_init(void) { #if defined(HARD_SPI) SpiAttr hSpiAttr; hSpiAttr.bitOrder = SpiBitOrder_MSBFirst; /* * SpiSpeed_0_5MHz = 160, * SpiSpeed_1MHz = 80, * SpiSpeed_2MHz = 40, * SpiSpeed_5MHz = 16, * SpiSpeed_8MHz = 10, * SpiSpeed_10MHz = 8, */ hSpiAttr.speed = SpiSpeed_0_5MHz; hSpiAttr.mode = SpiMode_Master; hSpiAttr.subMode = SpiSubMode_0; // Init HSPI GPIO WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, 2);//configure io to spi mode PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, 2);//configure io to spi mode PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, 2);//configure io to spi mode PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, 2);//configure io to spi mode SPIInit(SpiNum_HSPI, &hSpiAttr); #elif defined(SOFT_SPI) SOFT_PIN_INIT(); #else #error #error "Please define SPI Interface mode : SOFT_SPI or HARD_SPI" #endif }
int main(void) { halInit(); chSysInit(); palSetPadMode(GPIOA, GPIOA_BUTTON, PAL_MODE_INPUT_PULLDOWN); palSetPadMode(GPIOD, GPIOD_LED4, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOD, GPIOD_LED3, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOD, GPIOD_LED5, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOD, GPIOD_LED6, PAL_MODE_OUTPUT_PUSHPULL); chThdSleepSeconds(1); initUsbShell(); SPIInit(); fc_nrf_init(NULL, NRF_MODE_PTX); if(fc_nrf_test_spi_connection() == 1) { palSetPad(GPIOD, GPIOD_LED3); } while (TRUE) { palTogglePad(GPIOD, GPIOD_LED4); keepShellAlive(); chThdYield(); } }
/* ===================================================================*/ void OnChipInit(void) { GPIOInit(); SPIInit(); IIC_Init_G(); IIC_Init_M(); //SysTick_Init(); }
/******************************************************************************* ** Name: SpiDevShellBspDMA_Write ** Input:HDC dev, uint8 * pstr ** Return: rk_err_t ** Owner:hj ** Date: 2014.12.9 ** Time: 20:38:37 *******************************************************************************/ _DRIVER_SPI_SPIDEVICE_SHELL_ SHELL FUN rk_err_t SpiDevShellBspDMA_Write(HDC dev, uint8 * pstr) { rk_size_t realsize; pSPI_REG Spi_Reg; uint32 i = 0; DEBUG("SpiDevShellBspDMA_Write %d\n",SPI_CH_TEST); Spi_Reg = SpiGetCH(SPI_CH_TEST); Spi_NeedTransLen = 0; for(i=0;i<1024;i++) { Spi_TestBuffer[i++] = 0x55; Spi_TestBuffer[i] = 0xaa; } //open uart clk ScuClockGateCtr(HCLK_DMA_GATE, 1); //open rst uart ip ScuSoftResetCtr(SYSDMA_SRST, 1); DelayMs(1); ScuSoftResetCtr(SYSDMA_SRST, 0); IntRegister(INT_ID_DMA ,SpiDMAIntIsr_Test); IntPendingClear(INT_ID_DMA); IntEnable(INT_ID_DMA); DmaEnableInt(2); SPIInit(SPI_CH_TEST,0, 12*1000*1000, SPI_CTL_TXRX_MASTER_TEST | TRANSMIT_ONLY); SpiEanbleChannel(SPI_CH_TEST,0); if(SPI_TRANSMIT_ONLY == SPI_TEST_MODE) { DEBUG("SPI_TRANSMIT_ONLY\n"); Spi_Testflag = 1; SPIDmaWrite(SPI_CH_TEST); if(SPI_CH0 == SPI_CH_TEST) { DmaConfig(2, (uint32)Spi_TestBuffer, (uint32)(&(Spi_Reg->SPI_TXDR)),1024, &SPI0ControlDmaCfg_TX, NULL); } else { DmaConfig(2, (uint32)Spi_TestBuffer, (uint32)(&(Spi_Reg->SPI_TXDR)),1024, &SPI1ControlDmaCfg_TX, NULL); } } else { DEBUG("SPI_RECEIVE_ONLY\n"); //I2SInit(I2S_CH_TEST,I2S_SLAVE_MODE,I2S_EXT,I2S_TEST_FS,I2S_FORMAT,I2S_DATA_WIDTH16,I2S_NORMAL_MODE); } while(1); }
//this function deselects the sd card and turns off power to the port expander and the sd card void SD_disable(){ PortEx_DIRSET(BIT3_bm, PS_BANKB); //pull SD card CS high PortEx_OUTSET(BIT3_bm, PS_BANKB); SPIInit(SPI_MODE_0_gc); SPICS(TRUE); SPI_write(SDHC_DUMMY_BYTE); //must write a byte to spi when cd card cs is high to have sd card release MISO line SPICS(FALSE); //stop spi SPIDisable(); ADCPower(FALSE); //turn off portEX power Ext1Power(FALSE); //power down SD card }
/******************************************************************************* ** Name: SpiDevInit ** Input:HDC dev ** Return: rk_err_t ** Owner:Aaron.sun ** Date: 2014.5.30 ** Time: 9:18:00 *******************************************************************************/ _DRIVER_SPI_SPIDEVICE_INIT_ INIT FUN rk_err_t SpiDevInit(SPI_DEVICE_CLASS * pstSpiDev) { //open uart clk if(((DEVICE_CLASS*)pstSpiDev)->DevID == 0) { ScuClockGateCtr(CLK_SPI0_GATE, 0); ScuClockGateCtr(PCLK_SPI0_GATE, 0); DelayMs(1); ScuClockGateCtr(CLK_SPI0_GATE, 1); ScuClockGateCtr(PCLK_SPI0_GATE, 1); ScuSoftResetCtr(SPI0_SRST, 1); DelayMs(1); ScuSoftResetCtr(SPI0_SRST, 0); //SetSPIFreq(0,PLL_MUX_CLK,96000000); SetSPIFreq(0,XIN24M,24000000); //open rst uart ip } else if(((DEVICE_CLASS*)pstSpiDev)->DevID == 1) { ScuClockGateCtr(CLK_SPI1_GATE, 1); ScuClockGateCtr(PCLK_SPI1_GATE, 1); SetSPIFreq(1,XIN24M,24000000); //open rst uart ip ScuSoftResetCtr(SPI1_SRST, 1); DelayMs(1); ScuSoftResetCtr(SPI1_SRST, 0); } SpiDevHwInit(((DEVICE_CLASS *)pstSpiDev)->DevID, pstSpiDev->CurCh); SPIInit(((DEVICE_CLASS *)pstSpiDev)->DevID,0, pstSpiDev->stConfig[pstSpiDev->CurCh].SpiRate, pstSpiDev->stConfig[pstSpiDev->CurCh].CtrlMode); if(((DEVICE_CLASS *)pstSpiDev)->DevID == 0) { IntRegister(INT_ID_SPI0,SpiDevIntIsr0); IntPendingClear(INT_ID_SPI0); IntEnable(INT_ID_SPI0); } else if(((DEVICE_CLASS*)pstSpiDev)->DevID == 1) { IntRegister(INT_ID_SPI1,SpiDevIntIsr1); IntPendingClear(INT_ID_SPI1); IntEnable(INT_ID_SPI1); } return RK_SUCCESS; }
void SoftReset() { BYTE ipl_backup = SRbits.IPL; SRbits.IPL = 7; // disable interrupts log_printf("SoftReset()"); TimersInit(); PinsInit(); PWMInit(); ADCInit(); UARTInit(); SPIInit(); I2CInit(); InCapInit(); // TODO: reset all peripherals! SRbits.IPL = ipl_backup; // enable interrupts }
int main(){ SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlDelay(3); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1); GPIOPadConfigSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_BOTH_EDGES); GPIOIntRegister(GPIO_PORTF_BASE,PortFIntHandler); GPIOIntEnable(GPIO_PORTF_BASE, GPIO_INT_PIN_1); int i; for( i=0; i < size; i++) values[i] = 0; SysTickbegin(); SPIInit(); SendData(values,size); Wait(1000); while(1){ int i; Policia(); PadraoInit=0; MudaPadrao = 0; for(i=0; i < 3 && MudaPadrao==0; i++) Pattern3(); PadraoInit=0; MudaPadrao = 0; Ambulancia(); PadraoInit=0; MudaPadrao = 0; for(i=0; i < 3 && MudaPadrao==0; i++) Pattern2(); PadraoInit=0; MudaPadrao = 0; Pattern4(); PadraoInit=0; MudaPadrao = 0; } }
int main() { char c; char str[200]; int i; int address; int data; unsigned int mid, pid; uart0_init(); // 波特率115200,8N1(8个数据位,无校验位,1个停止位) SPIInit(); OLEDInit(); OLEDPrint(0, 0, "Hello World SPI!"); SPIFlashReadID(&mid, &pid); printf("SPI FLASH : Mid = 0x%2x, Pid = 0x%2x\n\r", mid, pid); sprintf(str, "SPI FLASH: %2x,%2x", mid, pid); OLEDPrint(2, 0, str); SPIFlashInit(); SPIFlashEraseSector(4096); SPIFlashEraseSector(1024); SPIFlashProgram(4096, "Happy NEW YEAR !", 20); SPIFlashProgram(1024, "Chinese New Year", 20); SPIFlashRead(1024, str, 18); printf("SPI Flash read from 1024: %s\n\r", str); // OLEDPrint(4, 0, str); SPIFlashRead(4096, str, 18); printf("SPI Flash read from 4096: %s\n\r", str); //OLEDPrint(6, 0, str); Test_Adc(); i2c_init(); at24cxx_write(0,0x11); data = at24cxx_read(0); if (data == 0x11) OLEDPrint(4, 0, "I2C OK!!!!"); else OLEDPrint(4, 0, "I2C ERROR!"); return 0; }
void sx1276_hal_init(void) { SpiAttr hSpiAttr; hSpiAttr.bitOrder = SpiBitOrder_MSBFirst; hSpiAttr.speed = SpiSpeed_10MHz; hSpiAttr.mode = SpiMode_Master; hSpiAttr.subMode = SpiSubMode_0; // Init HSPI GPIO WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, 2);//configure io to spi mode PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, 2);//configure io to spi mode PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, 2);//configure io to spi mode PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, 2);//configure io to spi mode SPIInit(SpiNum_HSPI, &hSpiAttr); }
//***************************************************************************** // //! Main //! //! \param none //! //! \return None //! //***************************************************************************** void main() { long lRetVal = -1; // // Initialize board configuration // BoardInit(); PinMuxConfig(); //Initialize GPIO interrupt GPIOIntInit(); //Initialize Systick interrupt SystickIntInit(); //Initialize Uart interrupt UART1IntInit(); //Initialize SPI SPIInit(); //Initalize Adafruit Adafruit_Init(); InitTerm(); //Connect the CC3200 to the local access point lRetVal = connectToAccessPoint(); //Set time so that encryption can be used lRetVal = set_time(); if(lRetVal < 0) { UART_PRINT("Unable to set time in the device"); LOOP_FOREVER(); } //Connect to the website with TLS encryption lRetVal = tls_connect(); if(lRetVal < 0) { ERR_PRINT(lRetVal); } //remote calls sendMessage() which calls http_post() which requires the return value from tls_connect() remote(lRetVal); //http_post(lRetVal); sl_Stop(SL_STOP_TIMEOUT); LOOP_FOREVER(); }
//主函数 int main() { INT8U i, j; INT16U value[2]; MCUInit(); //系统初始化 SCIInit(); //串行口初始化 SPIInit(); //SPI通信初始化 //程序总循环入口 while (1) { ADCP(3, 1, 2, value); //取33路AD转换16次平均值放入ADValue[33] SCISendN(4,(INT8U *)value); for (i=0; i<100; i++) for (j=0; j<200; j++) Delay(); } }
void writeFRAM(uint8_t* buffer, uint16_t length) { uint8_t prev_SPI_settings; ADCPower(TRUE); prev_SPI_settings = SPIC.CTRL; SPIInit(SPI_MODE_0_gc); SPIC.CTRL = FR_SPI_CONFIG_gc; SPICS(TRUE); PORTB.OUTCLR = PIN3_bm; // pull down CS_FRAM to write enable nop(); SPIC.DATA = FR_WREN; while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; PORTB.OUTSET = PIN3_bm; // latch opcode nop(); // time for CS_FRAM to accept high signal PORTB.OUTCLR = PIN3_bm; // pull down CS_FRAM to write enable nop(); SPIC.DATA = FR_WRITE; while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; //send address at which to start writing data SPIC.DATA = *(((uint8_t*)&FRAMAddress)+1); while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; SPIC.DATA = *((uint8_t*)&FRAMAddress); while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; //write data to FRAM for(uint32_t i = 0; i< length; i++){ SPIC.DATA = buffer[i]; while(!(SPIC.STATUS & SPI_IF_bm)); SPIBuffer[12] = SPIC.DATA; } PORTB.OUTSET = PIN3_bm; // pull up CS_FRAM to write protect SPICS(FALSE); SPIC.CTRL = prev_SPI_settings; //SPIC.CTRL = ADC_SPI_CONFIG_gc; //PORTC.OUTCLR = PIN4_bm; // enable SPI-SS //increment address by the written length FRAMAddress +=length; }
//the following command writes multiple blocks/sectors to the sd card starting at a specified sector (in the sd card) void SD_write_multiple_blocks(uint32_t sector,uint8_t* data,int lengthOfData){ PortEx_OUTCLR(BIT3_bm, PS_BANKB); //pull SD cs low SPIInit(SPI_MODE_0_gc); SPICS(TRUE); int numSectors = lengthOfData/SDHC_SECTOR_SIZE; int fillerBytes = SDHC_SECTOR_SIZE - lengthOfData%SDHC_SECTOR_SIZE; if (fillerBytes==SDHC_SECTOR_SIZE) fillerBytes = 0; else numSectors++; while(SD_command(SDHC_CMD_WRITE_MULTIPLE_BLOCKS,sector,SDHC_DUMMY_BYTE,8) != SDHC_CMD_SUCCESS); //write starting at specified sector for (int j=0;j<numSectors;j++){ Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //send dummy byte Buffer[1] = SPI_write(SDHC_MULT_WRITE_DATA_TOKEN); //send data token if(j == (numSectors-1)){ for (int i=0;i<(SDHC_SECTOR_SIZE-fillerBytes);i++){ Buffer[i%12] = SPI_write(data[(i+(j*SDHC_SECTOR_SIZE))]); } for (int i=0;i<fillerBytes;i++){ Buffer[i%12] = SPI_write(FILLER_BYTE); } } else{ for (int i=0;i<SDHC_SECTOR_SIZE;i++){ Buffer[i%12] = SPI_write(data[(i+(j*SDHC_SECTOR_SIZE))]); } } for (int i=0;i<2;i++) Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //write 2 CRC token Buffer[1] = FILLER_BYTE; while(Buffer[1] != SDHC_DUMMY_BYTE) Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //wait for card to store the data it received } for(int i=0;i<4;i++){ Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //write dummy byte } Buffer[1] = SPI_write(SDHC_MULT_WRITE_STOP_TOKEN); //write stop token for(int i=0;i<4;i++){ Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //write dummy byte } Buffer[1] = FILLER_BYTE; while (Buffer[1] != SDHC_DUMMY_BYTE) Buffer[1] = SPI_write(SDHC_DUMMY_BYTE); //wait for card to finish internal processes SPICS(FALSE); SPIDisable(); PortEx_OUTSET(BIT3_bm, PS_BANKB); //pull SD cs high }
/* * @brief Initialize the minimal amount of hardware for the bootloader to function * @returns void */ void systemInit(void) { uint32 i, j; MAP_IntMasterDisable(); // increase LDO voltage so that PLL operates properly MAP_SysCtlLDOSet(SYSCTL_LDO_2_75V); #ifdef PART_LM3S8962 MAP_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); #endif systemIDInit(); blinkyLedInit(); buttonsInit(); srand(roneID); serialInit(); #if defined(RONE_V9) || defined(RONE_V12) SPIInit(); radioInit(); #endif // defined(RONE_V9) || defined(RONE_V12) // Triple blink blinky, startup signal for (i = 0; i < 3; i++) { blinkyLedSet(1); for (j = 0; j < 150000;) { j++; } blinkyLedSet(0); for (j = 0; j < 250000;) { j++; } } // Initialize 24-bit Systick SysTickPeriodSet(0xffffff); SysTickEnable(); }
BOOL SDInit(void) { int i; U8 bResp; U32 ulOCR; U32 ulData; eCardType = eCardUnknown; // init SPI subsystem SPIInit(); // set low SPI speed SPISetSpeed(400000); // send at least 74 clocks with no chip select SPITick(10); // send CMD_GO_IDLE_STATE for (i = 0; i < 100; i++) { bResp = SDCommand(CMD_GO_IDLE_STATE, 0); if (bResp != 0xFF) { break; } } if (bResp != R1_IDLE_STATE) { DBG("CMD_GO_IDLE_STATE failed (0x%02X)!\n", bResp); return FALSE; } // send CMD8 bResp = SDCommand(CMD_SEND_IF_COND, 0x1AA); if (bResp == 1) { // Ver2.00 or later SD memory card ulData = SDExtraResp(4); if (ulData != 0x1AA) { DBG("CMD8 data 0x%08X\n", ulData); return FALSE; } if (!SDSendOpCond(OCR_HCS)) { DBG("SDSendOpCond failed!\n"); return FALSE; } // Check CCS bit if (!SDReadOCR(&ulOCR)) { DBG("ReadOCR failed!\n"); return FALSE; } eCardType = ((ulOCR & OCR_HCS) != 0) ? eCardSDV2HC : eCardSDV2; } else { // Ver1.X SD memory card or other if (!SDSendOpCond(0)) { DBG("SDSendOpCond failed!\n"); return FALSE; } eCardType = eCardSDV1; } // set high SPI speed SPISetSpeed(25000000); return TRUE; }
/** * Constructs the AHRS class using SPI communication and the default update rate. *<p> * This constructor should be used if communicating via SPI. *<p> * @param spi_port_id SPI port to use. */ AHRS::AHRS(SPI::Port spi_port_id) { SPIInit(spi_port_id, DEFAULT_SPI_BITRATE, NAVX_DEFAULT_UPDATE_RATE_HZ); }
AHRS::AHRS(SPI::Port spi_port_id, uint32_t spi_bitrate, uint8_t update_rate_hz) { SPIInit(spi_port_id, spi_bitrate, update_rate_hz); }
AHRS::AHRS(SPI::Port spi_port_id, uint8_t update_rate_hz) { SPIInit(spi_port_id, DEFAULT_SPI_BITRATE, update_rate_hz); }
/******************************************************************************* HardwareInit All port directioning and SPI must be initialized before calling ZigBeeInit(). For demonstration purposes, required signals are configured individually. *******************************************************************************/ void HardwareInit(void) { //------------------------------------------------------------------------- // This section is required to initialize the PICDEM Z for the CC2420 // and the ZigBee Stack. //------------------------------------------------------------------------- #ifdef USE_EXTERNAL_NVM EEPROM_nCS = 1; EEPROM_nCS_TRIS = 0; #endif #if defined(USE_EXTERNAL_NVM) && !defined(EE_AND_RF_SHARE_SPI) RF_SPIInit(); EE_SPIInit(); #else SPIInit(); #endif // Inicializa o Transceiver TransceiverInit(); #if defined(USE_EXTERNAL_NVM) && !defined(EE_AND_RF_SHARE_SPI) // Initialize the SPI1 pins and directions LATCbits.LATC3 = 0; // SCK LATCbits.LATC5 = 1; // SDO TRISCbits.TRISC3 = 0; // SCK TRISCbits.TRISC4 = 1; // SDI TRISCbits.TRISC5 = 0; // SDO // Initialize the SPI2 pins and directions LATDbits.LATD6 = 0; // SCK LATDbits.LATD4 = 1; // SDO TRISDbits.TRISD6 = 0; // SCK TRISDbits.TRISD5 = 1; // SDI TRISDbits.TRISD4 = 0; // SDO RF_SSPSTAT_REG = 0x40; RF_SSPCON1_REG = 0x21; EE_SSPSTAT_REG = 0x40; EE_SSPCON1_REG = 0x21; #else // Initialize the SPI pins and directions LATCbits.LATC3 = 0; // SCK LATCbits.LATC5 = 1; // SDO TRISCbits.TRISC3 = 0; // SCK TRISCbits.TRISC4 = 1; // SDI TRISCbits.TRISC5 = 0; // SDO SSPSTAT_REG = 0x40; SSPCON1_REG = 0x20; #endif //------------------------------------------------------------------------- // This section is required for application-specific hardware // initialization. //------------------------------------------------------------------------- // D1 and D2 are on RA0 and RA1 respectively, and CS of the TC77 is on RA2. // Make PORTA digital I/O. ADCON1 = 0x0F; // Deselect the TC77 temperature sensor (RA2) LATA = 0x04; // Make RA0, RA1, RA2 and RA4 outputs. TRISA = 0xE0; // Clear the RBIF flag (INTCONbits.RBIF) INTCONbits.RBIF = 0; // Enable PORTB pull-ups (INTCON2bits.RBPU) INTCON2bits.RBPU = 0; // Make the PORTB switch connections inputs. TRISBbits.TRISB4 = 1; TRISBbits.TRISB5 = 1; }
int SPI3W_sendCommand(char cmd){ int ret=0; Transfer f = { .data = cmd, .type = 0, }; void* structure = &f; //printf("%i\n", sizeof(Transfer)); ret = SPIWriteWord(structure); if(ret == -1) pabort("Invalid Command"); return ret; } int SPI3W_sendData(char datal){ int ret=0; Transfer f = { .data = datal, .type = 1, }; void* structure = &f; //printf("%i\n", sizeof(Transfer)); ret = SPIWriteWord(structure); if(ret == -1) pabort("Invalid Data"); return ret; } int init_tft(int deviceNum) { int ret=0; int SPISpeed = 2000000; ret = initResetPin(); if(ret == -1){ pabort("Unable to initialize reset PIN"); } ret = SPIInit(deviceNum, 9, SPISpeed); if(ret < 0){ pabort("Unable to initialize SPI"); } //***************************RESET LCD Driver******************************* // SET RST Pin high resetSet(); usleep(1000); // SET RST Pin low resetClear(); usleep(20000); // SET RST Pin high resetSet(); usleep(120000); SPI3W_sendCommand(0x11); // Sleep out and Charge Pump on usleep(120000); SPI3W_sendCommand(0xB1); //SETPWCTR SPI3W_sendData(0x02); SPI3W_sendData(0x35); SPI3W_sendData(0x36); SPI3W_sendCommand(0xB2); //SETDISPLAY SPI3W_sendData(0x02); SPI3W_sendData(0x35); SPI3W_sendData(0x36); SPI3W_sendCommand(0xB3); //Doesn't exist SPI3W_sendData(0x02); SPI3W_sendData(0x35); SPI3W_sendData(0x36); SPI3W_sendData(0x02); SPI3W_sendData(0x35); SPI3W_sendData(0x36); SPI3W_sendCommand(0xB4); //SETCYC SPI3W_sendData(0x07); SPI3W_sendCommand(0xC0); //SETSTBA SPI3W_sendData(0xa2); SPI3W_sendData(0x02); SPI3W_sendData(0x04); SPI3W_sendCommand(0xc1); //Doesn't exist SPI3W_sendData(0xc5); SPI3W_sendCommand(0xc2); //Doesn't exist SPI3W_sendData(0x0d); SPI3W_sendData(0x00); SPI3W_sendCommand(0xc3); // SETID SPI3W_sendData(0x8d); SPI3W_sendData(0x1a); SPI3W_sendCommand(0xc4); //Doesn't exist SPI3W_sendData(0x8d); SPI3W_sendData(0xee); SPI3W_sendCommand(0xc5); //Doesn't exist SPI3W_sendData(0x09); SPI3W_sendCommand(0xE0); //Gamma setting For LGIT Panel SPI3W_sendData(0x0a); SPI3W_sendData(0x1c); SPI3W_sendData(0x0c); SPI3W_sendData(0x14); SPI3W_sendData(0x33); SPI3W_sendData(0x2b); SPI3W_sendData(0x24); SPI3W_sendData(0x28); SPI3W_sendData(0x27); SPI3W_sendData(0x25); SPI3W_sendData(0x2C); SPI3W_sendData(0x39); SPI3W_sendData(0x00); SPI3W_sendData(0x05); SPI3W_sendData(0x03); SPI3W_sendData(0x0d); SPI3W_sendCommand(0xE1); //Doesn't exist SPI3W_sendData(0x0a); SPI3W_sendData(0x1c); SPI3W_sendData(0x0c); SPI3W_sendData(0x14); SPI3W_sendData(0x33); SPI3W_sendData(0x2b); SPI3W_sendData(0x24); SPI3W_sendData(0x28); SPI3W_sendData(0x27); SPI3W_sendData(0x25); SPI3W_sendData(0x2D); SPI3W_sendData(0x3a); SPI3W_sendData(0x00); SPI3W_sendData(0x05); SPI3W_sendData(0x03); SPI3W_sendData(0x0d); SPI3W_sendCommand(0x3A); //Doesn't exist SPI3W_sendData(0x06); SPI3W_sendCommand(0x29); //Display On usleep(150); }
/** * Constructs the AHRS class using SPI communication and the default update rate. *<p> * This constructor should be used if communicating via SPI. *<p> * @param spi_port_id SPI port to use. */ AHRS::AHRS(SPI::Port spi_port_id) { printf("AHRS Constructor!\n"); SPIInit(spi_port_id, DEFAULT_SPI_BITRATE, NAVX_DEFAULT_UPDATE_RATE_HZ); }
AHRS::AHRS(SPI::Port spi_port_id, uint32_t spi_bitrate, uint8_t update_rate_hz) { printf("AHRS Constructor!\n"); SPIInit(spi_port_id, spi_bitrate, update_rate_hz); }
AHRS::AHRS(SPI::Port spi_port_id, uint8_t update_rate_hz) { SPIInit(spi_port_id, DEFAULT_SPI_BITRATE, update_rate_hz); printf("AHRS Constructor!\n"); }