Example #1
0
static action_delay(int ms){
  int i = 0;
  for(;i<ms;++i)
    _delay_ms(1);
}
Example #2
0
//=============================================================================
//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);
		}
    }
}
Example #3
0
File: pmu.c Project: 211217613/uhd
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;
}
Example #4
0
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');
	




}
Example #5
0
// ============================================================================================
// 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();
    }

}
Example #6
0
void lcd_enable() {
        LCD_CONTROL_PORT |= 1 << LCD_EN;
        _delay_ms(2);
        LCD_CONTROL_PORT &= ~(1 << LCD_EN);
}
Example #7
0
// 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;
	
}
Example #8
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();
}
Example #9
0
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");
}
Example #10
0
void startup_user()
{
    _delay_ms(20); // gets rid of tick
    PLAY_NOTE_ARRAY(tone_startup, false, 0);
}
Example #11
0
void shutdown_user()
{
    PLAY_NOTE_ARRAY(tone_goodbye, false, 0);
    _delay_ms(150);
    stop_all_notes();
}
Example #12
0
// 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);


	}

}
Example #14
0
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();
	}
}
Example #15
0
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

	}

}
Example #16
0
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();
}
Example #17
0
/*
 * 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;
}
Example #18
0
// Don't buzz for a 750ms (used when band changing normally)
inline void buzz4kHz_Long_Pause()
{
  _delay_ms(750);
}
Example #19
0
/*
 * 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;
}
Example #20
0
// Don't buzz for 250ms (used for startup)
inline void buzz4kHz_Short_Pause()
{
  _delay_ms(250);
}
Example #21
0
void commit(int addr) {
	LEDs_TurnOffLEDs(LEDS_PMODE);
	accessData(0x4C, addr, 0x00);
	_delay_ms(30);
	LEDs_TurnOnLEDs(LEDS_PMODE);
}
Example #22
0
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();
      }
    }
  }
}
Example #23
0
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);
	
	
	
	
}
Example #24
0
void clearDisplay() {
  writeByte(0x01);
  _delay_ms(2);
}
Example #25
0
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();
		}																								
    }
}
Example #29
0
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;
}
Example #30
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;	
	
}