static action_delay(int ms){ int i = 0; for(;i<ms;++i) _delay_ms(1); }
//============================================================================= //Het hoofdprogramma int main(void) { //variabelen uint8_t blok; uint8_t arr[10]; poorten_init(); //init twi twi_init(); //init lcd lcd_init(); schrijftekst(); sei(); arr[0] = 0x00; arr[1] = 0x57; arr[0] = 0xFF; twi_mt_zendboodschap(0x38, 0x03,arr); //print resultaten interrupts if (MT_B.klaar == 1) { print_lcd(); } twi_mt_zendboodschap(0x39, 0x03,arr); //print resultaten interrupts if (MT_B.klaar == 1) { print_lcd(); } twi_mt_zendboodschap(0x3A, 0x0,arr); //print resultaten interrupts if (MT_B.klaar == 1) { print_lcd(); } twi_mt_zendboodschap(0x3B, 0x03,arr); //print resultaten interrupts if (MT_B.klaar == 1) { print_lcd(); } while(1) { //print resultaten interrupts if (MT_B.klaar == 1) { print_lcd(); } //als knop is ingedrukt : zend boodschap if ((bit_is_set(PINB,4)) ) //knop { //knop is los // schakelen mogelijk blok = 0; //wacht op denderen _delay_ms(D_TIJD); //zet led uit PORTD |= _BV(7); } if (!bit_is_set(PINB,4) ) { //knop is ingedrukt //blokkeer herhaling blok = 1; //wacht op denderen _delay_ms(D_TIJD); //zet led aan PORTD &= ~_BV(7); //maak vorige resultaten schoon lcd_clear(); lcd_gotoxy(0,0); schrijftekst(); //we zenden een Boodschap MT_B.data[0] = 0x00; MT_B.data[1] = 0x57; MT_B.data[0] = 0x77; MT_B.data[1] = 0x77; MT_B.data[1] = 0x77; MT_B.data[0] = 0x77; // twi_mt_zendboodschap(0x38, 0x06); //knop is ingedrukt //blokkeer herhaling blok = 1; //wacht op denderen _delay_ms(D_TIJD); //zet led aan PORTD &= ~_BV(7); //maak vorige resultaten schoon lcd_clear(); lcd_gotoxy(0,0); schrijftekst(); //we zenden een Boodschap MT_B.data[0] = 0x00; MT_B.data[1] = 0x57; MT_B.data[0] = 0x77; MT_B.data[1] = 0x77; MT_B.data[1] = 0x77; MT_B.data[0] = 0x77; // twi_mt_zendboodschap(0x39, 0x06); //knop is ingedrukt //blokkeer herhaling blok = 1; //wacht op denderen _delay_ms(D_TIJD); //zet led aan PORTD &= ~_BV(7); //maak vorige resultaten schoon lcd_clear(); lcd_gotoxy(0,0); schrijftekst(); //we zenden een Boodschap MT_B.data[0] = 0x00; MT_B.data[1] = 0x57; MT_B.data[0] = 0x77; MT_B.data[1] = 0x77; MT_B.data[1] = 0x77; MT_B.data[0] = 0x77; // twi_mt_zendboodschap(0x3B, 0x06); } } }
int8_t pmu_init(void) { int8_t ret; bool battery_present; state = OFF; /* make panic button an input */ io_input_pin(PANICn); panic_last = io_test_pin(PANICn); /* make the LED outputs */ io_output_pin(CHARGE); io_output_pin(POWER_LED); /* initialize the ADC, so we can sense the battery */ adc_init(); /* initialize TPS54478 for core power */ tps54478_init(true); /* wiggle USB and FTDI pins */ io_input_pin(USB_RESETn); io_output_pin(FTDI_RESETn); io_output_pin(USB_CLK_EN); io_input_pin(FTDI_CBUS3); /* make OVERTEMP input pin */ io_input_pin(OVERTEMP); /* initialize the charger */ ret = bq2419x_init(); if (ret) goto fail_bq2419x; /* wait a sec */ _delay_ms(1000); /* wdt setup */ cli(); WDTCSR |= BIT(WDCE) | BIT(WDE); WDTCSR = BIT(WDIE); sei(); /* see if we got a battery */ battery_present = pmu_battery_present(); battery_present_last = battery_present; if (battery_present) { last_full_charge = eeprom_get_last_full(); ret = ltc294x_init(LTC294X_MODEL_2942); } if (ret) return ret; ret = ltc3675_init(); if (ret) goto fail_ltc3675; /* need to hold them low until power is stable */ io_output_pin(PS_POR); io_output_pin(PS_SRST); io_clear_pin(PS_POR); io_clear_pin(PS_SRST); /* TODO: Not sure if needed */ io_input_pin(AVR_RESET); /* TODO: This will probably need to change */ io_input_pin(AVR_IRQ); io_set_pin(AVR_IRQ); // enable pull-up ? /* configure and enable interrupts */ interrupt_init(); /* initialize the timers */ timer0_init(); timer1_init(); state = OFF; return 0; fail_ltc3675: fail_bq2419x: return -1; }
void LCD_Init(uint8_t addr){ //0x27 address to LCD Display _delay_ms(8000); //Sends the start condition TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != START)Error(START); //Loads the slave address and set the R/W bit to 1 TWDR = (addr<<1) | LCD_WRITE; TWCR = (1<<TWINT) | (1<<TWEN); //MAYBE 1<<TWEA also??? while(!TWI_Busy()); if((TWSR & MASK) != MT_ADDRESS_ACK)Error((TWSR & MASK)); //Sends the data to the slave TWDR = 0x0; //8bits TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MT_BYTE_ACK)Error((TWSR & MASK)); //Sends the stop condition TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); _delay_ms(2000); /************************************************************************/ /* Initial write to LCD i 8 bit */ /************************************************************************/ dataport |= (1<<LCD_DATA1_PIN); dataport |= (1<<LCD_DATA0_PIN); //Sends the start condition TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != START)Error(START); //Loads the slave address and set the R/W bit to 1 TWDR = (addr<<1) | (LCD_WRITE); TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MT_ADDRESS_ACK)Error((TWSR & MASK)); //Sends the data to the slave TWDR = dataport; //8bits TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MT_BYTE_ACK)Error((TWSR & MASK)); //Sends the stop condition TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); _delay_ms(8000); /************************************************************************/ /* Toggle pin */ /************************************************************************/ LCD_toggle(); _delay_ms(4000); LCD_toggle(); _delay_ms(1000); LCD_toggle(); _delay_ms(1000); /************************************************************************/ /* Set for 4 bit instead */ /************************************************************************/ dataport &= (0<<LCD_DATA0_PIN); //Sends the start condition TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != START)Error(START); //Loads the slave address and set the R/W bit to 1 TWDR = (addr<<1) | (LCD_WRITE); TWCR = (1<<TWINT) | (1<<TWEN); //MAYBE 1<<TWEA also??? while(!TWI_Busy()); if((TWSR & MASK) != MT_ADDRESS_ACK)Error((TWSR & MASK)); //Sends the data to the slave TWDR = dataport; //8bits TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MT_BYTE_ACK)Error((TWSR & MASK)); //Sends the stop condition TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); /************************************************************************/ /* Toggle pin */ /************************************************************************/ _delay_ms(1000); LCD_toggle(); _delay_ms(8000); LCD_Command(0x28); //4bit two line _delay_ms(8000); LCD_Command(0x08); //display off _delay_ms(8000); LCD_Command(0x01);//Clear screen _delay_ms(8000); uint8_t mode = 0; mode = (1<<LCD_ENTRY_MODE)|(1<<LCD_ENTRY_INC); LCD_Command(mode);//D MODE FEDAULT _delay_ms(8000); LCD_Command(0x0C); //Dispattr Y_LED_On(); while(1); _delay_ms(8000); LCD_Print('S'); }
// ============================================================================================ // KEY INPUT PROCESS // ============================================================================================ void key_input() { char input_char = 0; if (usart.available()) input_char = usart.get(); if(input_char == 0x1b) xboot_reset(); //reboot the board if(input_char == 'Z') //Reboot whole system { send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "Z"); temp_time = jiffies + 3000; while(jiffies < temp_time) { LED_PORT.OUTTGL = LED_USR_1_PIN_bm; _delay_ms(100); } xboot_reset(); } // print version number if(input_char == 'v') fprintf_P(&usart_stream, PSTR("build number = %ld\r\n"), (unsigned long) &__BUILD_NUMBER); if(input_char == 'd') { if(display) display = false; else display = true; } if(input_char == 'r') //set sec_counter as 0 { send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "r"); sec_counter = 0; } // ============================================================================================ /// updateRate commands // ============================================================================================ // Hold Current Servo Position if(input_char == 'n'){ fprintf_P(&usart_stream, PSTR("setting updateRate to NONE\n")); updateRate = NONE; send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "n"); } if(input_char == 's'){ fprintf_P(&usart_stream, PSTR("setting updateRate to 10ms\n")); updateRate = SMOOTH; send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "s"); } if(input_char == 'h'){ fprintf_P(&usart_stream, PSTR("setting updateRate to 200ms\n")); updateRate = TWO_HUNDRED; send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "h"); } // ============================================================================================ /// currentMode commands // ============================================================================================ if(input_char == 'p'){ fprintf_P(&usart_stream, PSTR("'p' - etting currentMode to PERIODIC\n")); currentMode = PERIODIC; send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "p"); } if(input_char == 'V'){ fprintf_P(&usart_stream, PSTR("'V' - setting currentMode to AVERAGE\n")); currentMode = AVERAGE; send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "V"); } if(input_char == 'w'){ fprintf_P(&usart_stream, PSTR("'w' - setting currentMode to SWEEP\n")); currentMode = SWEEP; send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "w"); } if(input_char == 'c'){ cycleOn = !cycleOn; fprintf_P(&usart_stream, PSTR("'c' - cycle all modes\n")); send_message(MESSAGE_COMMAND, ALL_DIRECTION, ALL, "c"); } // ============================================================================================ /// toggle debug print // ============================================================================================ if(input_char == 'P'){ fprintf_P(&usart_stream, PSTR("'P' - toggling debug printf on/off \n")); debugPrint = !debugPrint; } if(input_char == 'c'){ printKeyCommands(); } }
void lcd_enable() { LCD_CONTROL_PORT |= 1 << LCD_EN; _delay_ms(2); LCD_CONTROL_PORT &= ~(1 << LCD_EN); }
// Listen-PIN pollen, warten auf Request: PIN wird LO uint8_t ListenForRequest() { if (websrstatus & (1<< SR_TALK_BIT)) { // ich sende selber return 0; } // Signal fuer Oszi // PORTD |= (1<<PB0); // _delay_ms(2); // PORTD &= ~(1<<PB0); // if ((SR_HANDSHAKE_PORTPIN & (1<<SR_LISTEN_PIN))) // PIN ist HI { if (websrstatus &(1<<SR_LISTEN_BIT)) // Listen-Bit ist noch gesetzt, Partner hat fertig gesendet { // Signal fuer Oszi // PORTD |= (1<<PB0); // _delay_ms(2); // PORTD &= ~(1<<PB0); //lcd_gotoxy(16,2); //lcd_putc('E'); //_delay_ms(40); // Listen-Bereitschaft an Partner zuruecknehmen SR_HANDSHAKE_PORT |= (1<<SR_TALK_PIN); // Listen-Bit zuruecksetzen websrstatus &= ~(1<<SR_LISTEN_BIT); } else { // Talk-Bit zuruecksetzen // websrstatus &= ~(1<< SR_TALK_BIT); // Bit 6 // websrstatus &= ~(1<<SR_LISTEN_BIT); } } else // SR_LISTEN_PIN ist LO, Request vom Partner { //******************* // Talk-Bit zuruecksetzen websrstatus &= ~(1<< SR_TALK_BIT); // Bit 6 //******************* // Ist LISTEN-BIT im websrstatus schon gesetzt? if (websrstatus & (1<<SR_LISTEN_BIT)) // Bit 7 { // Senden ist eingeleitet, nichts tun } else // neuer Request, Listen-Bit setzen { //lcd_clr_line(0); //lcd_gotoxy(15,2); //lcd_putc('A'); // websr_set_mode(0); // sicher ist sicher // ++++++++++++++++++++++++++++++++++++++ if (ByteCounter == 0xFF) { // Schleife fuer Verzoegerung /* uint8_t i=0; for (i=0;i< 0 ;i++) { _delay_ms(20); _delay_ms(20); _delay_ms(20); _delay_ms(20); _delay_ms(20); } */ } // ++++++++++++++++++++++++++++++++++++++ // Listen-Bereitschaft an Partner senden SR_HANDSHAKE_PORT &= ~(1<<SR_TALK_PIN); _delay_ms(1); // Listen-Status-Bit setzen websrstatus |= (1<<SR_LISTEN_BIT); //_delay_ms(200); return 1; // Bereit zum Lesen } } return 0; }
void setup() { // WDT_off(); -> moved the call to this function to start of the main loop, before init // clock settings: divide by 8 to get a 1Mhz clock, allows us to set the BOD level to 1.8V (DS p.37) // CLKPR = (1<<CLKPCE); // CLKPR = (1<<CLKPS1) | (1<<CLKPS0); // load meterid's and metervalues from EEPROM eeprom_read_block((void*)&measurements, (const void*)&EEPROM_measurements, sizeof(measurements)); // init serial port beginSerial(4800); _delay_ms(100); //LEDPIN=PB5/SCK configured as output pin DDRB |= (1<<PB7);//DONE // PD2=INT0 and PD3=INT1 configuration // set as input pin with 20k pull-up enabled PORTD |= (1<<PD2) | (1<<PD3); // INT0 and INT1 to trigger an interrupt on a falling edge EICRA = (1<<ISC01) | (1<<ISC11); // enable INT0 and INT1 interrupts EIMSK = (1<<INT0) | (1<<INT1); #if DBG > 0 // re-use PD4 pin for tracing interrupt times DDRD |= (1<<DDD4); #else // PD4=PCINT20 configuration // set as input pin with 20k pull-up enabled PORTD |= (1<<PD4); //enable pin change interrupt on PCINT20 PCMSK2 |= (1<<PCINT20); //pin change interrupt enable 2 PCICR |= (1<<PCIE2); #endif // analog comparator setup for brown-out detection // PD7=AIN1 configured by default as input to obtain high impedance // disable digital input cicuitry on AIN0 and AIN1 pins to reduce leakage current DIDR1 |= (1<<AIN1D) | (1<<AIN0D); // comparing AIN1 (Vcc/4.4) to bandgap reference (1.1V) // bandgap select | AC interrupt enable | AC interrupt on rising edge (DS p.243) ACSR |= (1<<ACBG) | (1<<ACIE) | (1<<ACIS1) | (1<<ACIS0); // Timer2 set to CTC mode (DS p.146, 154, 157) TCCR2A |= 1<<WGM21; #if DBG > 0 // Toggle pin OC2A=PB3 on compare match TCCR2A |= 1<<COM2A0; #endif // Set PB3 as output pin DDRB |= (1<<DDB7);//DONE // Timer2 clock prescaler set to 9 => fTOV2 = 1000kHz / 256 / 8 = 488.28Hz (DS p.158) TCCR2B |= (1<<CS22) | (1<<CS20); //DONE Prescaler 128 // Enable output compare match interrupt for timer2 (DS p.159) TIMSK2 |= (1<<OCIE2A); // Increase sampling frequency to 1250Hz (= 625Hz per channel) OCR2A = 0x63; // disable digital input cicuitry on ADCx pins to reduce leakage current DIDR0 |= (1<<ADC5D) | (1<<ADC4D) | (1<<ADC3D) | (1<<ADC2D) | (1<<ADC1D) | (1<<ADC0D); // select VBG as reference for ADC ADMUX |= (1<<REFS1) | (1<<REFS0); // ADC prescaler set to 8 => 1000kHz / 8 = 125kHz (DS p.258) ADCSRA |= (1<<ADPS1) | (1<<ADPS0) | (1<<ADPS2); //DONE, since frequency is 16Mhz, Prescaler needs to be 128 to achieve 125Khz // enable ADC and start a first ADC conversion ADCSRA |= (1<<ADEN) | (1<<ADSC); //set global interrupt enable in SREG to 1 (DS p.12) sei(); }
void send(uint8_t msg_type, const struct sensor *measurement, const struct state *aux) { uint8_t i; uint32_t value = 0; uint32_t ms = 0; int32_t rest; uint8_t pulse_count; char message[60]; switch (msg_type) { case PULSE: // blink the green LED PORTB |= (1<<PB7);//DONE _delay_ms(20); PORTB &= ~(1<<PB7);//DONE cli(); value = measurement->value; ms = aux->time; sei(); strcpy(message, "pls "); break; case POWER: cli(); rest = aux->nano_end - aux->nano_start; pulse_count = aux->pulse_count_final; sei(); // Since the AVR has no dedicated floating-point hardware, we need // to resort to fixed-point calculations for converting nWh/s to W. // 1W = 10^6/3.6 nWh/s // value[watt] = 3.6/10^6 * rest[nWh/s] // value[watt] = 3.6/10^6 * 65536 * (rest[nWh/s] / 65536) // value[watt] = 3.6/10^6 * 65536 * 262144 / 262144 * (rest[nWh/s] / 65536) // value[watt] = 61847.53 / 262144 * (rest[nWh/s] / 65536) // We round the constant down to 61847 to prevent 'underflow' in the // consecutive else statement. // The error introduced in the fixed-point rounding equals 8.6*10^-6. MacU16X16to32(value, (uint16_t)(labs(rest)/65536), 61847); value /= 262144; if (rest >= 0) value += pulse_count*3600; else value = pulse_count*3600 - value; strcpy(message, "pwr "); break; } strcpy(&message[4], measurement->id); strcpy(&message[36], ":0000000000\n"); i = 46; do { // generate digits in reverse order message[i--] = '0' + value % 10; // get next digit } while ((value /= 10) > 0); // delete it if ((msg_type == PULSE) && ms) { strcpy(&message[47], ":0000000000\n"); i = 57; do { // generate digits in reverse order message[i--] = '0' + ms % 10; // get next digit } while ((ms /= 10) > 0); // delete it } printString(message); // printString("\r"); }
void startup_user() { _delay_ms(20); // gets rid of tick PLAY_NOTE_ARRAY(tone_startup, false, 0); }
void shutdown_user() { PLAY_NOTE_ARRAY(tone_goodbye, false, 0); _delay_ms(150); stop_all_notes(); }
// run reset could be called in three ways, // convertional by the bluetooth command // -> that should write "Running Update", reconfigure serial speed and reset the ATm328 // second from the menu // -> thereby only the "running update" should be written and the serial speed should be reconfigured // third: from the state (2) if the user pushed "right" button to trigger reset // -> only reset ATm328 and return to last state void Speedo_aktors::run_reset_on_ATm328(char mode){ // serial setup and "klickibunti"-"show some msg" if(mode==RESET_COMPLETE || mode==RESET_PREPARE){ pSensors->m_reset->set_deactive(false,false); _delay_ms(100);// give serial 3 some time to send the messeage Serial3.end(); Serial3.begin(115200); // pOLED->clear_screen(); // pOLED->string_P(pSpeedo->default_font,PSTR("Running Update"),3,2); // pOLED->string_P(pSpeedo->default_font,PSTR("on AT328P"),5,3); }; // show "_R_to_trigger_reset__" only if in "preparation" mode if(mode==RESET_PREPARE){ char temp[2]; // sprintf(temp,"%c",127); // pOLED->string(pSpeedo->default_font,temp,1,7); // pOLED->string_P(pSpeedo->default_font,PSTR("to trigger reset"),3,7); } // run the reset if(mode==RESET_COMPLETE || mode==RESET_KICK_TO_RESET){ // pin as output DDRD |= (1<<ATM328RESETPIN); // set low -> low active PORTD &= ~(1<<ATM328RESETPIN); _delay_ms(50); PORTD |= (1<<ATM328RESETPIN); // set high, as pull up DDRD |= (1<<ATM328RESETPIN); PORTD |= (1<<ATM328RESETPIN); } // tunnel connection if(mode==RESET_COMPLETE || mode==RESET_PREPARE){ // tunnel mode unsigned long timeout=millis(); unsigned int max_time=5000; // should be enough if in android mode if(mode==RESET_PREPARE){ // longer timeout if in "menu-mode" max_time=30000; }; while(millis()-timeout<max_time){ // time out while(Serial3.available()>0){ Serial.print(Serial3.read(),BYTE); timeout=millis(); } while(Serial.available()>0){ Serial3.print(Serial.read(),BYTE); timeout=millis(); } if(mode==RESET_PREPARE){ // if(menu_state_on_enter==((pMenu->state/10))){ // button "right" was pushed // run_reset_on_ATm328(RESET_KICK_TO_RESET); // to the reset // pMenu->state=menu_state_on_enter; // reset menu state // } else if(menu_state_on_enter==((pMenu->state*10)+1)){ // button "left" was pushed // pMenu->state=menu_state_on_enter; // reset menu state, because menu->back will otherwise recaluclate two steps back // max_time=0; // break; // } } } Serial3.end(); Serial3.begin(19200); pSensors->m_reset->set_active(false,false); }; }
int main(void) { stdout = & mydata; ili9341_init();//initial driver setup to drive ili9341 ili9341_clear(BLACK);//fill screen with black colour _delay_ms(1000); ili9341_setRotation(3);//rotate screen _delay_ms(2); display_init();//display initial data while(1) { ili9341_settextcolour(CYAN,BLACK); ili9341_setcursor(vsetx,vsety); _delay_ms(2); ili9341_settextsize(3); ili9341_write('1'); _delay_ms(2); ili9341_write('0'); _delay_ms(2); ili9341_write('.'); _delay_ms(2); ili9341_write('2'); _delay_ms(2); ili9341_write('3'); _delay_ms(2); ili9341_setcursor(vactualx,vactualy); _delay_ms(2); ili9341_settextsize(5); ili9341_write('22'); _delay_ms(2); ili9341_write('0'); _delay_ms(2); ili9341_write('.'); _delay_ms(2); ili9341_write('2'); _delay_ms(2); ili9341_write('3'); _delay_ms(2); _delay_ms(2000); ili9341_setcursor(vsetx,vsety); _delay_ms(2); ili9341_settextsize(3); ili9341_write('9'); _delay_ms(2); ili9341_write('0'); _delay_ms(2); ili9341_write('.'); _delay_ms(2); ili9341_write('4'); _delay_ms(2); ili9341_write('5'); _delay_ms(2); ili9341_setcursor(vactualx,vactualy); _delay_ms(2); ili9341_settextsize(5); ili9341_write('9'); _delay_ms(2); ili9341_write('0'); _delay_ms(2); ili9341_write('.'); _delay_ms(2); ili9341_write('4'); _delay_ms(2); ili9341_write('5'); _delay_ms(2); _delay_ms(2000); } }
int main() { // set for 16 MHz clock CPU_PRESCALE(0); // Configure all port B and port D pins as inputs with pullup resistors. DDRD = 0x00; DDRB = 0x00; PORTB = 0xFF; PORTD = 0xFF; // Turn the LED on during the configuration LED_CONFIG; LED_ON; // Initialize the USB, and then wait for the host to set configuration. usb_init(); while (!usb_configured()); // Initialize the gamepad interface gamepad_init(); // Wait an extra second for the PC's operating system to load drivers // and do whatever it does to actually be ready for input _delay_ms(1000); // Timer 0 configuration (~60Hz) TCCR0A = 0x00; // Normal mode TCCR0B = 0x05; // Clock/1024 TIMSK0 = (1<<TOIE0); LED_OFF; while (1) { while (!ready); // Block until the next cycle (~60Hz) cli(); ready = 0; sei(); // Read pressed buttons from gamepad interface gamepad_read(); // Reset key array reset_keys(); // Special functions // - Software reboot if (PRESSED_REBOOT) { reboot(); } // 6 keys can be sent at a time, with any number of modifiers. // // - Buttons A, B, X and Y have their own position in the key array. // - Up/down and left/right pairs share one position, as they are // mutually exclusive (you cannot pres up AND down). // - L and R use the left and right Shift modifiers. // - Select and Start use the left and right Ctrl modifiers. if (PRESSED_A) press_key(KEY_Z, 0); if (PRESSED_B) press_key(KEY_X, 1); if (PRESSED_X) press_key(KEY_A, 2); if (PRESSED_Y) press_key(KEY_S, 3); if (PRESSED_UP) { press_key(KEY_UP, 4); } else if (PRESSED_DOWN){ press_key(KEY_DOWN, 4); } if (PRESSED_LEFT) { press_key(KEY_LEFT, 5); } else if (PRESSED_RIGHT){ press_key(KEY_RIGHT, 5); } if (PRESSED_L) press_modifier(KEY_LEFT_SHIFT); if (PRESSED_R) press_modifier(KEY_RIGHT_SHIFT); if (PRESSED_SELECT) press_modifier(KEY_LEFT_CTRL); if (PRESSED_START) press_modifier(KEY_RIGHT_CTRL); usb_keyboard_send(); } }
int main(void) { #if MPU6050_GETATTITUDE == 0 int16_t ax = 0; int16_t ay = 0; int16_t az = 0; int16_t gx = 0; int16_t gy = 0; int16_t gz = 0; double axg = 0; double ayg = 0; double azg = 0; double gxds = 0; double gyds = 0; double gzds = 0; #endif #if MPU6050_GETATTITUDE == 1 || MPU6050_GETATTITUDE == 2 long *ptr = 0; double qw = 1.0f; double qx = 0.0f; double qy = 0.0f; double qz = 0.0f; double roll = 0.0f; double pitch = 0.0f; double yaw = 0.0f; #endif //init uart uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU)); //init interrupt sei(); //init mpu6050 mpu6050_init(); _delay_ms(50); //init mpu6050 dmp processor #if MPU6050_GETATTITUDE == 2 mpu6050_dmpInitialize(); mpu6050_dmpEnable(); _delay_ms(10); #endif for(;;) { #if MPU6050_GETATTITUDE == 0 mpu6050_getRawData(&ax, &ay, &az, &gx, &gy, &gz); mpu6050_getConvData(&axg, &ayg, &azg, &gxds, &gyds, &gzds); #endif #if MPU6050_GETATTITUDE == 1 mpu6050_getQuaternion(&qw, &qx, &qy, &qz); mpu6050_getRollPitchYaw(&roll, &pitch, &yaw); _delay_ms(10); #endif #if MPU6050_GETATTITUDE == 2 if(mpu6050_getQuaternionWait(&qw, &qx, &qy, &qz)) { mpu6050_getRollPitchYaw(qw, qx, qy, qz, &roll, &pitch, &yaw); } _delay_ms(10); #endif #if MPU6050_GETATTITUDE == 0 char itmp[10]; ltoa(ax, itmp, 10); uart_putc(' '); uart_puts(itmp); uart_putc(' '); ltoa(ay, itmp, 10); uart_putc(' '); uart_puts(itmp); uart_putc(' '); ltoa(az, itmp, 10); uart_putc(' '); uart_puts(itmp); uart_putc(' '); ltoa(gx, itmp, 10); uart_putc(' '); uart_puts(itmp); uart_putc(' '); ltoa(gy, itmp, 10); uart_putc(' '); uart_puts(itmp); uart_putc(' '); ltoa(gz, itmp, 10); uart_putc(' '); uart_puts(itmp); uart_putc(' '); uart_puts("\r\n"); dtostrf(axg, 3, 5, itmp); uart_puts(itmp); uart_putc(' '); dtostrf(ayg, 3, 5, itmp); uart_puts(itmp); uart_putc(' '); dtostrf(azg, 3, 5, itmp); uart_puts(itmp); uart_putc(' '); dtostrf(gxds, 3, 5, itmp); uart_puts(itmp); uart_putc(' '); dtostrf(gyds, 3, 5, itmp); uart_puts(itmp); uart_putc(' '); dtostrf(gzds, 3, 5, itmp); uart_puts(itmp); uart_putc(' '); uart_puts("\r\n"); uart_puts("\r\n"); _delay_ms(1000); #endif #if MPU6050_GETATTITUDE == 1 || MPU6050_GETATTITUDE == 2 //quaternion ptr = (long *)(&qw); uart_putc(*ptr); uart_putc(*ptr>>8); uart_putc(*ptr>>16); uart_putc(*ptr>>24); ptr = (long *)(&qx); uart_putc(*ptr); uart_putc(*ptr>>8); uart_putc(*ptr>>16); uart_putc(*ptr>>24); ptr = (long *)(&qy); uart_putc(*ptr); uart_putc(*ptr>>8); uart_putc(*ptr>>16); uart_putc(*ptr>>24); ptr = (long *)(&qz); uart_putc(*ptr); uart_putc(*ptr>>8); uart_putc(*ptr>>16); uart_putc(*ptr>>24); //roll pitch yaw ptr = (long *)(&roll); uart_putc(*ptr); uart_putc(*ptr>>8); uart_putc(*ptr>>16); uart_putc(*ptr>>24); ptr = (long *)(&pitch); uart_putc(*ptr); uart_putc(*ptr>>8); uart_putc(*ptr>>16); uart_putc(*ptr>>24); ptr = (long *)(&yaw); uart_putc(*ptr); uart_putc(*ptr>>8); uart_putc(*ptr>>16); uart_putc(*ptr>>24); uart_putc('\n'); #endif } }
void setChannelModule(uint8_t channel) { uint8_t i; uint16_t channelData; //channelData = pgm_read_word(&channelTable[channel]); channelData = channelTable[channel]; // bit bash out 25 bits of data // Order: A0-3, !R/W, D0-D19 // A0=0, A1=0, A2=0, A3=1, RW=0, D0-19=0 SERIAL_ENABLE_HIGH(); _delay_ms(2); SERIAL_ENABLE_LOW(); SERIAL_SENDBIT0(); SERIAL_SENDBIT0(); SERIAL_SENDBIT0(); SERIAL_SENDBIT1(); SERIAL_SENDBIT0(); // remaining zeros for (i=20;i>0;i--) SERIAL_SENDBIT0(); // Clock the data in SERIAL_ENABLE_HIGH(); _delay_ms(2); SERIAL_ENABLE_LOW(); // Second is the channel data from the lookup table // 20 bytes of register data are sent, but the MSB 4 bits are zeros // register address = 0x1, write, data0-15=channelData data15-19=0x0 SERIAL_ENABLE_HIGH(); SERIAL_ENABLE_LOW(); // Register 0x1 SERIAL_SENDBIT1(); SERIAL_SENDBIT0(); SERIAL_SENDBIT0(); SERIAL_SENDBIT0(); // Write to register SERIAL_SENDBIT1(); // D0-D15 // note: loop runs backwards as more efficent on AVR for (i=16;i>0;i--) { // Is bit high or low? if (channelData & 0x1) { SERIAL_SENDBIT1(); } else { SERIAL_SENDBIT0(); } // Shift bits along to check the next one channelData >>= 1; } // Remaining D16-D19 for (i=4;i>0;i--) SERIAL_SENDBIT0(); // Finished clocking data in SERIAL_ENABLE_HIGH(); _delay_ms(2); MODULE_EN_HIGH(); MODULE_CLK_LOW(); MODULE_DATA_LOW(); }
/* * main() */ int main(void) { kb_init(); // does controller initialization too kb_led_state_power_on(); usb_init(); while (!usb_configured()); kb_led_delay_usb_init(); // give the OS time to load drivers, etc. kb_led_state_ready(); for (;;) { // swap `main_kb_is_pressed` and `main_kb_was_pressed`, then update bool (*temp)[KB_ROWS][KB_COLUMNS] = main_kb_was_pressed; main_kb_was_pressed = main_kb_is_pressed; main_kb_is_pressed = temp; kb_update_matrix(*main_kb_is_pressed); // this loop is responsible to // - "execute" keys when they change state // - keep track of which layers the keys were on when they were pressed // (so they can be released using the function from that layer) // // note // - everything else is the key function's responsibility // - see the keyboard layout file ("keyboard/ergodox/layout/*.c") for // which key is assigned which function (per layer) // - see "lib/key-functions/public/*.c" for the function definitions #define row main_loop_row #define col main_loop_col #define layer main_arg_layer #define is_pressed main_arg_is_pressed #define was_pressed main_arg_was_pressed for (row=0; row<KB_ROWS; row++) { for (col=0; col<KB_COLUMNS; col++) { is_pressed = (*main_kb_is_pressed)[row][col]; was_pressed = (*main_kb_was_pressed)[row][col]; if (is_pressed != was_pressed) { if (is_pressed) { layer = main_layers_peek(0); main_layers_pressed[row][col] = layer; main_arg_trans_key_pressed = false; } else { layer = main_layers_pressed[row][col]; main_arg_trans_key_pressed = main_kb_was_transparent[row][col]; } // set remaining vars, and "execute" key main_arg_row = row; main_arg_col = col; main_arg_layer_offset = 0; main_exec_key(); main_kb_was_transparent[row][col] = main_arg_trans_key_pressed; } } } #undef row #undef col #undef layer #undef is_pressed #undef was_pressed // send the USB report (even if nothing's changed) usb_keyboard_send(); usb_extra_consumer_send(); _delay_ms(MAKEFILE_DEBOUNCE_TIME); // update LEDs if (layers_head != 0) { kb_led_num_on(); kb_led_caps_on(); } else { kb_led_num_off(); kb_led_caps_off(); } // if (keyboard_leds & (1<<1)) { kb_led_caps_on(); } // else { kb_led_caps_off(); } if (keyboard_leds & (1<<2)) { kb_led_scroll_on(); } else { kb_led_scroll_off(); } if (keyboard_leds & (1<<3)) { kb_led_compose_on(); } else { kb_led_compose_off(); } if (keyboard_leds & (1<<4)) { kb_led_kana_on(); } else { kb_led_kana_off(); } } return 0; }
// Don't buzz for a 750ms (used when band changing normally) inline void buzz4kHz_Long_Pause() { _delay_ms(750); }
/* * shifts a byte into the SR* * Parameters: * out_byte The byte to load . */ uint8_t websr_shift_byte_out(uint8_t out_byte) { // Listen-Bit zuruecksetzen // websrstatus &= ~(1<< SR_LISTEN_BIT); // Bit 7 // Talk-Request an Partner senden, warten auf Antwort SR_HANDSHAKE_PORT &= ~(1<<SR_TALK_PIN); // Bit 3 // Talk-Bit setzen websrstatus |= (1<< SR_TALK_BIT); // Bit 6 //_delay_ms(10); uint16_t z=1; uint16_t zz=0; while (((SR_HANDSHAKE_PORTPIN & (1<< SR_LISTEN_PIN)))) // noch keine Antwort vom Partner > warten { // Timer2 zuruecksetzen TCNT2=0; timer2_counter=0; //lcd_gotoxy(16,3); //lcd_putint1(z); _delay_us(10); // warten z++; if (z == 0) // { zz++; } } z &= 0xFF00; z >>= 8; //zz &= 0xFF00; //zz >>= 8; if (ByteCounter == 0xFF) { //lcd_gotoxy(16,3); //lcd_puthex(z); //lcd_puthex(zz); if (zz >= 0x0005) { lcd_gotoxy(19,2); lcd_putc('E'); websrstatus |= (1<< SR_ERR_BIT); websr_reset(); return 2; } else { //lcd_putc('G'); } } // Antwort da //lcd_gotoxy(18,3); //lcd_puts("OK\0"); //_delay_ms(2); // Eventuell mehr //websrstatus |= (1<< SR_LISTEN_BIT); // Bit 7 int i; // lcd_gotoxy(10,2); // lcd_putc('*'); //lcd_gotoxy(11,2); //lcd_puts(" \0"); //_delay_ms(1); //lcd_gotoxy(11,2); for(i=0; i<8; i++) { if (out_byte & 0x80) { //lcd_putc('1'); /* this bit is high */ SR_DATA_PORT |=_BV(SR_DATA_IO_PIN); } else { //lcd_putc('0'); /* this bit is low */ SR_DATA_PORT &= ~_BV(SR_DATA_IO_PIN); } //_delay_us(2*SR_PULSE_DELAY); //_delay_us(255); // _delay_us(255); // _delay_us(50); websr_pulse(SR_PULSE_DELAY); //_delay_ms(1); //_delay_us(2*SR_PULSE_DELAY); out_byte = out_byte << 1; // Byte um eine Stelle nach links schieben } //lcd_putc('*'); // Talk-Request zuruecknehmen SR_HANDSHAKE_PORT |= (1<<SR_TALK_PIN); // +++ Partner Zeit lassen _delay_ms(8); return 0; }
// Don't buzz for 250ms (used for startup) inline void buzz4kHz_Short_Pause() { _delay_ms(250); }
void commit(int addr) { LEDs_TurnOffLEDs(LEDS_PMODE); accessData(0x4C, addr, 0x00); _delay_ms(30); LEDs_TurnOnLEDs(LEDS_PMODE); }
int main(void) { uint8_t currentBand=0; uint8_t currentChannel=0; uint8_t i=0; uint8_t channelChangeFlag=0; // Setup I/O Ports // PORTA // DDR-bit: high=output, bit low=input DDRA = 0x68; // Ensure that the Fatshark inputs are pulled up and the button is too PORTA = 0x97; // PORTB // DDR-bit: high=output, bit low=input //DDRB = 0x00; DDRB = 0x07; // Ensure the I/O ports are all off PORTB = 0x00; // Read in the current band from EEPROM currentBand = eeprom_read_byte(0x00); // Set the channel and band when first powered on - before the beeps. // Also give a moment for the goggles to initalise and set the relevant channel on the IO pins _delay_ms(500); currentChannel = readChannelFatshark(); setChannelModule((currentBand * 8)+currentChannel); // Make sure the current band is a valid number if (currentBand >= 4) currentBand = 0; // Beep out the current band for (i=0;i<=currentBand;i++) { buzz4kHz_Long(); buzz4kHz_Long_Pause(); } // force the current band to be set on the first loop run // using the currentChannel code currentChannel = 0xFF; // main loop while(1) { // See if we should change frequency band if (readChannelButton()) { if (channelChangeFlag == 0) { currentBand++; if (currentBand >= 4) currentBand = 0; eeprom_write_byte(0x00, currentBand); // Set new band and send it to the module setChannelModule((currentBand * 8)+currentChannel); // Beep out the new band for (i=0;i<=currentBand;i++) { buzz4kHz_Long(); buzz4kHz_Long_Pause(); } channelChangeFlag = 1; } } else { channelChangeFlag = 0; } if (readChannelFatshark() != currentChannel) { currentChannel = readChannelFatshark(); // Calculate new index and set the module to it setChannelModule((currentBand * 8)+currentChannel); for (i=0;i<=currentChannel;i++) { buzz4kHz_Short(); buzz4kHz_Short_Pause(); } } } }
void LCD_Print(uint8_t command){ dataport |= (1<<LCD_RS_PIN); dataport &= (0<<LCD_RW_PIN); //Sends the start condition TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != START)Error(START); //Loads the slave address and set the R/W bit to 1 TWDR = (0x27<<1) | (1<<0); TWCR = (1<<TWINT) | (1<<TWEN); //MAYBE 1<<TWEA also??? while(!TWI_Busy()); if((TWSR & MASK) != MT_ADDRESS_ACK)Error((TWSR & MASK)); //Sends the data to the slave TWDR = dataport; //8bits TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MR_BYTE_NACK)Error((TWSR & MASK)); //Sends the stop condition TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); _delay_ms(4000); dataport &= (0<<LCD_DATA3_PIN); dataport &= (0<<LCD_DATA2_PIN); dataport &= (0<<LCD_DATA1_PIN); dataport &= (0<<LCD_DATA0_PIN); if(command & 0x80) dataport |= (1<<LCD_DATA3_PIN); if(command & 0x40) dataport |= (1<<LCD_DATA2_PIN); if(command & 0x20) dataport |= (1<<LCD_DATA1_PIN); if(command & 0x10) dataport |= (1<<LCD_DATA0_PIN); //Sends the start condition TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != START)Error(START); //Loads the slave address and set the R/W bit to 1 TWDR = (0x27<<1) | (1<<0); TWCR = (1<<TWINT) | (1<<TWEN); //MAYBE 1<<TWEA also??? while(!TWI_Busy()); if((TWSR & MASK) != MR_ADDRESS_ACK)Error((TWSR & MASK)); //Sends the data to the slave TWDR = dataport; //8bits TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MR_BYTE_NACK)Error((TWSR & MASK)); //Sends the stop condition TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); _delay_ms(4000); LCD_toggle(); dataport &= (0<<LCD_DATA3_PIN); dataport &= (0<<LCD_DATA2_PIN); dataport &= (0<<LCD_DATA1_PIN); dataport &= (0<<LCD_DATA0_PIN); if(command & 0x08) dataport |= (1<<LCD_DATA3_PIN); if(command & 0x04) dataport |= (1<<LCD_DATA2_PIN); if(command & 0x02) dataport |= (1<<LCD_DATA1_PIN); if(command & 0x01) dataport |= (1<<LCD_DATA0_PIN); //Sends the start condition TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != START)Error(START); //Loads the slave address and set the R/W bit to 1 TWDR = (0x27<<1) | (1<<0); TWCR = (1<<TWINT) | (1<<TWEN); //MAYBE 1<<TWEA also??? while(!TWI_Busy()); if((TWSR & MASK) != MT_ADDRESS_ACK)Error((TWSR & MASK)); //Sends the data to the slave TWDR = dataport; //8bits TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MR_BYTE_NACK)Error((TWSR & MASK)); //Sends the stop condition TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); _delay_ms(4000); LCD_toggle(); dataport |= (1<<LCD_DATA0_PIN); dataport |= (1<<LCD_DATA1_PIN); dataport |= (1<<LCD_DATA2_PIN); dataport |= (1<<LCD_DATA3_PIN); //Sends the start condition TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != START)Error(START); //Loads the slave address and set the R/W bit to 1 TWDR = (0x27<<1) | (1<<0); TWCR = (1<<TWINT) | (1<<TWEN); //MAYBE 1<<TWEA also??? while(!TWI_Busy()); if((TWSR & MASK) != MT_ADDRESS_ACK)Error((TWSR & MASK)); //Sends the data to the slave TWDR = dataport; //8bits TWCR = (1<<TWINT) | (1<<TWEN); while(!TWI_Busy()); if((TWSR & MASK) != MR_BYTE_NACK)Error((TWSR & MASK)); //Sends the stop condition TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); _delay_ms(4000); }
void clearDisplay() { writeByte(0x01); _delay_ms(2); }
void glcd_init(void) { SPI_MasterInit(); glcd_cs_high(); glcd_dc_high(); glcd_rst_on(); _delay_ms(10); glcd_rst_off(); glcd_setOrientation(PORTRAIT); // default glcd_sendCmd(ILI9341_CMD_POWER_ON_SEQ_CONTROL); glcd_sendData(ILI9341_CMD_IDLE_MODE_ON); glcd_sendData(ILI9341_CMD_MEMORY_WRITE); glcd_sendData(ILI9341_CMD_NOP); glcd_sendData(ILI9341_CMD_TEARING_EFFECT_LINE_OFF); glcd_sendData(0x02); // XXX glcd_sendCmd(ILI9341_CMD_POWER_CONTROL_B); glcd_sendData(ILI9341_CMD_NOP); glcd_sendData(ILI9341_CMD_POWER_CONTROL_2); glcd_sendData(ILI9341_CMD_PARTIAL_AREA); glcd_sendCmd(ILI9341_CMD_DRIVER_TIMING_CONTROL_A); glcd_sendData(0x85); // XXX glcd_sendData(ILI9341_CMD_NOP); glcd_sendData(0x78); // XXX glcd_sendCmd(ILI9341_CMD_DRIVER_TIMING_CONTROL_B); glcd_sendData(ILI9341_CMD_NOP); glcd_sendData(ILI9341_CMD_NOP); glcd_sendCmd(0xED); // XXX glcd_sendData(0x64); // XXX glcd_sendData(0x03); // XXX glcd_sendData(ILI9341_CMD_PARTIAL_MODE_ON); glcd_sendData(0X81); // XXX glcd_sendCmd(ILI9341_CMD_PUMP_RATIO_CONTROL); glcd_sendData(ILI9341_CMD_DISP_INVERSION_OFF); glcd_sendCmd(ILI9341_CMD_POWER_CONTROL_1); glcd_sendData(0x23); //VRH[5:0] // XXX glcd_sendCmd(ILI9341_CMD_POWER_CONTROL_2); glcd_sendData(ILI9341_CMD_ENTER_SLEEP_MODE); glcd_sendCmd(ILI9341_CMD_VCOM_CONTROL_1); glcd_sendData(ILI9341_CMD_READ_MEMORY_CONTINUE); glcd_sendData(ILI9341_CMD_DISPLAY_OFF); glcd_sendCmd(ILI9341_CMD_VCOM_CONTROL_2); glcd_sendData(0x86); //-- // XXX glcd_sendCmd(ILI9341_CMD_MEMORY_ACCESS_CONTROL); glcd_sendData(0x48); //C8 //48 68gal.gal.gal.//28 E8 gal.gal.gal. // XXX glcd_sendCmd(ILI9341_CMD_COLMOD_PIXEL_FORMAT_SET); glcd_sendData(ILI9341_CMD_WRITE_CONTENT_ADAPT_BRIGHTNESS); glcd_sendCmd(ILI9341_CMD_FRAME_RATE_CONTROL_NORMAL); glcd_sendData(ILI9341_CMD_NOP); glcd_sendData(0x18); // XXX glcd_sendCmd(ILI9341_CMD_DISPLAY_FUNCTION_CONTROL); glcd_sendData(0x08); // XXX glcd_sendData(0x82); // XXX glcd_sendData(0x27); // XXX glcd_sendCmd(ILI9341_CMD_ENABLE_3_GAMMA_CONTROL); glcd_sendData(ILI9341_CMD_NOP); glcd_sendCmd(0x26); //Gamma curve selected // XXX glcd_sendData(ILI9341_CMD_SOFTWARE_RESET); glcd_sendCmd(ILI9341_CMD_POSITIVE_GAMMA_CORRECTION); glcd_sendData(0x0F); // XXX glcd_sendData(0x31); // XXX glcd_sendData(ILI9341_CMD_PAGE_ADDRESS_SET); glcd_sendData(ILI9341_CMD_READ_DISP_PIXEL_FORMAT); glcd_sendData(ILI9341_CMD_READ_DISP_SIGNAL_MODE); glcd_sendData(0x08); // XXX glcd_sendData(0x4E); // XXX glcd_sendData(0xF1); // XXX glcd_sendData(ILI9341_CMD_VERT_SCROLL_START_ADDRESS); glcd_sendData(0x07); // XXX glcd_sendData(ILI9341_CMD_ENTER_SLEEP_MODE); glcd_sendData(0x03); // XXX glcd_sendData(ILI9341_CMD_READ_DISP_SIGNAL_MODE); glcd_sendData(ILI9341_CMD_READ_DISP_STATUS); glcd_sendData(ILI9341_CMD_NOP); glcd_sendCmd(ILI9341_CMD_NEGATIVE_GAMMA_CORRECTION); glcd_sendData(ILI9341_CMD_NOP); glcd_sendData(ILI9341_CMD_READ_DISP_SIGNAL_MODE); glcd_sendData(0x14); // XXX glcd_sendData(0x03); // XXX glcd_sendData(ILI9341_CMD_SLEEP_OUT); glcd_sendData(0x07); // XXX glcd_sendData(0x31); // XXX glcd_sendData(ILI9341_CMD_POWER_CONTROL_2); glcd_sendData(0x48); // XXX glcd_sendData(0x08); // XXX glcd_sendData(0x0F); // XXX glcd_sendData(ILI9341_CMD_READ_DISP_PIXEL_FORMAT); glcd_sendData(0x31); // XXX glcd_sendData(ILI9341_CMD_MEMORY_ACCESS_CONTROL); glcd_sendData(ILI9341_CMD_READ_DISP_SELF_DIAGNOSTIC); glcd_sendCmd(ILI9341_CMD_SLEEP_OUT); _delay_ms(120); glcd_sendCmd(ILI9341_CMD_DISPLAY_ON); glcd_sendCmd(ILI9341_CMD_MEMORY_WRITE); glcd_bg(bgcolor); }
int main() { int i; print("====== BEGIN CPUCYCLES TEST ======\n"); for(i=0;i<NTIMINGS;i++) { t[i] = cpucycles(); _delay_ms(1); } for(i=0;i<NTIMINGS-1;i++) { printllu(t[i+1]-t[i]); print(" "); } print("\n"); for(i=0;i<NTIMINGS;i++) { t[i] = cpucycles(); _delay_ms(2); } for(i=0;i<NTIMINGS-1;i++) { printllu(t[i+1]-t[i]); print(" "); } print("\n"); for(i=0;i<NTIMINGS;i++) { t[i] = cpucycles(); _delay_ms(3); } for(i=0;i<NTIMINGS-1;i++) { printllu(t[i+1]-t[i]); print(" "); } print("\n"); for(i=0;i<NTIMINGS;i++) { t[i] = cpucycles(); _delay_ms(4); } for(i=0;i<NTIMINGS-1;i++) { printllu(t[i+1]-t[i]); print(" "); } print("\n"); for(i=0;i<NTIMINGS;i++) { t[i] = cpucycles(); _delay_ms(5); } for(i=0;i<NTIMINGS-1;i++) { printllu(t[i+1]-t[i]); print(" "); } print("\n"); print("====== END CPUCYCLES TEST ======\n"); avr_end(); return 0; }
/* Eine Viertelsekunde Piepen */ void beep(void) { PORTC |= _BV(PC3); //BEEP! _delay_ms(250); PORTC &= ~_BV(PC3); }
/* Hauptprogramm des Controllers ** ** Dieses Programm wird beim Starten des Controllers aufgerufen und ** ** abgearbeitet. Die Endlosschleife ist der zyklische Teil des Programms */ int main(void) { init(); //Aufruf der init Funktion while(1) //zyklischer Teil des Programms { if(controller == 0 && dataint) { receive = dataread(1); switch(receive) { case 1: //falls die Klemme 1 angesprochen werden soll { setBit(DDRC, Klemme1); setBit(PORTC, Klemme1); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 2: //falls die Klemme 2 angesprochen werden soll { setBit(DDRC, Klemme2); setBit(PORTC, Klemme2); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 3: //falls die Klemme 3 angesprochen werden soll { setBit(DDRC, Klemme3); setBit(PORTC, Klemme3); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 4: //falls die Klemme 4 angesprochen werden soll { setBit(DDRC, Klemme4); setBit(PORTC, Klemme4); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 5: //falls die Klemme 5 angesprochen werden soll { setBit(DDRC, Klemme5); setBit(PORTC, Klemme5); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 6: //falls die Klemme 6 angesprochen werden soll { setBit(DDRC, Klemme6); setBit(PORTC, Klemme6); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 7: //falls die Klemme 7 angesprochen werden soll { setBit(DDRB, Klemme7); setBit(PORTB, Klemme7); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 8: //falls die Klemme 8 angesprochen werden soll { setBit(DDRD, Klemme8); setBit(PORTD, Klemme8); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 9: //falls die Klemme 9 angesprochen werden soll { setBit(DDRB, Klemme9); setBit(PORTB, Klemme9); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 10: //falls die Klemme 10 angesprochen werden soll { setBit(DDRD, Klemme10); setBit(PORTD, Klemme10); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 11: //falls die Klemme 11 angesprochen werden soll { setBit(DDRB, Klemme11); setBit(PORTB, Klemme11); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 12: //falls die Klemme 12 angesprochen werden soll { setBit(DDRD, Klemme12); setBit(PORTD, Klemme12); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 13: //falls die Klemme 13 angesprochen werden soll { setBit(DDRB, Klemme13); setBit(PORTB, Klemme13); //setzen der Klemme datawrite(Datenrichtig, Sthaupt); break; } case 31: //falls ein Platinentest durchgeführt werden soll { _delay_ms(100); datawrite(Platinentest, Sthaupt); break; } default: { datawrite(Datennichtrichtig, Sthaupt); break; } } dataint = 0; controller = -1; receive = 0; datareadinit(); } else if(controller == 1 && dataint) { receive = dataread(1); switch(receive) { case 0: { break; } } dataint = 0; controller = -1; receive = 0; datareadinit(); } } }
int main(void) { //setting PWM-Ports as output DDRB = 0xFF; //set port B as output DDRD = 0b11111101; //set port D as output with pin D1 input //setup the pwm for the servo TCCR1A = _BV(COM1A1) // set OC1A/B at TOP | _BV(COM1B1) // clear OC1A/B when match | _BV(WGM11); //(fast PWM, clear TCNT1 on match ICR1) TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS11); // timer uses main system clock with 1/8 prescale ICR1 = 20000; // used for TOP, makes for 50 hz PWM OCR1A = 1500; // servo at center //set up pwm for the motors TCCR0A = _BV(COM0A1) // set OC1A/B at TOP | _BV(COM0B1) // clear OC1A/B when match | _BV(WGM00) // fast PWM mode | _BV(WGM01); TCCR0B = _BV(CS01) | _BV(CS00); drive_stop(0); //motors stopped servo_position(servo_center, 50); //servo center //variables to hold the distances; uint16_t forward_dist; uint16_t left_dist; uint16_t right_dist; uint8_t fwd_count; servo_position(servo_center, 50); while(1) { forward_dist = sensor_distance(); _delay_ms(50); if (forward_dist <= forward_buffer) { drive_stop(0); beep_meow(); servo_position(servo_left, 400); left_dist = sensor_distance(); servo_position(servo_right,400); right_dist = sensor_distance(); servo_position(servo_center,200); while ((left_dist > right_dist) && (forward_dist <= (forward_buffer + now_clear))) { drive_left(speed_80p); forward_dist = sensor_distance(); _delay_ms(50); } while ((left_dist <= right_dist) && (forward_dist <= (forward_buffer + now_clear))) { drive_right(speed_80p); forward_dist = sensor_distance(); _delay_ms(50); } } drive_forward(speed_80p); fwd_count++; if (fwd_count == 20) { fwd_count = 0; servo_position(servo_left, 150); left_dist = sensor_distance(); if (left_dist <= sides_buffer) { drive_stop(0); beep_meow(); while (left_dist <= (sides_buffer + now_clear)) { drive_right(speed_80p); left_dist = sensor_distance(); _delay_ms(100); } } servo_position(servo_center,100); servo_position(servo_right, 150); right_dist = sensor_distance(); if (right_dist <= sides_buffer) { drive_stop(0); beep_meow(); while (right_dist <= (sides_buffer + now_clear)) { drive_left(speed_80p); right_dist = sensor_distance(); _delay_ms(100); } } servo_position(servo_center,100); } } return 0; }
void holdAtTemp(uint16_t targetTemp, uint16_t targetTime){ double readTemp; double lowerRange = 0; double upperRange = 0; double temp = 0; double avgTemp = 0.0; int numTemps = 0; lowerRange = targetTemp;// + 0.1; upperRange = targetTemp;// + 0.1; while(count_ms < 2*targetTime){//count increments at quarter seconds readTemp = convertADC(adc_read()); /* //send_serial("Denaturing temp is "); //send App uart_putchar(denTemp); uart_putchar('\n'); _delay_ms(1000); //send_serial("readTemp is "); //send App uart_putchar(readTemp); uart_putchar('\n'); _delay_ms(1000); */ _delay_ms(1);// don't forget about the delay in the adc_read function! if (readTemp < lowerRange){ OCR0A = (82 - (targetTemp-55)*2); // normalized to PWM @ 82 at 55C and increase duty cycle by 2 PWM values for each degree PORTB = Fan_OFF; // turn off fan PORTD = LED_OFF; // turn off led } else{ OCR0A = 255; // set heater to 0% duty cycle PORTB = Fan_OFF; // power off the fan PORTD = LED_ON; // turn on the led } if (readTemp > (upperRange + 1)){ OCR0A = 255; // heater PWM duty cycle set to 0% PORTB = Fan_ON; // turn on the fan PORTD = LED_OFF; // turn off led } if (timerFlag == 0){ // timer flag is true every 1/4 second temp += readTemp; // sums gathered temperatures numTemps++; // keep track of the number of temperatures gathered //timerFlag = 0; // reset the 1/4 second timer flag } if (timerFlag == 1){ avgTemp = temp / numTemps; // average the gathered temperature readings temp = 0; // reset the summed temperatures numTemps = 0; // reset the number of gathered temperatures timerFlag = 0; if (((avgTemp*10)/10 >= targetTemp+2) || ((avgTemp*10)/10 <= targetTemp-2)){ // if current temperature is outside of +/- 1C range count_ms = 0; //reset counter if temp is outside of +/- 1C range } //send_serial(avgTemp*10/10, count_ms); // } } count_ms = 0; //reset counter while(count_ms <= 8){ PORTD = LED_OFF; } count_ms = 0; //reset counter while(count_ms <= 8){ PORTD = LED_ON; } PORTD = LED_OFF; }