// functions
void i2cInit(void)
{
// set pull-up resistors on I2C bus pins
// TODO: should #ifdef these
sbi(PORTC, 0); // i2c SCL on ATmega163,323,16,32,etc
sbi(PORTC, 1); // i2c SDA on ATmega163,323,16,32,etc
sbi(PORTD, 0); // i2c SCL on ATmega128,64
sbi(PORTD, 1); // i2c SDA on ATmega128,64
// clear SlaveReceive and SlaveTransmit handler to null
i2cSlaveReceive = 0;
i2cSlaveTransmit = 0;
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
// set state
I2cState = I2C_IDLE;
// enable TWI interrupt and slave address ACK
sbi(TWCR, TWIE);
sbi(TWCR, TWEA);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
// enable interrupts
sei();
}
void i2cInit(void)
{
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN); // Enable TWI
}
// functions
void i2cInit(void)
{
GenCal_Flag = 1;
// set pull-up resistors on I2C bus pins
// this seems unnecessary, commented out by MBR
/*
sbi(PORTC, 0); // i2c SCL on ATmega163,323,16,32,etc
sbi(PORTC, 1); // i2c SDA on ATmega163,323,16,32,etc
sbi(PORTD, 0); // i2c SCL on ATmega128,64
sbi(PORTD, 1); // i2c SDA on ATmega128,64
*/
// clear SlaveReceive and SlaveTransmit handler to null
i2cSlaveReceive = 0;
i2cSlaveTransmit = 0;
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
// set state
I2cState = I2C_IDLE;
// enable TWI interrupt and slave address ACK
sbi(TWCR, TWIE);
sbi(TWCR, TWEA);
// outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
// enable interrupts
sei();
}
void i2cInit(void)
{
// set i2c bit rate to 40KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
//initialize
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x2D); //power register
i2cWaitForComplete();
i2cSendByte(0x08); //measurement mode
i2cWaitForComplete();
i2cSendStop();
i2cSendStart();
i2cWaitForComplete();
i2cSendByte(0xA6); //write to ADXL
i2cWaitForComplete();
i2cSendByte(0x31); //data format
i2cWaitForComplete();
i2cSendByte(0x08); //full resolution
i2cWaitForComplete();
i2cSendStop();
}
void spyglassInit(void)
{
i2cInit();
i2cSetBitrate(100);
PcfCtrlData = (SPYGLASS_LED0 | SPYGLASS_LED1 | SPYGLASS_BEEPER);
spyglassSetLeds(0);
spyglassSetBeeper(0);
}
// functions
void edpInit(void)
{
// initialize i2c interface and function library
i2cInit();
// set i2c bit rate to 30KHz
i2cSetBitrate(30);
// set the Slave Receive Handler function
// (this function will run whenever a master somewhere else on the bus
// writes data to us as a slave)
i2cSetSlaveReceiveHandler( edpSlaveReceiveService );
// set the Slave Transmit Handler function
// (this function will run whenever a master somewhere else on the bus
// attempts to read data from us as a slave)
i2cSetSlaveTransmitHandler( edpSlaveTransmitService );
}
// functions
void i2cInit(void)
{
// clear SlaveReceive and SlaveTransmit handler to null
i2cSlaveReceive = 0;
i2cSlaveTransmit = 0;
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// set state
I2cState = I2C_IDLE;
// enable TWI (two-wire interface)
// enable TWI interrupt and slave address ACK
TWCR |= BV(TWEN) | BV(TWIE) | BV(TWEA);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
// enable interrupts
}
int main(void) {
uchar i;
DDRC &= (~0x30);
_delay_ms(20);
DDRC |= (1U << 3);
PORTC |= (1U << 3);
i2cInit();
i2cSetBitrate(10);
i2cSetLocalDeviceAddr(0x80, TRUE);
i2cSetSlaveReceiveHandler(i2c_write);
_delay_ms(20);
PORTC ^= (1U << 3);
wdt_enable(WDTO_1S);
/* Even if you don't use the watchdog, turn it off here. On newer devices,
* the status of the watchdog (on/off, period) is PRESERVED OVER RESET!
*/
wdt_disable();
/* RESET status: all port bits are inputs without pull-up.
* That's the way we need D+ and D-. Therefore we don't need any
* additional hardware initialization.
*/
usbInit();
usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */
i = 0;
while(--i){ /* fake USB disconnect for > 250 ms */
wdt_reset();
_delay_ms(1);
}
usbDeviceConnect();
sei();
for(;;) { /* main event loop */
wdt_reset();
usbPoll();
}
return 0;
}
void twi_init(void)
{
#if TWILIB == AVR315 || TWILIB == AVR315_SYNC || TWILIB == AVR315_QUEUED
TWI_Master_Initialise();
#elif TWILIB == BUFFTW
i2cInit();
i2cSetBitrate(400);
#else
twi_init();
#endif
}
// functions
void i2cInit(void)
{
// set pull-up resistors on I2C bus pins
// TODO: should #ifdef these
//sbi(PORTC, 4); // i2c SCL on ATmega163,323,16,32,etc
//sbi(PORTC, 5); // i2c SDA on ATmega163,323,16,32,etc
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
// set state
I2cState = I2C_IDLE;
// enable TWI interrupt and slave address ACK
sbi(TWCR, TWIE);
sbi(TWCR, TWEA);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
}
void ads7828test(void)
{
u08 i;
u16 conv=0;
// initialize i2c function library
i2cInit();
i2cSetBitrate(30);
// initialize
if(ads7828Init(ADS7828_I2C_ADDR))
{
rprintf("ADS7828 detected and initialized!\r\n");
}
else
{
rprintf("Cannot detect ADS7828!\r\n");
return;
}
// use the externally applied voltage on REF pin
ads7828SetReference(0);
// or use the internal 2.5V voltage reference
//ads7828SetReference(1);
while(1)
{
// position cursor
vt100SetCursorPos(4,1);
for(i=0; i<8; i++)
{
// convert
conv = ads7828Convert(ADS7828_I2C_ADDR, i);
// print results
rprintf("CH#%d: Conversion result is: %d \r\n", i, conv-2048);
}
// pause between readings
timerPause(100);
}
}
// functions
void i2cInit(void)
{
// set pull-up resistors on I2C bus pins
sbi(I2C_SCL_PORT, I2C_SCL_PIN);
sbi(I2C_SDA_PORT, I2C_SDA_PIN);
// clear SlaveReceive and SlaveTrasmit handler to null
i2cSlaveReceive = 0;
i2cSlaveTransmit = 0;
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
// set state
I2cState = I2C_IDLE;
// enable TWI interrupt and slave address ACK
sbi(TWCR, TWIE);
sbi(TWCR, TWEA);
// enable interrupts
sei();
}
// functions
void i2cInit(void) {
#ifdef I2C_USE_INT_PULLUP_RESISTORS
// set pull-up resistors on I2C bus pins
#if (defined (__AVR_ATmega64C1__) || defined (__AVR_ATmega64M1__) ||\
defined (__AVR_ATmega128__) || defined (__AVR_ATmega1280__) ||\
defined (__AVR_ATmega1281__) || defined (__AVR_ATmega1284P__) ||\
defined (__AVR_ATmega128RFA1__) || defined(__AVR_ATmega2560__))
sbi(PORTD, 0); // i2c SCL on ATmega128,64
sbi(PORTD, 1); // i2c SDA on ATmega128,64
#elif (defined (__AVR_ATmega8__) || defined (__AVR_ATmega8A__))
sbi(PORTC, 5); // i2c SCL on ATmega8
sbi(PORTC, 4); // i2c SDA on ATmega8
#else
sbi(PORTC, 0); // i2c SCL on ATmega163,323,16,32,etc
sbi(PORTC, 1); // i2c SDA on ATmega163,323,16,32,etc
#endif
#endif
// clear SlaveReceive and SlaveTransmit handler to null
i2cSlaveReceive = 0;
i2cSlaveTransmit = 0;
i2cStopHandler = 0;
// set i2c bit rate to 100KHz
i2cSetBitrate(100);
// enable TWI (two-wire interface)
sbi(TWCR, TWEN);
// set state
I2cState = I2C_IDLE;
// enable TWI interrupt and slave address ACK
sbi(TWCR, TWIE);
sbi(TWCR, TWEA);
//outb(TWCR, (inb(TWCR)&TWCR_CMD_MASK)|BV(TWINT)|BV(TWEA));
// enable interrupts
sei();
}
int main(void) {
DDRD = 0xff;
DDRB = 0xff;
DDRA = 0xff;
clear();
init();
frame = 0;
i2cInit();
i2cSetBitrate(10);
i2cSetLocalDeviceAddr(LOCAL_ADDR, TRUE);
i2cSetSlaveReceiveHandler( i2cSlaveReceiveService );
i2cSetSlaveTransmitHandler( i2cSlaveTransmitService );
frameDelay = 100;
// continuously loop
while(1) {
// draw();
// updateOffsets();
// frame++;
// _delay_ms(frameDelay);
}
}
int main (void)
{
I2C_init();
i2cSetBitrate(100);
pca9685_init(PCA9685_WRITE);
/*just for calibration purpose*/
uint16_t pwm_data[] = {
//0b0000000000101001, //decimal=41 -> 1% PWM
0b0000000001010010, //decimal=82 -> 2% PWM
0b0000000001111011, //decimal=123 -> 3% PWM
0b0000000010100111, //decimal=167 -> 4% PWM
0b0000000011001101, //decimal=205 -> 5% PWM
0b0000000011110110, //decimal=246 -> 6% PWM
0b0000000100011111, //decimal=287 -> 7% PWM
0b0000000101001000, //decimal=328 -> 8% PWM
0b0000000101101100, //decimal=365 -> 9% PWM
0b0000000110011010, //decimal=410 -> 10% PWM
0b0000000111000011, //decimal=451 -> 11% PWM
0b0000000111101100, //decimal=492 -> 12% PWM
0b0000001000010100, //decimal=532 -> 13% PWM
0b0000001000111101, //decimal=573 -> 14% PWM
0b0000001001100110, //decimal=614 -> 15% PWM
//0b0000001010001111, //decimal=655 -> 16% PWM
//0b0000001010111000, //decimal=696 -> 17% PWM
//0b0000001011100001, //decimal=737 -> 18% PWM
//0b0000001100001010, //decimal=778 -> 19% PWM
//0b0000001100110011, //decimal=819 -> 20% PWM
};
while(1)
{
/*servo_neutral(PCA9685_WRITE, 3);
_delay_ms(500);
servo_left(PCA9685_WRITE, 3);
_delay_ms(500);
servo_neutral(PCA9685_WRITE, 3);
_delay_ms(500);
servo_right(PCA9685_WRITE, 3);
_delay_ms(500);*/
I2C_start();
I2C_write(PCA9685_WRITE);
I2C_write(FIRST_CHANNEL);
I2C_write(0x01); //channel 0
I2C_write(0x00);
I2C_write(pwm_data[8]);
I2C_write(pwm_data[8]>>8);
I2C_write(0x01); //channel 1
I2C_write(0x00);
I2C_write(pwm_data[11]);
I2C_write(pwm_data[11]>>8);
I2C_write(0x01); //channel 2
I2C_write(0x00);
I2C_write(pwm_data[1]);
I2C_write(pwm_data[1]>>8);
I2C_stop();
_delay_ms(2000);
I2C_start();
I2C_write(PCA9685_WRITE);
I2C_write(FIRST_CHANNEL);
I2C_write(0x01); //channel 0
I2C_write(0x00);
I2C_write(pwm_data[1]);
I2C_write(pwm_data[1]>>8);
I2C_write(0x01); //channel 1
I2C_write(0x00);
I2C_write(pwm_data[3]);
I2C_write(pwm_data[3]>>8);
I2C_write(0x01); //channel 2
I2C_write(0x00);
I2C_write(pwm_data[1]);
I2C_write(pwm_data[1]>>8);
I2C_stop();
_delay_ms(2000);
}
}
int main(void)
{
#if _EXT_EEPROM_EMPTY==1
DDRB=0xFF;
PORTB=0x00;
i2cSetBitrate(100); //Ustaw prêdkoœæ i2c na 100kHz
EXT_EEPROM_var *struktura_eeprom;
struktura_eeprom=malloc(sizeof(EXT_EEPROM_var));
strcpy(struktura_eeprom->empty, " ");
strcpy(struktura_eeprom->temperatura, "Temperatura: ");
strcpy(struktura_eeprom->m1, "Ustawienia ");
strcpy(struktura_eeprom->m10, "Data: ");
strcpy(struktura_eeprom->m11, "Godzina: ");
strcpy(struktura_eeprom->m12, "LCD: ");
strcpy(struktura_eeprom->eePCF_Sunday, "Niedziela");
strcpy(struktura_eeprom->eePCF_Monday, "Poniedzialek");
strcpy(struktura_eeprom->eePCF_Tuesday, "Wtorek");
strcpy(struktura_eeprom->eePCF_Wednesday, "Sroda");
strcpy(struktura_eeprom->eePCF_Thursday, "Czwartek");
strcpy(struktura_eeprom->eePCF_Friday, "Piatek");
strcpy(struktura_eeprom->eePCF_Saturday, "Sobota");
strcpy(struktura_eeprom->eePCF_January, "Styczen");
strcpy(struktura_eeprom->eePCF_February, "Luty");
strcpy(struktura_eeprom->eePCF_March, "Marzec");
strcpy(struktura_eeprom->eePCF_April, "Kwiecien");
strcpy(struktura_eeprom->eePCF_May, "Maj");
strcpy(struktura_eeprom->eePCF_June, "Czerwiec");
strcpy(struktura_eeprom->eePCF_July, "Lipiec");
strcpy(struktura_eeprom->eePCF_August, "Sierpien");
strcpy(struktura_eeprom->eePCF_September, "Wrzesien");
strcpy(struktura_eeprom->eePCF_October, "Pazdziernik");
strcpy(struktura_eeprom->eePCF_November, "Listopad");
strcpy(struktura_eeprom->eePCF_December, "Grudzien");
PORTB=0x0F;
EI2C_write_buf(ADDR_EEMEM_24C64, 0, sizeof(EXT_EEPROM_var), (uint8_t*)struktura_eeprom);
free(struktura_eeprom);
PORTB=0xFF;
#endif // _EXT_EEPROM_EMPTY
#if _EXT_EEPROM_EMPTY==0
char bufor_lcd[41]; //Bufor przechowuj¹cy znaki z pamiêci EEPROM
//Zmienne wykorzystywane w opóŸnieniach:
uint8_t state=0;
uint32_t cnt=0, offset_cnt=0;
uint8_t state_light=0;
uint32_t cnt_light=0, offset_cnt_light=0;
Ustawienia ustawienia; //Struktura s³u¿¹ca do odczytania ustawieñ z EEPROM
ustawienia.ustawienia_poczatkowe=0;
//Ustaw PORTB jak wyjœcie dla LED:
DDRB=0xFF;
PORTB=0x00;
Flagi.flaga_klawiatura=1;
//// ustawienia TIMER0, przerwanie co 10us
OCR0 = 19;
TCCR0 |= (1<<WGM01); //Tryb ctc
TCCR0 |= (1<<CS01); // Preskaler 8
TIMSK |= (1<<OCIE0);
// Przerwanie INT0
MCUCR |= (1<<ISC01); // wyzwalanie zboczem opadaj¹cym
GICR |= (1<<INT0); // odblokowanie przerwania
PORTD |= (1<<PD2); // podci¹gniêcie pinu INT0 do VCC
i2cSetBitrate(100); //Ustaw prêdkoœæ i2c na 100kHz
lcd_init();
pobierz_czas(&czas);
pobierz_date(&data);
/* sprawdzamy ile czujników DS18xxx widocznych jest na magistrali */
czujniki_cnt = search_sensors();
/* wysy³amy rozkaz wykonania pomiaru temperatury
* do wszystkich czujników na magistrali 1Wire
* zak³adaj¹c, ¿e zasilane s¹ w trybie NORMAL,
* gdyby by³ to tryb Parasite, nale¿a³oby u¿yæ
* jako pierwszego prarametru DS18X20_POWER_PARASITE */
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
/* czekamy 750ms na dokonanie konwersji przez pod³¹czone czujniki */
_delay_ms(750);
/* dokonujemy odczytu temperatury z pierwszego czujnika o ile zosta³ wykryty */
/* wyœwietlamy temperaturê gdy czujnik wykryty */
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);
else {
lcd_locate(0,0);
lcd_str("term. error "); /* wyœwietlamy informacjê o b³êdzie jeœli np brak czujnika lub b³¹d odczytu */
}
#endif // _EXT_EEPROM_EMPTY
while (1)
{
#if _EXT_EEPROM_EMPTY==0
eeprom_read_block(&ustawienia, &deafult_flags, sizeof(deafult_flags));
if (ustawienia.ustawienia_poczatkowe)
{
eeprom_read_block(&data, &deafult_data, sizeof(data));
eeprom_read_block(&czas, &deafult_czas, sizeof(czas));
ustaw_date(&data);
ustaw_czas(&czas);
ustawienia.ustawienia_poczatkowe=0;
eeprom_update_block(&ustawienia, &deafult_flags, sizeof(deafult_flags));
}
switch(state_light)
{
case 0:
if (Flagi.light_lcd)
{
state_light=1;
cli();
cnt_light=200000;
offset_cnt_light=licznik;
sei();
}
break;
case 1:
if(cnt_light<=licznik-offset_cnt_light)
{
Flagi.light_lcd=0;
state_light=0;
}
break;
}
lcd_light(Flagi.light_lcd);
//OpóŸnienie dzia³añ po wciœniêciu przycisku
switch(state)
{
case 0:
key_code=debouncer(KlawiaturaSkan());
if(key_code)
{
state=1;
Flagi.light_lcd=1; //W³¹cz podœwietlanie LCD
cli();
cnt=50000;
offset_cnt=licznik;
sei();
}
break;
case 1:
key_code=0;
if(cnt<=licznik-offset_cnt)
{
state=0;
}
break;
}
if (Flagi.flaga_menu_func==1)
{
EI2C_read_buf(ADDR_EEMEM_24C64, menu_ptr->addr_ext_eeprom, menu_ptr->size_ext_eeprom, (uint8_t *)bufor_lcd);
if(Flagi.flaga_lcd)
{
lcd_locate(0, 0);
}
(*menu_ptr->funkcja)(bufor_lcd); //WskaŸnik na funkcje dla danej pozycji menu
}
if(Flagi.flaga_klawiatura==1)
{
if (key_code == PRZYCISK_PRAWO)
{
if(menu_ptr->next!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->next;
}
}
else if (key_code == PRZYCISK_LEWO)
{
if(menu_ptr->prev!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->prev;
}
}
else if (key_code == PRZYCISK_DOL)
{
if(menu_ptr->down!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->down;
}
}
else if (key_code == PRZYCISK_GORA)
{
if(menu_ptr->up!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->up;
}
}
}
if(menu_ptr->funkcja!=NULL)
Flagi.flaga_menu_func=1;
else
Flagi.flaga_menu_func=0;
#endif // _EXT_EEPROM_EMPTY
}
}
int main(void)
{
unsigned char tempSec;
get_mcusr(); // Disable the watchdog timer
uartInit(); // Init both UARTs
uartSetBaudRate(0,BAUD);
uartSetBaudRate(1,BAUD);
stdout = stdin = &uart1_str; // Init the stdout and stdin (printf, scanf...) functions
stderr = &uart0_str; // Init the stderror functions
i2cInit();
i2cSetBitrate(100);
ds1307_enable(DS1307_I2C_ADDR); // Enable the DS1307 RTC
// Make a flash on LEDs connected to PORTB when starting / restarting
DDRB=0xff; // PORTB output
PORTB=0xff; // All bits on port B = 1
_delay_ms(1000); // Wait until XBee modem has started
PORTB=0x00; // All bits on port B = 0
// Empty the receive buffer of both UARTs
uartFlushReceiveBuffer(EthUART);
uartFlushReceiveBuffer(XBeeUART);
wdt_enable(WDTO_2S); // Enable watchdog, reset after 2 seconds
wdt_reset();
while(1)
{
wdt_reset(); // Reset the watchdog timer
tempSec=time.sec;
if(ds1307_gettime(DS1307_I2C_ADDR, &time))
{ //if(tempSec!=time.sec)
if((time.sec%2==0)&&(tempSec!=time.sec)) // True every 2nd second
{
while(!uartReceiveBufferIsEmpty(XBeeUART))
{
int i;
i=0;
signed char XBeePacket[12];
// Read data from slave module
while (i<13)
{
while (uartReceiveBufferIsEmpty(XBeeUART))
;;
// Syncronization
uartReceiveByte(XBeeUART, &XBeePacket[i]);
if (XBeePacket[i]=='~') // Counter is set to 0 if the current character is '~'
i=0;
if (XBeePacket[0]=='~') //Increment if the first character in received data is '~'
i++;
}
sm[XBeePacket[7]-'0'].temp=XBeePacket[12]-7; // Compensate for heat from components in slave module
// Check status of slave module and make status ready to send to webserver
if (XBeePacket[10]=='f')
sm[XBeePacket[7]-'0'].status=0;
else if (XBeePacket[10]=='n')
sm[XBeePacket[7]-'0'].status=1;
XBeePacketCounter[XBeePacket[7]-'0']=1; // Set packet counter for this slave module to 1
}
// Check packet counter of all modules, if false: status=2 is sent to the webserver
// Webserver will then now which modules that are unconnected
for (int i=0; i<noOfModules; i++)
{
if (!XBeePacketCounter[i])
sm[i].status=2;
XBeePacketCounter[i]=0;
}
// Receive data from webserver
if (checkForEthPacket(ethPacket))
{
if (ethPacket[pHour]<24)// edit time
{
time.yr=ethPacket[pYear];
time.mon=ethPacket[pMonth];
time.dat=ethPacket[pDate];
time.hr=ethPacket[pHour];
time.min=ethPacket[pMin];
ds1307_settime(DS1307_I2C_ADDR,time);
}
int number=0;
while (number<noOfModules)
{
sm_web[number].type=ethPacket[pType+number*pFieldsModules];
sm_web[number].status=ethPacket[pStatus+number*pFieldsModules];
sm_web[number].temp=ethPacket[pTemp+number*pFieldsModules];
switch (sm_web[number].type)
{
case 0:
if (sm_web[number].status==0) // Check if the current slave module is disabled on the website
sendSlaveModule(number,0); // Send data to slave module: turn off relay
else
{
if ((sm[number].temp)<(sm_web[number].temp-1)) // Measured temperature < wanted temperature - 1 ?
sendSlaveModule(number,1); // Send data to slave module: turn on relay
else if ((sm[number].temp)>(sm_web[number].temp+1)) // Measured temperature > wanted temperature + 1 ?
sendSlaveModule(number,0); // Send data to slave module: turn off relay
else
sendSlaveModule(number,2); // Send data to slave module
}
break;
}
number++; // next slave module
}
}
sendEthPacket(time, sm); // send packet with data to webserver
}
}
}
return 0;
}
//to initialize the i2c subroutine
void initI2c(void)
{
i2cInit();
i2cSetBitrate(100);
}
//#########################################
//#########################################
//#########################################
// S T A R T M A I N P R O G R A M
int main(void)
{
//-----------------------------------------
// Allocate memory
//-----------------------------------------
int32_t temperature = 0;
int32_t pressure = 0;
int16_t BMP085_calibration_int16_t[8];
int16_t BMP085_calibration_uint16_t[3];
uint8_t error_code=0;
int32_t altitude=0;
//-----------------------------------------
// Initialize Stuff
//-----------------------------------------
//uart_init(); //Initialize UART0
volatile int16_t testVar;
_delay_ms(11);
i2cSetBitrate(1000); //Initialize TWI 1000kHz
BMP085_Calibration(BMP085_calibration_int16_t, BMP085_calibration_uint16_t,&error_code);////Initialize BMP085
lcd_init();
lcd_set_font(FONT_FIXED_8,NORMAL);
//-----------------------------------------
// Do forever
//-----------------------------------------
//printf("error code global init: %d \n",error_code);
while(1)
{
/*
printf("------------------------\n");
printf("------------------------\n");
printf("Pressure raw %ld \n",bmp085ReadPressure(&error_code));
printf("error code global: %d \n",error_code);
printf("------------------------\n");
printf("------------------------\n");
printf("Temperature raw %ld \n",bmp085ReadTemp(&error_code));
printf("error code global: %d \n",error_code);
printf("------------------------\n");
printf("------------------------\n");
*/
bmp085Convert(BMP085_calibration_int16_t, BMP085_calibration_uint16_t,&temperature, &pressure,&error_code);
lcd_moveto_xy (1, 0);
lcd_put_string_P(FONT_FIXED_8, NORMAL, PSTR("Temp: "));
lcd_put_int((int16_t)temperature);
lcd_moveto_xy (2, 0);
lcd_put_string_P(FONT_FIXED_8, NORMAL, PSTR("Pressure: "));
lcd_put_int((int16_t)pressure);
altitude = bmp085CalcAltitude (pressure);
lcd_moveto_xy (3, 0);
lcd_put_string_P(FONT_FIXED_8, NORMAL, PSTR("Altitude: "));
lcd_put_int((int16_t)altitude);
/*
printf("Temperature: %ld (in 0.1 deg C)\n", temperature);
printf("Pressure: %ld Pa\n\n", pressure);
printf("Altitude: %ld dm\n", bmp085CalcAltitude(pressure));
printf("error code global: %d \n",error_code);
printf("------------------------\n");
printf("------------------------\n");
*/
_delay_ms(200);
}
return 0;
}
