//__________________________________________________________________________________________________ void anibike_dl_master_initialize ( void ) { // Set pull-down and wired-or so that there will be no problems PORT_ConfigurePins( &DATALINK_PORT, DATALINK_CLK_PIN|DATALINK_DATA_PIN, false, false, PORT_OPC_TOTEM_gc, PORT_ISC_INPUT_DISABLE_gc ); PORT_ConfigurePins( &DATALINK_PORT, DATALINK_CS_PIN, false, false, PORT_OPC_WIREDANDPULL_gc, PORT_ISC_INPUT_DISABLE_gc ); DATALINK_PORT.DIRSET = DATALINK_CLK_PIN|DATALINK_DATA_PIN|DATALINK_CS_PIN; DATALINK_PORT.OUTSET = DATALINK_CS_PIN; /* Initialize SPI master on port DATAFLASH_PORT. */ SPI_MasterInit(&spiMasterC, &DATALINK_SPI, &DATALINK_PORT, false, SPI_MODE_0_gc, SPI_INTLVL_OFF_gc, false, SPI_PRESCALER_DIV4_gc,1); // drive cs to high DATALINK_PORT.OUTSET = DATALINK_CS_PIN; }
int main(void) { cli(); CCP = 0xd8; CLKPR = 3; // 1/8 clock prescaler sei(); // power saver - uart PRR &= ~(1 << PRUSART0); init_uart(); //power saver - spi PRR &= ~(1 << PRSPI); SPI_MasterInit(); struct bme280_t s1, s2; s1.dev_addr = 1; s2.dev_addr = 2; init_bme280(&s1); init_bme280(&s2); while(1) { measure(&s1); measure(&s2); transmit_string("----\r\n"); _delay_ms(1000); } }
void cc2500_Init(uint8_t power) { prog_uint8_t *init = cc2500InitValue; SET_BIT(PORTB, OUT_B_SPI_SCK); RES_BIT(PORTB, OUT_B_SPI_MOSI); RES_BIT(PORTB, OUT_B_SPI_SS); _delay_us(40); // warten 40us SPI_MasterInit(); _delay_us(40); // warten 40us cc2500_Reset(); cc2500_Off(); // SS wegnehmen SPI_MasterTransmit(CC2500_IOCFG2 | CC2500_WRITE_BURST); do { SPI_MasterTransmit(pgm_read_byte(init++)); } while(init < (cc2500InitValue + sizeof(cc2500InitValue) - 3)); cc2500_Off(); // SS wegnehmen wegen Burst SPI_MasterTransmit(CC2500_TEST2 | CC2500_WRITE_BURST); do { SPI_MasterTransmit(pgm_read_byte(init++)); } while(init < (cc2500InitValue + sizeof(cc2500InitValue))); cc2500_Off(); // SS wegnehmen wegen Burst cc2500setPatableMax(power); }
int main(void) { SPI_MasterInit(); btInit(); interruptINT1_init(); sei(); btTransmit(0); //moveRobot(ACTIVATE_HIT); while(1) { BT_SensorValues(); getSensorValues(); setVariables(); dataValues[LIFE] = lifeCount; //Start of AI program that should keep the robot within the boundaries of the tape track moveRobot(LED | lifeCount); if(!lifeCount) { sensorControlDead(); if(TapeFlag >= 0x03 && counting == 0) { counting = 1; timerValue = TIMER_1A_SECOND; timer_init(); } else if(counting == 2) { while(1) { moveRobot(STOP); } } } else { if(hit == 0) { activateHitFlag = 0; hitFlag = 1; } if (hit == 1 && activateHitFlag) { moveRobot(IR_ON); moveRobot(ACTIVATE_HIT); } else if(hit == 1 && hitFlag == 1) { hitFlag = 0; lifeCount = lifeCount >> 1; timer0_init(); } else if (hit == 1 && !activateHitFlag) { moveRobot(IR_OFF); } if(!sprayPray) { idle(); } }
void NT7534_Init(){ //nastaveni portu PIN_A0_DDR = 1; //data PIN_RES_DDR = 1; //reset NT7534_CS_DDR = 1; //cs //init values //reset RES = 0; delay_us(50); RES = 1; //CS deactive NT7534_CLEAR_CS; //init SPI SPI_MasterInit(); delay_us(50); //init display NT7534_Display_Init(); delay_us(50); NT7534_clear_screen(); delay_us(50); knuerr_logo(); }
int main (void) { TWI_init(); //TWI Bus Initialisieren TWI_59116_reset(); TWI_59116_setup(); if(CORE==Master){ DDRA=0xff; //PORTA als Ausgang DDRD|=(1<<2); // PD2 als Ausgang Interrupt_init(); sei(); SPI_MasterInit(); Ebene_ein=0; while(1) { effect_blinky2(1); //ok effect_planboing(0,AXIS_Z,20); //ok effect_planboing(1,AXIS_X,20); //ok effect_planboing(0,AXIS_Y,20); //ok effect_planboing(1,AXIS_Z,20); //ok for (uint8_t ii=0;ii<8;ii++) effect_box_shrink_grow (0,ii%4, ii & 4, 20); //ok //sendvoxels_rand_z(100,10,20); // ok effect_random_sparkle (1,3,20,10); //ok effect_box_woopwoop(1,40,1); //naja effect_rain(0,300); //ok //effect_wormsqueeze (2, AXIS_Z, 1, 100, 25); //ok for(int i=0;i<8;i++){ // Pixel durchtesten for(int j=0;j<64;j++) { LED[0][i][j/8][j%8]=0xff; _delay_us(500); } for(int j=0;j<64;j++) { LED[0][i][j/8][j%8]=0; _delay_us(500); } } } }else{ DDRA=0x00; //PORTA als Eingang DDRD&=~(1<<2); // PD2 als Eingang SPI_SlaveInit(); Ebene_ein=0; while(1) { I2C_Leds_ein(Ebene_ein%8); //Säulentreiber einschalten für nächste Ebene } } return 0; }
void main(void) { SPI_MasterInit(); ip_init(); while (1){ ip_task(); } }
/** \brief Initializes the ADC. * * All library functions in this library take the adc given here as their first * parameter. This function initializes it for future communication with the * ADC. This library uses the SPI library to communicate with the ADC, set up * in interrupt driven packet transfer mode, at 2MHz clock frequency. This * library performs bus arbitration through the SPI_driver.c library, however, * it is still a good idea to limit the ADC as the only peripheral on the bus * for performance reasons. * * \param[out] adc the adc to initialize * \param[in] control_port pointer to the control port for the ADC * \param[in] CONVST_bm /CONVST pin bit mask (on control_port) * \param[in] EOC_bm /EOC pin bit mask (on control_port) * \param[in] SPI_port pointer to the SPI port for the ADC * \param[in] SPI_module the SPI module to use * \param[in] RFS_bm /RFS pin bit mask (on SPI_port) */ void ADC_init(ADC_ext_t *adc, PORT_t *control_port, uint8_t CONVST_bm, uint8_t EOC_bm, PORT_t *SPI_port, SPI_t *SPI_module, uint8_t RFS_bm) { /* initialize the adc */ adc->control_port = control_port; adc->CONVST_bm = CONVST_bm; adc->SPI_port = SPI_port; adc->RFS_bm = RFS_bm; adc->SPI_master = malloc(sizeof(SPI_Master_t)); adc->data_packet = malloc(sizeof(SPI_DataPacket_t)); adc->ready = true; adc->continuous = false; adc->callback = NULL; /* enable /CONVST pin as output */ control_port->DIRSET = CONVST_bm; PORTCFG.MPCMASK = CONVST_bm; control_port->PIN0CTRL = PORT_OPC_TOTEM_gc; control_port->OUTSET = CONVST_bm; control_port->OUTCLR = CONVST_bm; control_port->OUTSET = CONVST_bm; /* Init /RFS pin as output with push/pull configuration */ SPI_port->DIRSET = RFS_bm; PORTCFG.MPCMASK = RFS_bm; SPI_port->PIN0CTRL = PORT_OPC_TOTEM_gc; SPI_port->OUTSET = RFS_bm; SPI_port->OUTCLR = RFS_bm; SPI_port->OUTSET = RFS_bm; /* Initialize SPI master on port C, which also sets up SPI interrupt */ SPI_MasterInit(adc->SPI_master, // SPI_master_t struct to use SPI_module, // SPI module to use (see board.h) SPI_port, // SPI port to use (see board.h) false, // lsb_first = false SPI_MODE_2_gc, // data on leading falling edge SPI_INTLVL_MED_gc, // SPI interrupt priority false, // clock2x = false SPI_PRESCALER_DIV64_gc); // division scaler (2MHz) /* enable interrupts on /EOC for falling edge * (ADC pulls low to signal conversion ready) */ control_port->DIRCLR = EOC_bm; // EOC pin is input PORTCFG.MPCMASK = EOC_bm; control_port->PIN0CTRL = PORT_ISC_FALLING_gc; // pulled low when ready control_port->INT0MASK |= EOC_bm; // enable EOC interupt mask control_port->INTCTRL = PORT_INT0LVL_LO_gc; // enable LO level interrupts /* enable low and med level interrupts */ PMIC.CTRL |= PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm; }
int main () { /* Configure port D pin 0 as output * for signaling when tests pass */ DDR_SIGNAL = (1<<DD_SIGNAL); uint8_t i, byte_received; SPI_MasterInit(); for (i=0; i<100; i++) { SPI_MasterTransmit(0x81); _delay_ms(5); /* is SPI interrupt flag set? */ if (SPSR == 0x80) { /* if SPI interrupt flag is set * clear it by reading the data * in SPI data register */ byte_received = SPI_ReadData(); set_bit(SIGNAL_PORT, SIGNAL); //_delay_ms(25); /* did clearing interrupt * flag succeed? */ if (SPSR == 0x00) { /* if yes blink LED */ clear_bit(SIGNAL_PORT, SIGNAL); //_delay_ms(25); } } /* if flag is not set blink slowly * forever */ else { while (1) { set_bit(SIGNAL_PORT, SIGNAL); _delay_ms(500); clear_bit(SIGNAL_PORT, SIGNAL); _delay_ms(500); } } } /* if all is well, after completing * the requested transmissions * the LED should go off and the * processeor should do nothing * happily ever after */ while (1); ; return (0); }
void matrix_init(void) { SPI_MasterInit(); matrix_transmit(OP_SHUTDOWN,0b00000000); matrix_clear(); matrix_transmit(OP_DISPLAYTEST,0x00); matrix_transmit(OP_SCANLIMIT,0x07); matrix_transmit(OP_DECODEMODE,0x00); matrix_transmit(OP_INTENSITY,0x0F); matrix_transmit(OP_SHUTDOWN,0b00000001); }
int main( void ) { cli(); setup_clock(); InitBuffer(&ab); //Don't touch any PORTB below 4, those are for printf // SetupPrintf(); USB_ZeroPrescaler(); USB_Init(); DDRC = 0x0; SPI_MasterInit(); // _delay_ms(10); //wait for tiny 44 to be ready for data // setup_timers(); setup_channel_interrupt(); DDRD |= _BV(PD6); sei(); // testAsm(); // if (testPtr == 'w') PORTD |= _BV(PD6); while(1) { UENUM = 4; //interrupts can change this //these if statements can take a bit of time so run them and save the //result for future use if ( USB_READY(UEINTX) && (BytesFree(&ab) >= 8) ) dataState=1; else if ( BytesUsed(&ab) >= 2) dataState=2; else dataState=0; while (needAudioFlag==0); cli(); needAudioFlag=0; DoAudioState(); sei(); } return 0; }
void oled_init() { SPI_MasterInit(); DDRB|=(1<<PB0)|(1<<PB1); PORTB&=~(1<<PB0); _delay_ms(50); PORTB|=(1<<PB0); PORTB&=~(1<<PB1); //发送命令 SPI_MasterTransmit(0xae);//--turn off oled panel SPI_MasterTransmit(0x00);//---set low column address SPI_MasterTransmit(0x10);//---set high column address SPI_MasterTransmit(0x40);//--set start line address Set Mapping RAM Display Start Line (0x00~0x3F) SPI_MasterTransmit(0x81);//--set contrast control register SPI_MasterTransmit(0xcf); // Set SEG Output Current Brightness SPI_MasterTransmit(0xa1);//--Set SEG/Column Mapping 0xa0左右反置 0xa1正常 SPI_MasterTransmit(0xc8);//Set COM/Row Scan Direction 0xc0上下反置 0xc8正常 SPI_MasterTransmit(0xa6);//--set normal display SPI_MasterTransmit(0xa8);//--set multiplex ratio(1 to 64) SPI_MasterTransmit(0x3f);//--1/64 duty SPI_MasterTransmit(0xd3);//-set display offset Shift Mapping RAM Counter (0x00~0x3F) SPI_MasterTransmit(0x00);//-not offset SPI_MasterTransmit(0xd5);//--set display clock divide ratio/oscillator frequency SPI_MasterTransmit(0x80);//--set divide ratio, Set Clock as 100 Frames/Sec SPI_MasterTransmit(0xd9);//--set pre-charge period SPI_MasterTransmit(0xf1);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock SPI_MasterTransmit(0xda);//--set com pins hardware configuration SPI_MasterTransmit(0x12); SPI_MasterTransmit(0xdb);//--set vcomh SPI_MasterTransmit(0x40);//Set VCOM Deselect Level SPI_MasterTransmit(0x20);//-Set Page Addressing Mode (0x00/0x01/0x02) SPI_MasterTransmit(0x02);// SPI_MasterTransmit(0x8d);//--set Charge Pump enable/disable SPI_MasterTransmit(0x14);//--set(0x10) disable SPI_MasterTransmit(0xa4);// Disable Entire Display On (0xa4/0xa5) SPI_MasterTransmit(0xa6);// Disable Inverse Display On (0xa6/a7) SPI_MasterTransmit(0xaf);//--turn on oled panel /* SPI_MasterTransmit(0xAF); SPI_MasterTransmit(0x40); SPI_MasterTransmit(0xA0); SPI_MasterTransmit(0xA6); SPI_MasterTransmit(0xA4); SPI_MasterTransmit(0xA2); SPI_MasterTransmit(0xC8); SPI_MasterTransmit(0x2F); SPI_MasterTransmit(0x24); SPI_MasterTransmit(0x81); SPI_MasterTransmit(0x24); */ oled_clear(); }
int main() { DDRC=255; //PORTC as output,used for Slave Selections while(1) { PORTC=0; _delay_ms(1000); SPI_MasterInit(); SPI_MasterTransmit(255); PORTC=255; _delay_ms(1000); PORTC=0; _delay_ms(1000); SPI_MasterInit(); SPI_MasterTransmit(0); PORTC=255; _delay_ms(1000); } return 0; }
int main(void) { //usart_init (UBRR_VAL);//инициализация модуля SPI_MasterInit();//инициализация SPI nRF24L01_init(0b00000011);//инициализация модуля nrf24l01_RX_TX_mode(PRX);//переходим в режим приемника while(1) { mSend(4);//внешний mSend(3);//кухня mSend(2);//ванная } }
int main(void) { PORTB=0xFF; DDRB=0xFF; SPI_MasterInit(); while (1) { SPI_MasterTransmit(0x37); _delay_ms(500); SPI_MasterTransmit(0x38); _delay_ms(500); SPI_MasterTransmit(0x39); _delay_ms(500); } }
void init(void) { clock_prescale_set(clock_div_2); // we run at 3.3v fdev_setup_stream(&mystdout, uart_putchar, NULL, _FDEV_SETUP_WRITE); stdout = &mystdout; usb_init(); MRF_RESET_CONFIG; MRF_CS_CONFIG; SPI_MasterInit(); // interrupt pin from mrf EIMSK |= (1<<INT0); while (!usb_configured()) { } // Advised to wait a bit longer by pjrc.com // as not all drivers will be ready even after host is up _delay_ms(500); }
int main(void) { char highbyte, lowbyte; SPI_MasterInit(); int i; i = MCP_START; // MCP4921 initial value while(1) { for (i=MCP_START; i<MCP_START+4096; i+=2) { highbyte = i>>8; lowbyte = i; PORTB &= ~(1<<2); //SS sets to low SPI_MasterTransmit(highbyte); SPI_MasterTransmit(lowbyte); PORTB |= 1<<2; //SS sets to high } } }
int main(void) { struct LCD_Geometry *pointCurrent= &Current; struct LCD_Properties *pointProperties= &Properties; FILE lcd_str = FDEV_SETUP_STREAM(TerminalChar, NULL, _FDEV_SETUP_RW); //FILE lcd_str = FDEV_SETUP_STREAM(USART_send, NULL, _FDEV_SETUP_RW); char *hellow = "hello"; stdout = &lcd_str; USART_init(); SPI_MasterInit(); SSD1289_Initalize(); testLibrary(); //ReadBMP_ARRAY(40,40,BMP_IMAGE); }
void Radio_RxInit() { SPI_MasterInit(); DDRB|=(1<<CSN)|(1<<CE); PORTB|=(1<<IRQ)|(1<<CSN); delay_ms(5); unsigned char oneByte[1]={0x33}; unsigned char threeByte[3]={0x18, 0x04, 0x96}; writeRegister(0x00, oneByte, 1); //set config reg to power up into rx mode oneByte[0]=0x01; writeRegister(0x03, oneByte, 1); //set address length to 3 bytes writeRegister(0x0A, threeByte, 3); //set address of pipe 0 to random number, in this case my birthday oneByte[0]=76; writeRegister(0x05, oneByte, 1); //set channel to 76 oneByte[0]=0x00; writeRegister(0x01, oneByte, 1); //turn off auto acknowledge oneByte[0]=5; writeRegister(0x11, oneByte, 1); //set packet length for pipe 0 flushRx(); PORTB|=(1<<CE); }
void Radio_TxInit() { SPI_MasterInit(); DDRB|=(1<<CSN)|(1<<CE); PORTB|=(1<<IRQ)|(1<<CSN); delay_ms(5); //settling time specified in the data sheet unsigned char oneByte[1]={0x72}; unsigned char threeByte[3]={0x18, 0x04, 0x96}; writeRegister(0x00, oneByte, 1); //set config reg to power up into tx mode oneByte[0]=0x01; writeRegister(0x03, oneByte, 1); //set address length to 3 bytes writeRegister(0x10, threeByte, 3); //set address of transmit to random number, in this case my birthday oneByte[0]=76; writeRegister(0x05, oneByte, 1); //set to channel 76 oneByte[0]=0x00; writeRegister(0x01, oneByte, 1); //turn off Auto Acknowledge, one way communication okay if a few packets get dropped writeRegister(0x04, oneByte, 1); //turn off retransmit, not ideal for remote control oneByte[0]=0x01; writeRegister(0x1D, oneByte, 1); //enable W_TX_PAYLOAD_NOACK flushTx(); PORTB|=(1<<CE); }
void SPI_Init(u08 mode,u08 prescale) { //variable unsigned char temp; //set these pins H SPI_PORT |= (1<<MOSI_PIN)|(1<<MISO_PIN)|(1<<SCK_PIN); //setup SPI SPI_SCKspeed(prescale); SPI_Modeselect(mode); SPI_MasterInit(); //clear SPI interrupt flag temp = SPSR; temp = SPDR; }
int main(void) { /* desabilita os pinos de RX e TX */ UCSR0B=0x00; /* Para uso do botão */ DDRB &= (~(1 << PB0)); PORTB |= (1 << PB0); LCD_inicia_4bits(); SPI_MasterInit(); while(1) { if(!tst_bit(PINB, PB0)) { SPI_HABILITA_SLAVE(); _delay_ms(20); SPI_Transmit('A'); SPI_DESABILITA_SLAVE(); while(!tst_bit(PINB, PB0)); } } }
int main(void) { unsigned int XXL,YXL,ZXL; //unsigned int ADC1,ADC2,ADC3; // int16_t ZGY; unsigned int XGY,YGY,ZGY; // unsigned char XYZ_buffer[100]; unsigned int timer=0; unsigned int timer_old=0; unsigned int diff_counter=0; unsigned int m_IMU_count=0; double m_XXL_sum=0; double m_YXL_sum=0; double m_ZXL_sum=0; double m_XGY_sum=0; double m_YGY_sum=0; double m_ZGY_sum=0; clk_init(); port_init(); USART_INIT(); timer_Init(); int_init(); // sei(); // spi_init(); /* Init SS pin as output with wired AND and pull-up. */ //120813 portC를 D로 바꿈 SPI인거 같아서 PORTD.DIRSET = PIN0_bm; PORTD.PIN0CTRL = PORT_OPC_WIREDANDPULL_gc; PORTD.DIRSET = PIN1_bm; PORTD.PIN1CTRL = PORT_OPC_WIREDANDPULL_gc; /* Set SS output to high. (No slave addressed). */ PORTD.OUTSET = PIN0_bm; PORTD.OUTSET = PIN1_bm; /* Instantiate pointer to ssPort. */ PORT_t *ssPort = &PORTD; /* Initialize SPI master on port D. */ SPI_MasterInit(&spiMasterD, &SPID, &PORTD, false, SPI_MODE_3_gc, SPI_INTLVL_OFF_gc, false, SPI_PRESCALER_DIV16_gc); /* Use USARTD0 and initialize buffers. */ USART_InterruptDriver_Initialize(&USARTD0_data, &USARTD0, USART_DREINTLVL_HI_gc); /* Enable RXC interrupt. */ USART_RxdInterruptLevel_Set(USARTD0_data.usart, USART_RXCINTLVL_HI_gc); /* Enable PMIC interrupt level low. */ PMIC.CTRL |= PMIC_HILVLEX_bm; /* Enable global interrupts.*/ sei(); /* Initialize ACC & Gyro */ // Init_L3G4200DH(); Init_LIS3DH(); SPI_MasterCreateDataPacket(&dataPacket, masterSendData_gyro_init, GYRO_DATA, NUM_BYTES, &PORTD, PIN1_bm); SPI_MasterSSLow(ssPort, PIN1_bm); /* Transceive packet. */ SPI_MasterTransceivePacket(&spiMasterD, &dataPacket); /* MASTER: Release SS to slave. */ SPI_MasterSSHigh(ssPort, PIN1_bm); // USART_Rx_Enable(&USARTD0); // USART_Tx_Enable(&USARTD0); double z_deg=0; unsigned int oldT=0; unsigned int newT=0; unsigned int dT=0; int i; double x1m=0; double x1p=0; double P1p=1.0; double x2m[4]={0,0,0,0}; double x2p[4]={0,0,0,0}; double P2p[4][4]={{0.1,0,0,0}, {0,0.1,0,0}, {0,0,0.1,0}, {0,0,0,0.1}}; double enc_time_cnt=0; for(i=0;i<DELAY_COMP_G;i++) { m_XGY_buf[i]=0.0; m_YGY_buf[i]=0.0; m_ZGY_buf[i]=0.0; m_XXL_buf[i]=0.0; m_YXL_buf[i]=0.0; m_ZXL_buf[i]=0.0; m_enc_buf[i]=0.0; m_enc_timebuf[i]=0.0; m_T_buf[i]=0.0; } //char XYZ_buffer_debug[20]; //sprintf((char*)XYZ_buffer_debug,"Hello W"); //uartSendTX((unsigned char*)XYZ_buffer_debug); while(1) { //if(1) if(samplingFlag) { // adc_start_conversion(&ADCA, ADC_CH0); samplingFlag=0; timer=TCC0.CNT; diff_counter=timer-timer_old; /* Create data packet (SS to slave by PC0). */ SPI_MasterCreateDataPacket(&dataPacket, masterSendData, ACC_DATA, NUM_BYTES, &PORTD, PIN0_bm); /* MASTER: Pull SS line low. This has to be done since * SPI_MasterTransceiveByte() does not control the SS line(s). */ SPI_MasterSSLow(ssPort, PIN0_bm); _delay_us(5); /* Transceive packet. */ SPI_MasterTransceivePacket(&spiMasterD, &dataPacket); /* MASTER: Release SS to slave. */ _delay_us(5); SPI_MasterSSHigh(ssPort, PIN0_bm); /* Create data packet (SS to slave by PC1). */ SPI_MasterCreateDataPacket(&dataPacket, masterSendData_gyro, GYRO_DATA, NUM_BYTES, &PORTD, PIN1_bm); /* MASTER: Pull SS line low. This has to be done since * SPI_MasterTransceiveByte() does not control the SS line(s). */ SPI_MasterSSLow(ssPort, PIN1_bm); /* Transceive packet. */ _delay_us(5); SPI_MasterTransceivePacket(&spiMasterD, &dataPacket); /* MASTER: Release SS to slave. */ _delay_us(5); SPI_MasterSSHigh(ssPort, PIN1_bm); timer_old=timer; T=(double)diff_counter/2000000.0*32.0; ACC_DATA[2]=ACC_DATA[2]+0x80; ACC_DATA[4]=ACC_DATA[4]+0x80; ACC_DATA[6]=ACC_DATA[6]+0x80; YXL= (unsigned int)ACC_DATA[2]*256+ACC_DATA[1]; XXL= (unsigned int)ACC_DATA[4]*256+ACC_DATA[3]; ZXL= (unsigned int)ACC_DATA[6]*256+ACC_DATA[5]; GYRO_DATA[2]=GYRO_DATA[2]+0x80; GYRO_DATA[4]=GYRO_DATA[4]+0x80; GYRO_DATA[6]=GYRO_DATA[6]+0x80; XGY= (unsigned int)GYRO_DATA[4]*256+GYRO_DATA[3]; YGY= (unsigned int)GYRO_DATA[2]*256+GYRO_DATA[1]; ZGY= (unsigned int)GYRO_DATA[6]*256+GYRO_DATA[5]; if(m_IMU_count<Tsample) { m_IMU_count++; } else if(m_IMU_count<Tsample+Bsample) { m_XXL_sum+=XXL; m_YXL_sum+=YXL; m_ZXL_sum+=ZXL; //m_XGY_sum+=XGY; //m_YGY_sum+=YGY; m_ZGY_sum+=ZGY; m_IMU_count++; } else if(m_IMU_count==Tsample+Bsample) { //SetTimer(25,1,NULL); m_biasXXL=(double)m_XXL_sum/(double)Bsample; m_biasYXL=(double)m_YXL_sum/(double)Bsample; m_biasZXL=(double)m_ZXL_sum/(double)Bsample-GRAVITY_COUNT; //m_biasXGY=(double)m_XGY_sum/(double)Bsample; //m_biasYGY=(double)m_YGY_sum/(double)Bsample; m_biasZGY=(double)m_ZGY_sum/(double)Bsample; gravityVect[0]=0; gravityVect[1]=0; gravityVect[2]=SCALE_ZXL*GRAVITY_COUNT; m_IMU_count++; } else { //encoder_interface(0); //encoder_interface(1); //host_interface(); //unsigned int a=TCC0.CNT; //position_estimator(XXL,YXL,ZXL,XGY,YGY,ZGY); //unsigned int b=TCC0.CNT; //TJX=(double)(b-a)/2000000.0*32.0; //FF_controller(); newT=TCC0.CNT; dT=newT-oldT; //////////////////////////////////////////////// /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// int i,j,k; m_XXL=-SCALE_XXL*((double)XXL-(double)m_biasXXL); m_YXL=-SCALE_YXL*((double)YXL-(double)m_biasYXL); m_ZXL=SCALE_ZXL*((double)ZXL-(double)m_biasZXL); m_XGY=-SCALE_XGY*((double)XGY-(double)m_biasXGY);//-0.001212142/0.00015711 m_YGY=SCALE_YGY*((double)YGY-(double)m_biasYGY);//+ //if(ZGY<3000) m_ZGY=SCALE_ZGY*((double)ZGY-(double)m_biasZGY+65536.0); //else m_ZGY=SCALE_ZGY*((double)ZGY-(double)m_biasZGY);//+ m_ZGY=SCALE_ZGY*((double)ZGY-(double)m_biasZGY); sprintf(XYZ_buffer,"%u %u %u %u %u %u \n",XXL, YXL, ZXL, XGY, YGY, ZGY); uartC0SendTX((unsigned char*)XYZ_buffer); } } } while(true) { nop(); } }
int main( void ) { uint8_t delay; uint8_t counter; uint8_t doStatus = 1; InitTimer(); InitUART(); SetDirectionOut( LED ); SetDirectionOut( MOSI ); SetDirectionIn( MISO ); SetDirectionOut( SCK ); SetDirectionOut( SS ); SetDirectionIn( INT ); SetDirectionOut( TRIGGER ); TRIGGER_PORT &= ~TRIGGER_MASK; SPI_MasterInit(); Log( "*****\n" ); Log( "***** WLN CLI program\n" ); Log( "*****\n" ); sei(); counter = 0; while ( 1 ) { LED_PORT ^= LED_MASK; if ( doStatus ) { if ( counter == 0 ) { uint8_t status = WLN_ReadStatus(); WLN_PrintStatus( status ); } counter = ( counter + 1 ) & 0x03; } // Tick rate is 100/sec so waiting for 50 waits for 1/2 sec for ( delay = 0; delay < 50; delay++ ) { tick_t prevCount = gTickCount; while ( gTickCount == prevCount ) { LogBufDump(); } if ( UART0_IsCharAvailable() ) { char ch = UART0_GetChar(); switch ( ch ) { case '!': { doStatus = !doStatus; Log( "Turning status %s\n", doStatus ? "on" : "off" ); break; } case '*': { Log( "Reset\n" ); SetDirectionOut( RESET ); RESET_PORT &= ~RESET_MASK; break; } case ' ': { WLN_ReadData(); break; } default: { Log( "Read: '%c'\n", ch ); WLN_WriteByte( ch ); break; } } } } } } // main
//----------------------------------------------------------------------------- // functions //----------------------------------------------------------------------------- void spi_init(void) { // Initialize SPI master on port C. SPI_MasterInit(&spiMasterC, &SPIC, &PORTC, false, SPI_MODE_0_gc, \ SPI_INTLVL_HI_gc, false, SPI_PRESCALER_DIV4_gc); }
void spi_format(spi_t *obj, int bits, int mode, int slave) { spi_master_config_t master_config; spi_slave_config_t slave_config; /* Bits: values between 4 and 16 are valid */ MBED_ASSERT(bits >= 4 && bits <= 16); obj->bits = bits; if (slave) { /* Slave config */ SPI_SlaveGetDefaultConfig(&slave_config); slave_config.dataWidth = (spi_data_width_t)(bits - 1); slave_config.polarity = (mode & 0x2) ? kSPI_ClockPolarityActiveLow : kSPI_ClockPolarityActiveHigh; slave_config.phase = (mode & 0x1) ? kSPI_ClockPhaseSecondEdge : kSPI_ClockPhaseFirstEdge; SPI_SlaveInit(spi_address[obj->instance], &slave_config); } else { /* Master config */ SPI_MasterGetDefaultConfig(&master_config); master_config.dataWidth = (spi_data_width_t)(bits - 1); master_config.polarity = (mode & 0x2) ? kSPI_ClockPolarityActiveLow : kSPI_ClockPolarityActiveHigh; master_config.phase = (mode & 0x1) ? kSPI_ClockPhaseSecondEdge : kSPI_ClockPhaseFirstEdge; master_config.direction = kSPI_MsbFirst; switch (obj->instance) { case 0: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM0); RESET_PeripheralReset(kFC0_RST_SHIFT_RSTn); break; case 1: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM1); RESET_PeripheralReset(kFC1_RST_SHIFT_RSTn); break; case 2: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM2); RESET_PeripheralReset(kFC2_RST_SHIFT_RSTn); break; case 3: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM3); RESET_PeripheralReset(kFC3_RST_SHIFT_RSTn); break; case 4: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM4); RESET_PeripheralReset(kFC4_RST_SHIFT_RSTn); break; case 5: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM5); RESET_PeripheralReset(kFC5_RST_SHIFT_RSTn); break; case 6: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM6); RESET_PeripheralReset(kFC6_RST_SHIFT_RSTn); break; case 7: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM7); RESET_PeripheralReset(kFC7_RST_SHIFT_RSTn); break; #if (FSL_FEATURE_SOC_FLEXCOMM_COUNT > 8U) case 8: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM8); RESET_PeripheralReset(kFC8_RST_SHIFT_RSTn); break; #endif #if (FSL_FEATURE_SOC_FLEXCOMM_COUNT > 9U) case 9: CLOCK_AttachClk(kFRO12M_to_FLEXCOMM9); RESET_PeripheralReset(kFC9_RST_SHIFT_RSTn); break; #endif } SPI_MasterInit(spi_address[obj->instance], &master_config, 12000000); } }
int main(void) { unsigned int XXL,YXL,ZXL,XGL,YGL,ZGL; unsigned char XYZ_buffer[100]; clk_init(); port_init(); USART_INIT(); // spi_init(); /* Init SS pin as output with wired AND and pull-up. */ PORTC.DIRSET = PIN0_bm; PORTC.PIN0CTRL = PORT_OPC_WIREDANDPULL_gc; PORTC.DIRSET = PIN1_bm; PORTC.PIN1CTRL = PORT_OPC_WIREDANDPULL_gc; /* Set SS output to high. (No slave addressed). */ PORTC.OUTSET = PIN0_bm; PORTC.OUTSET = PIN1_bm; /* Instantiate pointer to ssPort. */ PORT_t *ssPort = &PORTC; /* Initialize SPI master on port C. */ SPI_MasterInit(&spiMasterC, &SPIC, &PORTC, false, SPI_MODE_3_gc, SPI_INTLVL_OFF_gc, false, SPI_PRESCALER_DIV16_gc); /* Initialize ACC & Gyro */ Init_L3G4200DH(); Init_LIS331DLH(); /* Read Sensor data */ while(true) { /* Create data packet (SS to slave by PC0). */ SPI_MasterCreateDataPacket(&dataPacket, masterSendData, ACC_DATA, NUM_BYTES, &PORTC, PIN0_bm); /* MASTER: Pull SS line low. This has to be done since * SPI_MasterTransceiveByte() does not control the SS line(s). */ SPI_MasterSSLow(ssPort, PIN0_bm); /* Transceive packet. */ SPI_MasterTransceivePacket(&spiMasterC, &dataPacket); /* MASTER: Release SS to slave. */ SPI_MasterSSHigh(ssPort, PIN0_bm); /* Create data packet (SS to slave by PC1). */ SPI_MasterCreateDataPacket(&dataPacket, masterSendData, GYRO_DATA, NUM_BYTES, &PORTC, PIN1_bm); /* MASTER: Pull SS line low. This has to be done since * SPI_MasterTransceiveByte() does not control the SS line(s). */ SPI_MasterSSLow(ssPort, PIN1_bm); /* Transceive packet. */ SPI_MasterTransceivePacket(&spiMasterC, &dataPacket); /* MASTER: Release SS to slave. */ SPI_MasterSSHigh(ssPort, PIN1_bm); ACC_DATA[2]=ACC_DATA[2]+0x80; ACC_DATA[4]=ACC_DATA[4]+0x80; ACC_DATA[6]=ACC_DATA[6]+0x80; XXL= (unsigned int)ACC_DATA[2]*256+ACC_DATA[1]; YXL= (unsigned int)ACC_DATA[4]*256+ACC_DATA[3]; ZXL= (unsigned int)ACC_DATA[6]*256+ACC_DATA[5]; GYRO_DATA[2]=GYRO_DATA[2]+0x80; GYRO_DATA[4]=GYRO_DATA[4]+0x80; GYRO_DATA[6]=GYRO_DATA[6]+0x80; XGL= (unsigned int)GYRO_DATA[2]*256+GYRO_DATA[1]; YGL= (unsigned int)GYRO_DATA[4]*256+GYRO_DATA[3]; ZGL= (unsigned int)GYRO_DATA[6]*256+GYRO_DATA[5]; sprintf((char*)XYZ_buffer,"[XXL%6u][YXL%6u][ZXL%6u][XGY%6u][YGY%6u][ZGY%6u]\r\n",XXL,YXL,ZXL,XGL,YGL,ZGL); //uartSendTXbit('3'); //sprintf((char*)XYZ_buffer,"abcdefgefgh12341\n\r"); uartSendTX(XYZ_buffer); } while(true) { nop(); } }
int main() { bitSet(DDRJ, DDJ1); /* red - output pin */ bitSet(DDRJ, DDJ0); /* yellow - output pin */ bitSet(DDRH, DDH1); /* green - output pin */ bitSet(PORTJ, PJ1); /* red off */ bitSet(PORTJ, PJ0); /* yellow off */ bitSet(PORTH, PH1); /* green off */ DDRL = 0b00000000; /* PL0 .. PL7 input */ PORTL = 0b11111111; /* PL0 .. PL7 pullup enable */ // initialize timer. OCR1A = 2; /* Compare match after 2 increments (976 Hz) */ TCCR1A = _BV(COM1A0); /* Toggle OC1A on compare match */ TCCR1B = _BV(WGM12) | _BV(CS12) | _BV(CS10); /* Mode=Clear on Compare Match; clk = Clk_IO/1024 = 1953 Hz */ TCCR1C = 0; TIMSK1 = _BV(OCIE1A); //TCCR0A = 0; //TCCR0B = _BV(CS02) | _BV(CS00); // start timer with clk/1024 (15,625 kHz) //TIMSK0 = _BV(TOIE0); // enable timer0 overflow interrupt SPI_MasterInit(); int value = 0; int prevValue = 0; lcdInit(); sei(); lcdPrint(0, "Hello Arduino!"); while(1) { set_sleep_mode(0); // IDLE mode sleep_mode(); if (prevEncoder == 2 && encoderVal == 0) { value+=10; if (value > 1000) { value = 1000; } bitClear(PORTJ, PJ1); /* red on */ } else { bitSet(PORTJ, PJ1); /* red off */ } if (prevEncoder == 1 && encoderVal == 0) { value-=10; if (value < 0) { value = 0; } bitClear(PORTJ, PJ0); /*yellow on */ } else { bitSet(PORTJ, PJ0); /* yellow off */ } if (prevValue != value) { itoa(value, line, 10); lcdPrint(0, line); MCP48xx_SetValue(value); } prevValue = value; #if 0 if ( (prevEncoder == 3 && encoderVal == 2) || (prevEncoder == 2 && encoderVal == 0) || (prevEncoder == 0 && encoderVal == 1) || (prevEncoder == 1 && encoderVal == 3)) { bitClear(PORTJ, PJ1); /* red on */ } else { bitSet(PORTJ, PJ1); /* red off */ } if ( (prevEncoder == 3 && encoderVal == 1) || (prevEncoder == 1 && encoderVal == 0) || (prevEncoder == 0 && encoderVal == 2) || (prevEncoder == 2 && encoderVal == 3)) { bitClear(PORTJ, PJ0); /*yellow on */ } else { bitSet(PORTJ, PJ0); /* yellow off */ } #endif prevEncoder = encoderVal; } }
/*! \brief Test function. * * This function tests the SPI master and slave drivers in interrupt-driven * operation, with a master (on port C) communicating with a slave (on port D). * * Hardware setup: * * - Connect PC4 to PD4 (SS) * - Connect PC5 to PD5 (MOSI) * - Connect PC6 to PD6 (MISO) * - Connect PC7 to PD7 (SCK) * * The driver is tested by transmitting data from the master to the slave. * The slave increments the received data and sends it back. The master reads * the data from the slave and verifies that it equals the data sent + 1. * * The first data transaction is initiated by the main routine. When a * transaction has finished, an interrupt will be triggered which will start * new transactions until all bytes have been transceived. * * The variable, 'success', will be non-zero when the function reaches the * infinite for-loop if the test was successful. * * \note This example uses multilevel interrupts. For more information on how * to use the interrupt controller, refer to application note AVR1305. */ int main( void ) { /* Init SS pin as output with wired AND and pull-up. */ PORTC.DIRSET = PIN4_bm; PORTC.PIN4CTRL = PORT_OPC_WIREDANDPULL_gc; /* Set SS output to high. (No slave addressed). */ PORTC.OUTSET = PIN4_bm; /* Initialize SPI master on port C. */ SPI_MasterInit(&spiMasterC, &SPIC, &PORTC, false, SPI_MODE_0_gc, SPI_INTLVL_LO_gc, false, SPI_PRESCALER_DIV4_gc); /* Initialize SPI slave on port D. */ SPI_SlaveInit(&spiSlaveD, &SPID, &PORTD, false, SPI_MODE_0_gc, SPI_INTLVL_MED_gc); /* Enable low and medium level interrupts in the interrupt controller. */ PMIC.CTRL |= PMIC_MEDLVLEN_bm | PMIC_LOLVLEN_bm; sei(); /* Create data packet (SS to slave by PC4) */ SPI_MasterCreateDataPacket(&dataPacket, sendData, receivedData, NUM_BYTES + 1, &PORTC, PIN4_bm); /* Transmit and receive first data byte. */ uint8_t status; do { status = SPI_MasterInterruptTransceivePacket(&spiMasterC, &dataPacket); } while (status != SPI_OK); /* Wait for transmission to complete. */ while (dataPacket.complete == false) { } /* Check that correct data was received. Assume success at first. */ success = true; for (uint8_t i = 0; i < NUM_BYTES; i++) { if (receivedData[i + 1] != (uint8_t)(sendData[i] + 1)) { success = false; } } while(true) { nop(); } }
/*! \brief Test function. * * This function tests the SPI master and slave drivers in polled operation, * with a master (on port C) communicating with a slave (on port D). * * Hardware setup: * * - Connect PC4 to PD4 (SS) * - Connect PC5 to PD5 (MOSI) * - Connect PC6 to PD6 (MISO) * - Connect PC7 to PD7 (SCK) * * The drivers are tested in two phases: * * 1: Data is transmitted on byte at a time from the master to the slave. * The slave increments the received data and sends it back. The master reads * the data from the slave and verifies that it equals the data sent + 1. * * 2: Data is transmitted 4 bytes at a time to the slave. As the master sends * a byte to the slave, the preceding byte is sent back to the master. * When all bytes have been sent, it is verified that the last 3 bytes * received at the master, equal the first 3 bytes sent. * * The variable, 'success', will be non-zero when the function reaches the * infinite for-loop if the test was successful. */ int main(void) { /* Init SS pin as output with wired AND and pull-up. */ PORTC.DIRSET = PIN4_bm; PORTC.PIN4CTRL = PORT_OPC_WIREDANDPULL_gc; /* Set SS output to high. (No slave addressed). */ PORTC.OUTSET = PIN4_bm; /* Instantiate pointer to ssPort. */ PORT_t *ssPort = &PORTC; /* Initialize SPI master on port C. */ SPI_MasterInit(&spiMasterC, &SPIC, &PORTC, false, SPI_MODE_0_gc, SPI_INTLVL_LO_gc, false, SPI_PRESCALER_DIV4_gc); /* Initialize SPI slave on port D. */ SPI_SlaveInit(&spiSlaveD, &SPID, &PORTD, false, SPI_MODE_0_gc, SPI_INTLVL_LO_gc); /* PHASE 1: Transceive individual bytes. */ /* MASTER: Pull SS line low. This has to be done since * SPI_MasterTransceiveByte() does not control the SS line(s). */ SPI_MasterSSLow(ssPort, PIN4_bm); for(uint8_t i = 0; i < NUM_BYTES; i++) { /* MASTER: Transmit data from master to slave. */ SPI_MasterTransceiveByte(&spiMasterC, masterSendData[i]); /* SLAVE: Wait for data to be available. */ while (SPI_SlaveDataAvailable(&spiSlaveD) == false) { } /* SLAVE: Get the byte received. */ uint8_t slaveByte = SPI_SlaveReadByte(&spiSlaveD); /* SLAVE: Increment received byte and send back. */ slaveByte++; SPI_SlaveWriteByte(&spiSlaveD, slaveByte); /* MASTER: Transmit dummy data to shift data from slave to master. */ uint8_t masterReceivedByte = SPI_MasterTransceiveByte(&spiMasterC, 0x00); /* MASTER: Check if the correct value was received. */ if (masterReceivedByte != (masterSendData[i] + 1) ) { success = false; } } /* MASTER: Release SS to slave. */ SPI_MasterSSHigh(ssPort, PIN4_bm); /* PHASE 2: Transceive data packet. */ /* Create data packet (SS to slave by PC4). */ SPI_MasterCreateDataPacket(&dataPacket, masterSendData, masterReceivedData, NUM_BYTES, &PORTC, PIN4_bm); /* Transceive packet. */ SPI_MasterTransceivePacket(&spiMasterC, &dataPacket); /* Check that correct data was received. Assume success at first. */ for (uint8_t i = 0; i < NUM_BYTES - 1; i++) { if (masterReceivedData[i + 1] != masterSendData[i]) { success = false; } } while(true) { nop(); } }