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");
}
