int main(void) { uint8_t escaped = 0; leds_init(); DDR_CONFIG_OUT(RS485_TX_PIN); DDR_CONFIG_OUT(RS485_NRX_PIN); PIN_CLEAR(RS485_TX_PIN); PIN_CLEAR(RS485_NRX_PIN); UBRR0 = UART_BAUD_SELECT(RS485_BITRATE,F_CPU); UCSR0B |= (1<<TXEN0) | (1<<RXEN0); UBRR1 = UART_BAUD_SELECT(RS485_BITRATE,F_CPU); UCSR1B |= (1<<TXEN1) | (1<<RXEN1); wdt_reset(); PIN_SET(RS485_TX_PIN); PIN_SET(RS485_NRX_PIN); while(1){ wdt_reset(); if( (UCSR1A & (1<<RXC1)) ){ uint8_t data = UDR1; if( escaped ){ escaped = 0; if( data == 'R' ){ wdt_enable(WDTO_2S); while(1); } }else{ if( data == '\\' ){ escaped = 1; continue; } } UDR0 = data; PIN_SET(RS485_TX_PIN); PIN_SET(RS485_NRX_PIN); //_delay_us(4); leds_tx(); while( !(UCSR0A & (1<<TXC0)) ); UCSR0A |= (1<<TXC0); leds_txend(); //_delay_us(4); PIN_CLEAR(RS485_TX_PIN); PIN_CLEAR(RS485_NRX_PIN); } if( (UCSR0A & (1<<RXC0)) ){ UDR1 = UDR0; leds_rx(); while( !(UCSR1A & (1<<TXC1)) ); UCSR1A |= (1<<TXC1); leds_rxend(); } } }
static void init(void) { clock_prescale_set(clock_div_1); uart_init(UART_BAUD_SELECT(BAUD, F_CPU)); uart1_init(UART_BAUD_SELECT(BAUD, F_CPU)); fdev_setup_stream(&mystdout, _uart_putc, NULL, _FDEV_SETUP_WRITE); fdev_setup_stream(&mystdout1, _uart1_putc, NULL, _FDEV_SETUP_WRITE); stdout = &mystdout; DDRD |= _BV(PIND6); DDRE |= _BV(PINE3); }
int main(void) { // init uart_init(UART_BAUD_SELECT(UART_BAUD_RATE, F_CPU)); // enable interrupts after resetting the kicker sei(); uart_puts_P("* Interrupts enabled. - "); ports_init(); uart_puts_P("Ports initialized. - "); kicker_init(); uart_puts_P("Kicker initialized. - "); //kicker_uext(500); uart_puts_P("Device initialized. Enter main loop\n"); for (;;) { parser_process_uart(); } return 0; }
int main(void) { uart_config_default_stdio(); uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); spi_init(); radio_init(); sei(); printf("\nTX Test. Type in a packet:\n"); txtest_configure_radio(); //====================// //Communications Test char temp; temp = rfm22b_read(DTYPE); temp = rfm22b_read(DVERS); temp = rfm22b_read(INTEN1); temp = rfm22b_read(INTEN2); temp = rfm22b_read(OMFC1); temp = rfm22b_read(OMFC2); while(1) { txtest_fill_packet_from_uart(); txtest_send_current_packet(); printf("Transmit done. Type another:\n\n"); } }
// Initialize uart and direct standard out and standard error to uart void Debug::Initialize() { uart_init(UART_BAUD_SELECT(UART_BAUD_RATE, F_CPU)); fdev_setup_stream(&uartStream, UARTPutChar, NULL, _FDEV_SETUP_WRITE); stdout = &uartStream; stderr = &uartStream; }
void init(void) { // configure pins DDRB |= (1 << DSKY_DISPLAY_PIN_CLR); // output DDRD |= (1 << DSKY_DISPLAY_PIN_PWRCLR); // output DDRD &= ~(1 << DSKY_DISPLAY_PIN_PWRCLR); // configure pins for SPI master SPI_init(); // initialize UART uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); // intialize KSP plugin kspio_init(); clearRegisters(); // resets the shift registers and the decade counter // initialize bargraph PWM pins as outputs DSKY_BARGRAPH_CTRL_PORT |= (1 << DSKY_BARGRAPH_PIN_B1); DSKY_BARGRAPH_CTRL_PORT |= (1 << DSKY_BARGRAPH_PIN_B2); DSKY_BARGRAPH_CTRL_PORT |= (1 << DSKY_BARGRAPH_PIN_B3); // configure PWMs for bargraph displays TCCR0A |= (1 << COM0A1); // set non-inverting mode for OC0A TCCR0A |= (1 << COM0B1); // set non-inverting mode for OC0B TCCR0A |= (1 << WGM01) | (1 << WGM00); // set fast PWM mode TCCR0B |= (1 << CS02) | (1 << CS00); // set prescaler to 1024 and start PWM TCCR2A |= (1 << COM2B1); // set non-inverting mode for OC2B //TCCR2A |= (1 << WGM21) | (1 << WGM20); // set fast PWM mode - done in millis.c //TCCR2B |= (1 << CS22) | (1 << CS21) | (1 << CS20); // set prescaler to 1024 and start PWM - done in millis.c // multiplexing the displays TCCR1A |= (1 << WGM10); // timer/counter control register 1 A: fast PWM TCCR1B |= (1<<WGM12) | (1<<CS11) | (1<<CS10); // timer/counter control register 1 B: clock select 64th frequency TIMSK1 |= (1<<TOIE1); // timer/counter interrupt mask register: timer/counter 1 overflow interrupt enable }
/** * Initiate hardware peripherials. */ void init_hw() { ARD_LED_INIT(); // init arduino LED port uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU)); // init uarts stdout = &mystdio; // configure stdout to UART 0 TIMER0_PRES_1024(); // set prescaler of timer 0 TIMER0_OVF_IE(); // enable overflow interrupt of timer 0 TIMER0_RELOAD(TIMER0_10MS); // reload counter of timer 0 TIMER1_PRES_1024(); // set prescaler of timer 1 TIMER1_OVF_IE(); // enable overflow interrupt of timer 1 TIMER1_RELOAD(TIMER1_CNT); // reload counter of timer 1 but.port = &PINB; // initiate button but.bit = PB4; button_init(&but, &PORTB); LEF_TimerInit(&eTimer1); LEF_TimerInit(&eTimer2); LEF_TimerInit(&eTimer3); LEF_TimerStartRepeat(&eTimer1, 100); // set as 100 ticks repeating timer LEF_TimerStartRepeat(&eTimer2, 200); // set as 100 ticks repeating timer sev_cmd_init(cmdTable); sei(); // enable interrupts }
void GPS_init() { // Initialize UART: // set baud rate unsigned int baudrate = UART_BAUD_SELECT(GPS_UART_BAUDRATE,F_CPU); if ( baudrate & 0x8000 ) { GPS_UART_STATUS = (1<<U2X0); //Enable 2x speed baudrate &= ~0x8000; } GPS_UART_UBRR = (unsigned char)baudrate; /* enable UART receiver and transmmitter and receive complete interrupt */ GPS_UART_CONTROL = _BV(RXCIE0)|_BV(RXEN0)|_BV(TXEN0); /* Set frame format: asynchronous, 8data, no parity, 1stop bit */ #ifdef GPS_UART_URSEL0 GPS_UART_MISC = (1<<URSEL0)|(3<<UCSZ00); #else GPS_UART_MISC = (3<<UCSZ00); #endif // Initialize state machine GPS_state = 0; }
int main(void){ DDRC = 0x00; uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei(); unsigned int c; while(1){ c = uart_getc(); if(c & UART_NO_DATA){ /* * NO UART DATA available */ } else{ /* * New Data is avialable at the port. * check the frame for overrun errro */ if ( c & UART_FRAME_ERROR ){ /* Framing Error detected, i.e no stop bit detected */ uart_puts_P("UART Frame Error: "); } if ( c & UART_OVERRUN_ERROR ){ /* * * Overrun, a character already present in the UART UDR register was * * not read by the interrupt handler before the next character arrived, * one or more received characters have been dropped * * */ uart_puts_P("UART Overrun Error: "); } if ( c & UART_BUFFER_OVERFLOW ){ /* * * We are not reading the receive buffer fast enough, * * one or more received character have been dropped * */ uart_puts_P("Buffer overflow error: "); } processData(c); // PORTC = c; } } return 0; }
int main(void) { // initializing uart data variables for storage of incoming data // signed char uart_data_length = -1; // char char1 = '@'; // int innt = 12412; // long long1 = -123456789; // float float1 = 3.1415926; // double double1 = -2.81; // uart_init( UART_BAUD_SELECT(BAUD,F_CPU) ); TC1_Setup(); sei(); uart_putc(2); mpu6050_setup(); uart_putc(3); // DDRD = 0b11111011; // set PD2 to input // PORTD = 0b00000100; // set PD2 to high // // EICRA = 0b00000011; // EIMSK = 0b00000001; // PCICR |= _BV(PCIE0); //Enable PCINT2 // // PCMSK0 |= (1 << PCINT0); /* Enable PCINT0 */ DDRB |= 1 << PINB0; while (1) { PORTB ^= 1 << PINB0; _delay_ms(500); } }
int main(void) { double lat = 0.0, lon = 0.0; char buffer[32]; uint16_t v; AFSK_Init(); uart_init((UART_BAUD_SELECT(9600,F_CPU))); Trigger_Init(); batv_init(); // Sleep control DDRC |= (1<<PORTC0); PORTC &= ~(1<<PORTC0); // Debug led DDRD |= (1<<PORTD3); PORTD &= ~(1<<PORTD3); // set_sleep_mode( SLEEP_MODE_PWR_DOWN ); // set_sleep_mode( SLEEP_MODE_IDLE ); sei(); sns_nmea_Init(); send=1; for(;;) { // sleep_enable(); // sleep_cpu(); // sleep_disable(); // c = uart_getc(); sns_nmea_Process(); // if( !(c&0xFF00) ) { // PORTB ^= (1<<PORTB1); // } if( send ) { // Convert to pengi friendly format lat = (double)(NMEA_data.lat_deg) + (double)(NMEA_data.lat_min/60.0) + (double)(NMEA_data.lat_sec_h/6000.0); lon = (double)(NMEA_data.lon_deg) + (double)(NMEA_data.lon_min/60.0) + (double)(NMEA_data.lon_sec_h/6000.0); // end conversion v = batv_get(); sprintf( buffer, "Vcc: %d.%02dV", v/100, v%100 ); aprs_packet_rewind( &pkt ); aprs_pack_position( &pkt, lat /*57.68111667*/, lon /*11.98611667*/, '/'<<8|'[' ); aprs_add_comment( &pkt, buffer ); ax25_tx_packet( &pkt ); sns_nmea_Init(); send = 0; } } return 0; }
char initSerial(uint16_t baud) { switch(baud) { case 38400: uart_init(UART_BAUD_SELECT(38400,F_CPU)); break; case 9600: uart_init(UART_BAUD_SELECT(9600,F_CPU)); break; case 1200: uart_init(UART_BAUD_SELECT(1200,F_CPU)); break; default: return(-1); } return 0; }
int main() { uart_init(UART_BAUD_SELECT(UART_BAUD_RATE, F_CPU)); sei(); uart_puts("begin\r\n"); nrfInit(); writeReg(RF_SETUP, SET_RF_SETUP); writeAddr(RX_ADDR_P0, SET_RX_ADDR_P0); writeAddr(TX_ADDR, SET_TX_ADDR); writeReg(DYNPD, SET_DYNPD); writeReg(FEATURE, SET_FEATURE); writeReg(RF_CH, SET_RF_CH); writeReg(CONFIG, SET_CONFIG); startRadio(); uint8_t worked; uint8_t size; char sendbuffer[] = "Testing 1..2..3.. Testing."; size = sizeof (sendbuffer); char receivebuffer[33]; char c; char count[10]; int charbuffer; char payloadlength; // uart_puts(sendbuffer); worked = transmit(sendbuffer, size); if (worked == 1) { uart_puts("Transmit Worked!\r\n"); } else { uart_puts("Transmit Failed.\r\n"); } startRx(); while (1) { payloadlength = dynReceive(receivebuffer); if (payloadlength > 0) { uart_puts("Got something:"); uart_puts(receivebuffer); uart_puts("\r\n"); } else { uart_puts("nothin received\r\n"); } c = uart_getc(); if (!(c & UART_NO_DATA)) { uart_putc(c); } printRegisters(); _delay_ms(2000); } }
int main(void) { uart_t *u0; uint8_t rc; rtc_device_t *rtc = &rtc_ds1307; rtc_datetime_24h_t current_dt, offset_dt; _delay_ms(1000); u0 = uart_init("0", UART_BAUD_SELECT(38400, F_CPU)); uart_init_stdout(u0); i2c_init(); DDRC = _BV(PC0) | _BV(PC1); PORTC = _BV(PC0) | _BV(PC1); sei(); printf("\n\nBooted up!\n"); rc = rtc_init(rtc); printf("Inited RTC, rc=%i\n", rc); rc = rtc_sqw_rate(rtc, 1); printf("Set sqw rate, rc=%i\n", rc); rc = rtc_sqw_enable(rtc); printf("Set sqw enable, rc=%i\n", rc); rc = rtc_clock_start(rtc); printf("Started clock, rc=%i\n", rc); _delay_ms(1000); while(1) { rc = rtc_read(rtc, ¤t_dt); rtc_offset_time(¤t_dt, &offset_dt, -7); printf("rc = %i, %04i-%02i-%02i %02i:%02i:%02i %i offset: %04i-%02i-%02i %02i:%02i:%02i %i\n", rc, current_dt.year, current_dt.month, current_dt.date, current_dt.hour, current_dt.minute, current_dt.second, current_dt.day_of_week, offset_dt.year, offset_dt.month, offset_dt.date, offset_dt.hour, offset_dt.minute, offset_dt.second, offset_dt.day_of_week ); _delay_ms(1000); } return(0); }
int main(void) { InitLEDPort(); YellowLEDOn(); delay_sec(1); YellowLEDOff(); delay_sec(1); YellowLEDOn(); delay_sec(1); i2c_init(); // init I2C interface #ifdef UART_DEBUG uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei(); uart_puts_P("\r\n'lsm303test' ready!\r\n"); #endif // UART_DEBUG #ifdef LSM303DLH_USE_ACC LSM303DLHInitACC( I2C_DEV_LSM303DLH_ACC1 ); #endif // LSM303DLH_USE_ACC #ifdef LSM303DLH_USE_MAG LSM303DLHInitMAG( I2C_DEV_LSM303DLH_MAG ); #endif // LSM303DLH_USE_MAG while ( 1 ) { #ifdef UART_DEBUG uart_puts_P("\r\nRunning test... "); #endif // UART_DEBUG #if (defined LSM303DLH_USE_ACC) || (defined LSM303DLH_USE_MAG) # ifdef LSM303DLH_USE_ACC LSM303DLHTestACC(); # endif // LSM303DLH_USE_ACC # ifdef LSM303DLH_USE_MAG LSM303DLHTestMAG(); # endif // LSM303DLH_USE_MAG #else # ifdef UART_DEBUG uart_puts_p( cCRLF ); # endif // UART_DEBUG delay_sec(2); #endif // LSM303DLH_USE_ACC || LSM303DLH_USE_MAG } return 0; }
void simCommInit(){ uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); delay(commDelay); uart_puts("AT+IPR=9600"); sendCRLF(); delay(commDelay); if (strncmp( getAnswer(), successResp, 2 ) != 0){ //sendError } }
int main(void) { PORTB.DIR |= (1<<PIN4); PORTB.DIR |= (1<<PIN6); while(1){ PORTB.OUT |= (1<<PIN4); _delay_ms(500); PORTB.OUT &= ~(1<<PIN4); PORTB.OUT |= (1<<PIN6); _delay_ms(500); PORTB.OUT &= ~(1<<PIN6); } _delay_ms(500); //} //return 0; uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei(); /*while(1) { uint8_t i = 0; for (i=0; i<255; i++) { // Send one char. do{ * Wait until it is possible to put data into TX data register. * NOTE: If TXDataRegister never becomes empty this will be a DEADLOCK. */ /*}while(!((USART.STATUS & USART_DREIF_bm) != 0)); uart_putc(i); PORTC.OUT |= (1<<PIN5); _delay_ms(50); PORTC.OUT &= ~(1<<PIN5); _delay_ms(100); } _delay_ms(1000); }*/ while(1) { uint16_t byte = uart_getc(); if (byte != UART_NO_DATA) { uart_putc(byte); PORTC.OUT |= (1<<PIN5); _delay_ms(50); PORTC.OUT &= ~(1<<PIN5); _delay_ms(100); } } }
int main(void) { u08 c; char buffer[7]; int num=1; bool isFlowControlOn = true; bool isHexModeOn = false; ledsSet(1); ledsInit(); ledsSet(2); uartInit( UART_BAUD_SELECT( 9600, F_CPU ) ); ledsSet(3); uartFlowControlOn( true ); ledsSet(4); uartPutString("String stored in SRAM\n"); ledsSet(5); uartPutString("String stored in FLASH\n"); ledsSet(6); itoa( num, buffer, 10); // convert interger into string (decimal format) uartPutString(buffer); // and transmit string to UART uartPutString( "\n" ); ledsSet(7); //while ( !uartIsCharAvailable() ) { //do nothing //} //c = uartBlockingGetChar(); uartPutString( "You pressed: " ); //uartPutChar( c ); uartPutString( "\n" ); for(;;) { ledsSet(11); c = uartBlockingGetChar(); //_delay_ms( 100 ); ledsSet(12); if ( c == 'V' ) { uartPutString( "testSerial: " ); uartPutString( __DATE__ ); uartPutString( " " ); uartPutString( __TIME__ ); uartPutString( "\n" ); } else if ( c == 'B' ) { MCUCR = _BV(IVCE); MCUCR = _BV(IVSEL); //move interruptvectors to the boot sector sector asm volatile("jmp 0x3800"); } else if ( c == 'F' ) {
int main() { unsigned char i; char c='A'; int led; //DDRD = 0xff; // PB0 an PORTB als Ausgang setzen DDRD = (1 << PD4) | (1<<PD3); PORTD ^= (1 << PD4); uart_init(UART_BAUD_SELECT(2400, F_CPU)); sei(); //uart_puts("AAATEST"); //uart_putc(c); while(1) // Für immer { c = uart_getc(); if (c & UART_NO_DATA) { PORTD ^= (1 << PD3); continue; } // check for error if (c & UART_FRAME_ERROR) { continue; } if (c & UART_OVERRUN_ERROR) { continue; } if (c & UART_BUFFER_OVERFLOW) { continue; } if(c==0x00) continue; PORTD ^= (1 << PD4); uart_putc(c+1); /* for(led=2; led<5; led++) { PORTD = (1 << led); // Toggle PB0 z.B. angeschlossene LED for (i=1; i<=10; i++) _delay_ms(10); } for(led=3; led>2; led--continue PORTD = (1 << led); // Toggle PB0 z.B. angeschlossene LED for (i=1; i<=10; i++) _delay_ms(10); }*/ } return 0; }
/* ------------------------------------------------------------------------- */ void init(void) { /* most important: configure layer enable as output and low as the latches are not able to source more than one layer at once */ PORTC = 0; DDRC = 0xFF; DDRA = 0xFF; DDRD = 0xFF; PORTA = 0; PORTD = 0; cube_show_init(); //usbInit(); //usbReset(); // USB Poll with Timer1 (16Bit) TCCR1A = 0x00; TCCR1B = (1 << CS10); // prescale = 0 TCNT1 = USB_POLL_TCNT_START; TIMSK |= (1 << TOIE1); // Timer2 (8Bit) TCCR2 = 0x00; TCCR2 |= (1 << WGM21); // CTC TCCR2 |= (1 << CS22) | (1 << CS21) | (1 << CS20); // prescale = 1024 TCNT2 = 1; OCR2 = 125; // Ergibt genau 0,008 Sekunden TIMSK |= (1 << OCIE2); _delay_ms(1); sei(); _delay_ms(1); qBlock[0] = 0; qBlock[1] = 0; qBlock[2] = 0; qBlock[3] = 0; qBlock[4] = 0; qBlock[5] = 0; qBlock[6] = 0; falldown = 1; sekunden = 0; minuten = 0; stunden = 0; showTime = false; uart_init(UART_BAUD_SELECT(BAUDRATE, F_CPU)); }
/************************************************************************* Function: uartInit Purpose: initialize uart in 9600 8-N-1 standard and sets serial to stdout **************************************************************************/ void uartInit(void) { /* testado: OK */ /* * Initialize UART library, pass baudrate and AVR cpu clock * with the macro * UART_BAUD_SELECT() (normal speed mode ) * or * UART_BAUD_SELECT_DOUBLE_SPEED() ( double speed mode) */ uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); // setup our stdio stream stdout = &mystdout; }
/** * @brief Initializes MemoryTester * @param mt pointer to MemoryTester instance */ void MemoryTester_init(struct MemoryTester *mt) { /* open UART0 - 9600,N,8,1 */ ser_init(UART_BAUD_SELECT(9600, F_CPU)); // mt->inouterr = FDEV_SETUP_STREAM(ser_putch, ser_getch, _FDEV_SETUP_RW); FILE f = FDEV_SETUP_STREAM(ser_putch, ser_getch, _FDEV_SETUP_RW); mt->inouterr = f; stdin = stdout = stderr = &mt->inouterr; mt->window_base = NULL; mt->window_size = 0; puts_P(ver_str_pgm); }
int main(void) { FILE mystdout = FDEV_SETUP_STREAM(ser_putch, ser_getch, _FDEV_SETUP_RW); uint8_t key; /* pressed key */ stdout = stderr = stdin = &mystdout; /* open UART0 - 9600,N,8,1 - interrupt driven RxD */ ser_init( UART_BAUD_SELECT(9600, F_CPU) ); printf("\r\n---== Watchdog Timer ==---\r\n\n"); printf("MCU reset flags - 0x%02x\n\n", MCUCSR); printf(" Power-On Reset %s\n", MCUCSR & _BV(PORF) ? "1" : "0"); printf(" External Reset %s\n", MCUCSR & _BV(EXTRF) ? "1" : "0"); printf(" Brown-out Reset %s\n", MCUCSR & _BV(BORF) ? "1" : "0"); printf(" Watchdog Reset %s\n", MCUCSR & _BV(WDRF) ? "1" : "0"); printf(" JTAG Reset %s\n\n", MCUCSR & _BV(JTRF) ? "1" : "0"); if(MCUCSR & _BV(PORF) || MCUCSR & _BV(JTRF)) bootctr = 0; /* clear boot counter after power-on reset */ printf("Boot counter %d\n\n", bootctr++); MCUCSR = 0x00; /* clear information which reset source caused an MCU reset */ printf( "Press 's' for SW reset or 'h' for HW reset.\n\n"); while(1) { key = toupper(getchar()); /* read a key */ DDRD = 0xFF; /* set port D as output */ PORTD = 0x00; /* turn on LEDs on port D */ printf("Key pressed -> LEDs will be turned ON.\n"); switch(key) { case 'H' : reboot(HW_RESET); /* force HW reset */ break; case 'S' : reboot(SW_RESET); /* force SW reset */ break; default: break; } } }
void init(void){ NUMBER_OF_PACKETS = 0; TIMER_OVERFLOW = 0; uart_init(UART_BAUD_SELECT(MASTER_UART_BAUD_RATE, F_CPU )); //All initiialization is to be done here. softuart_init(PORT_1); softuart_init(PORT_2); adc_init(); sei(); motor_init(); // enable motors after both soft uart ports are enabled. timer_init(); }
int main () { uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,16000000L) ); _delay_ms(100); rfm12_init(); sei(); uart_puts("String stored in SRAM\n"); for(;;){ send_data(); _delay_ms(5000); } }
/* * Do all the startup-time peripheral initializations. */ static void ioinit(void) { uart_init((unsigned int) UART_BAUD_SELECT(F_CPU, 9600)); /* Timer; 8-bit Timer */ TIFR = 0; /* clear any possible interrupt-flags */ TCCR0 |= (_BV(CS01) | _BV(CS00)); #if defined(TIMER0_SETUP_HOOK) /* run timer-dependent hooks, when available */ TIMER0_SETUP_HOOK(); #endif /* Enable timer 0 overflow interrupt. */ TIMSK = _BV(TOIE0); sei (); }
int main( void ) //Главная функция { USART_Init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); //Скорость соединения 19200 бит/с for(;;) //Вечный цикл { USART_Transmit( USART_Receive() ); //Отправка принятого символа назад } }
int main(void) { char temp; LED1_INIT(); LED2_INIT(); uart_config_default_stdio(); uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei(); LED1_ON(); LED2_ON(); printf("\n\n********RFM22 Communication Test********\n"); LED1_ON(); LED2_OFF(); rfm22b_init(); txtest_configure_radio(); //====================// //Communications Test temp = rfm22b_read(DTYPE); temp = rfm22b_read(DVERS); temp = rfm22b_read(INTEN1); temp = rfm22b_read(INTEN2); temp = rfm22b_read(OMFC1); temp = rfm22b_read(OMFC2); LED1_OFF(); LED2_ON(); printf("*****************************************\n\n"); txtest_send_current_packet(); // Send test packet '0123456789:;<=>?" // This example allows you to enter a 16-byte packet to send printf("Entering TX Mode...Give me a 16-byte packet\n\n"); LED1_OFF(); LED2_OFF(); txtest_fill_packet_from_uart(); while(1) { txtest_send_current_packet(); _delay_ms(1000); } return 0; }
void main(void) { //Initialize IOs init_IO(); //Initialize the RTC init_rtc(); //Initialize the UART uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); //set the Global Interrupt Enable Bit sei(); while(1) { //Blink sekonds LED if (led_state == 1) { PORTB |= (1<<led_pin); // Turn on LED } else { PORTB &= ~(1<<led_pin); // Turn off LED } if (new_tick) { //Convert and display hours char buf [2]; itoa (t.hour,buf,10); uart_puts(buf); uart_puts(":"); //Convert and display minutes itoa (t.minute,buf,10); uart_puts(buf); uart_puts(":"); //Convert and display seconds itoa (t.second,buf,10); uart_puts(buf); uart_puts("\r\n"); new_tick = 0; } } }
int main(void) { char printbuff[100]; //init uart uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); //init interrupt sei(); #if DHT_FLOAT == 0 int8_t temperature = 0; int8_t humidity = 0; #elif DHT_FLOAT == 1 float temperature = 0; float humidity = 0; #endif for (;;) { if(dht_gettemperaturehumidity(&temperature, &humidity) != -1) { #if DHT_FLOAT == 0 itoa(temperature, printbuff, 10); #elif DHT_FLOAT == 1 dtostrf(temperature, 3, 3, printbuff); #endif uart_puts("temperature: "); uart_puts(printbuff); uart_puts("C");uart_puts("\r\n"); #if DHT_FLOAT == 0 itoa(humidity, printbuff, 10); #elif DHT_FLOAT == 1 dtostrf(humidity, 3, 3, printbuff); #endif uart_puts("humidity: "); uart_puts(printbuff); uart_puts("%RH");uart_puts("\r\n"); } else { uart_puts("error"); uart_puts("\r\n"); } uart_puts("\r\n"); _delay_ms(1500); } return 0; }