int initAccel(void)
{
initI2C();
enable_interrupts();
// Make sure the MPU6050 is awake by reading its WHO_AM_I register
if (readRegister(WHO_AM_I) == 0x68) {
powerUpAccel();
return 0; // ok
} else {
return -1; // device not found
}
}
void initIOBoard(void) {
unsigned char address;
initI2C();
for (address=0; address<4; address++) {
// Configure PCA9555
write2I2C(IO_ADDR|(address<<1), 3 /* output1 */, 0);
write2I2C(IO_ADDR|(address<<1), 7 /* config1 */, 0 /* output */);
write2I2C(IO_ADDR|(address<<1), 4 /* polarity0 */, 0xff /* invert all inputs */);
}
}
void main()
{
byte i;
long l;
initBus();
initADC();
initI2C();
#ifdef HAS_UART
initInterruptUarts();
#endif
for(i=0; i<16; i++)
cfgRegs[i] = 65;
byte i2cErrCount = 0;
while(1)
{
byte rx = readTemp(0x9E);
/* Read error */
if(rx == 255)
{
if(i2cErrCount < 10)
i2cErrCount++;
else
myTemperature = 255;
initI2C();
} else
{
i2cErrCount = 0;
myTemperature = rx;
}
}
}
int main()
{
// Clock configuration
SCU_PASSWD = 0x000000C0UL; // disable bit protection
SCU_CLKCR = 0x3FF00100UL; //MCLK = 32 MHz, PCLK = 32 MHz
while((SCU_CLKCR & MASK_SCU_CLKCR_VDDC2LOW));
SCU_PASSWD = 0x000000C3UL; // enable bit protection
// SystemCoreClockUpdate();
// setup Debug LEDs
InitGpioOutput( gpioPort0 , 0u );
// P0_IOCR0 |= BIT7; ///< P0.0
InitGpioOutput( gpioPort1 , 0u );
InitGpioOutput( gpioPort1 , 1u );
// P1_IOCR0 |= BIT7 + BIT15; ///< P1.0 + P1.1
rbGPIOp2.IOCR8 |= BIT23 + BIT31;
// P2_IOCR8 |= BIT23 + BIT31;
///< P2.10 + P2.11
rbGPIOp2.PDISC = rbGPIOp2.PDISC & ~BIT10;
// P2_PDISC = P2_PDISC & ~BIT10;
P2_PDISC = P2_PDISC & ~BIT11;
if( (initNVM() == NVMNoError) && (initI2C(I2CInst1,address) == I2CNoError) ){
I2C_Descr.writeBuf = I2C_Descr.IO_Buffer ;
I2C_Descr.recvCnt = 0u;
I2C_Descr.writeCnt = 0u;
enable_interrupts();
}
while(1){
};
return 0;
}
int main()
{
INTEnableSystemMultiVectoredInt();
initI2C();
initLCD();
CAN1Init();
Timer1Init();
while (1)
{
CAN1RxMsgProcess();
}
return 0;
}
char initAltimeter() {
initI2C();
altimeterConnected = checkDevicePresence(I2C_SLAVE_ADDRESS,WHO_AM_I_REG);
if (altimeterConnected){
char data[3] = {0xB8, 0x07, 0xB9};
sendMessage(I2C_SLAVE_ADDRESS, CONTROL_REGISTER1, &data[0], 1, WRITE);
sendMessage(I2C_SLAVE_ADDRESS, DATA_READY_EVENT_REGISTER, &data[1], 1, WRITE);
sendMessage(I2C_SLAVE_ADDRESS, CONTROL_REGISTER1, &data[2], 1, WRITE);
}
else{
#if DEBUG
debug("Altimeter Device Not Connected!");
#endif
}
return altimeterConnected;
}
uint16_t begin(void)
{
//! Todo: don't use _xgAddress or _mAddress, duplicating memory
_xgAddress = settings.device.agAddress;
_mAddress = settings.device.mAddress;
constrainScales();
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable
calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable
calcaRes(); // Calculate g / ADC tick, stored in aRes variable
if (settings.device.commInterface == IMU_MODE_I2C) // If we're using I2C
initI2C(); // Initialize I2C
else if (settings.device.commInterface == IMU_MODE_SPI) // else, if we're using SPI
initSPI(); // Initialize SPI
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
uint8_t mTest = mReadByte(WHO_AM_I_M); // Read the gyro WHO_AM_I
delay(DELAY * 150);
uint8_t xgTest = xgReadByte(WHO_AM_I_XG); // Read the accel/mag WHO_AM_I
uint16_t whoAmICombined = (xgTest << 8) | mTest;
if (whoAmICombined != ((WHO_AM_I_AG_RSP << 8) | WHO_AM_I_M_RSP))
{
return 0;
}
// Gyro initialization stuff:
initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc.
// Accelerometer initialization stuff:
initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc.
// Magnetometer initialization stuff:
initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc.
// Once everything is initialized, return the WHO_AM_I registers we read:
return whoAmICombined;
}
uint16_t LSM9DS0::begin(gyro_scale gScl, accel_scale aScl, mag_scale mScl,
gyro_odr gODR, accel_odr aODR, mag_odr mODR)
{
// Store the given scales in class variables. These scale variables
// are used throughout to calculate the actual g's, DPS,and Gs's.
gScale = gScl;
aScale = aScl;
mScale = mScl;
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable
calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable
calcaRes(); // Calculate g / ADC tick, stored in aRes variable
// Now, initialize our hardware interface.
if (interfaceMode == MODE_I2C) // If we're using I2C
initI2C(); // Initialize I2C
else if (interfaceMode == MODE_SPI) // else, if we're using SPI
initSPI(); // Initialize SPI
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
uint8_t gTest = gReadByte(WHO_AM_I_G); // Read the gyro WHO_AM_I
uint8_t xmTest = xmReadByte(WHO_AM_I_XM); // Read the accel/mag WHO_AM_I
// Gyro initialization stuff:
initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc.
setGyroODR(gODR); // Set the gyro output data rate and bandwidth.
setGyroScale(gScale); // Set the gyro range
// Accelerometer initialization stuff:
initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc.
setAccelODR(aODR); // Set the accel data rate.
setAccelScale(aScale); // Set the accel range.
// Magnetometer initialization stuff:
initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc.
setMagODR(mODR); // Set the magnetometer output data rate.
setMagScale(mScale); // Set the magnetometer's range.
// Once everything is initialized, return the WHO_AM_I registers we read:
return (xmTest << 8) | gTest;
}
int main(void) {
uint8_t tempHighByte, tempLowByte;
// -------- Inits --------- //
clock_prescale_set(clock_div_1); /* 8MHz */
initUSART();
printString("\r\n==== i2c Thermometer ====\r\n");
initI2C();
// ------ Event loop ------ //
while (1) {
/* To set register, address LM75 in write mode */
i2cStart();
i2cSend(LM75_ADDRESS_W);
i2cSend(LM75_TEMP_REGISTER);
i2cStart(); /* restart, just send start again */
/* Setup and send address, with read bit */
i2cSend(LM75_ADDRESS_R);
/* Now receive two bytes of temperature */
tempHighByte = i2cReadAck();
tempLowByte = i2cReadNoAck();
i2cStop();
// Print it out nicely over serial for now...
printByte(tempHighByte);
if (tempLowByte & _BV(7)) {
printString(".5\r\n");
}
else {
printString(".0\r\n");
}
/* Once per second */
_delay_ms(1000);
} /* End event loop */
return 0; /* This line is never reached */
}
void main()
{
byte writeIndex = 0;
byte i;
long l;
TRISB = 0xFFFF; /* All inputs */
LAT_BATT1_CTL = BATT_ENABLE;
LAT_BATT2_CTL = BATT_ENABLE;
LAT_BATT3_CTL = BATT_ENABLE;
LAT_BATT4_CTL = BATT_ENABLE;
#ifdef BBR2
LAT_BATT5_CTL = ~BATT_ENABLE;
#else
LAT_BATT5_CTL = BATT_ENABLE;
#endif
LAT_BATT6_CTL = BATT_ENABLE;
TRIS_BATT1_CTL = TRIS_OUT;
TRIS_BATT2_CTL = TRIS_OUT;
TRIS_BATT3_CTL = TRIS_OUT;
TRIS_BATT4_CTL = TRIS_OUT;
#ifdef BBR2
TRIS_BATT5_CTL = TRIS_IN;
#else
TRIS_BATT5_CTL = TRIS_OUT;
#endif
TRIS_BATT6_CTL = TRIS_OUT;
TRIS_BATT1 = TRIS_IN;
TRIS_BATT2 = TRIS_IN;
TRIS_BATT3 = TRIS_IN;
TRIS_BATT4 = TRIS_IN;
TRIS_BATT5 = TRIS_IN;
TRIS_BATT6 = TRIS_IN;
TRIS_WTRSEN = TRIS_IN;
LAT_PWRKILL = ~PWRKILL_ON;
TRIS_PWRKILL = TRIS_OUT;
TRIS_LED_STA = TRIS_OUT;
TRIS_LED_BATTLOW = TRIS_OUT;
LAT_LED_STA = LED_ON;
LAT_LED_BATTLOW = LED_ON;
initBus();
LAT_LED_STA = LED_ON;
LAT_LED_BATTLOW = ~LED_ON;
// while(1);
initADC();
initI2C();
initBattlowLight();
#ifdef HAS_UART
initInterruptUarts();
#endif
for(l=0; l<50000; l++);
LAT_LED_STA = LED_ON;
LAT_LED_BATTLOW = ~LED_ON;
for(l=0; l<50000; l++);
// LAT_PWRKILL = PWRKILL_ON;
LAT_LED_STA = ~LED_ON;
for(i=0; i<16; i++)
cfgRegs[i] = 65;
byte i2cErrCount = 0;
while(1)
{
// checkBus();
/* Give it a second */
// for(l=0; l<10000; l++);
byte rx = readTemp(0x9E);
/* Read error */
if(rx == 255)
{
if(i2cErrCount < 10)
i2cErrCount++;
else
myTemperature = 255;
initI2C();
} else
{
i2cErrCount = 0;
myTemperature = rx;
}
static const byte vADCs[]={ADC_B1V, ADC_B2V, ADC_B3V, ADC_B4V, ADC_B5V, ADC_B6V, ADC_26V};
/* Measure battery voltages */
for(i=0; i < 7; i++) {
#ifdef BBR2
/* There is no fifth battery in BBR2, so skip it */
if(i == 4) { vBatt[4]= 0; continue; }
#endif
setADC(vADCs[i]);
vBatt[i] = applyCalibration(readADC(), CAL_V_A, CAL_V_B);
}
/* Maintain running averages of the I sensors */
for(i=0; i < BATT_COUNT; i++) {
#ifdef BBR2
/* There is no fifth battery in BBR2, so skip it */
if(i == 4) { iADCVal[4][writeIndex] = 0; continue; }
#endif
setADC(iADCs[i]);
iADCVal[i][writeIndex] = readADC();
}
writeIndex++;
if(writeIndex >= IHISTORY_SIZE)
writeIndex = 0;
/* Calculate running averages of the battery currents */
for(i=0; i < BATT_COUNT; i++) {
#ifdef BBR2
/* There is no fifth battery in BBR2, so skip it. */
if(i == 4) { iBatt[4] = 0; continue; }
#endif
iBatt[i] = applyCalibration(avgRow(i), CAL_I12V_A, CAL_I12V_B);
}
}
}
// hardware init
void init(void)
{ // setup oscillator
//OSCCON=OSCCONVALUE;
OSCCONbits.SPLLEN=1; //software PLL enable x4 = 32mhz
OSCCONbits.IRCF = 14;//8MHZ
OSCCONbits.SCS =0;// osc dettermined by fosc
// setup i/o pins
// setup porta
PORTA=0x00;
LATA=0x00;
ANSELA=0x00;
TRISA=0xFF;
WPUA=0x00; // disable weakpullups
// setup portb
PORTB=0x00;
LATB=0x00;
ANSELB=0x00;
TRISB=0xFF;
WPUB=0x50; // enable pullups on Y1 and Y2
// setup portb
PORTC=0x00;
LATC=0x00;
ANSELC=0x00;
TRISC=0xD7; // everything is input, except leds
WPUC=0x05; // enable pullups on X1 and X2
nWPUEN=0; // enable weakpullups on jumpers
// setup PPS (sorta :))
APFCON0=0x00;
APFCON1=0x00;
LED1ON;
LED2ON;
//X is device
//Y is protocol
// check jumpers
mode_device=0x00;
mode_protocol=0x00;
mode_device|=(X2<<1);
mode_device|=(X1);
mode_protocol|=(Y2<<1);
mode_protocol|=(Y1);
// protocol specific initialisation
switch(mode_protocol)
{ case MODESPI: initSPI();
break;
case MODEI2C: initI2C();
break;
case MODEUART: initUART();
break;
case MODEUNK: break;
default: break;
}
LED1OFF;
// enable interrupts
// PEIE=1;
// GIE=1;
}
int main(void)
{
uint8_t year=0, month=0, day=0, hour=0, minute=0, second=0;
char str[16];
uint8_t count = 0, men = 0;
UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXC); //odblokowanie przerwania z odbiorem na urat
lcd_init();
USART_Init(MYUBRR);
initI2C();
LCD_DISPLAY(LCDDISPLAY);
LCD_CLEAR;
LCD_LOCATE(0,0);
lcd_puts("Hello!");
ds1307_setdate(91, 1, 14, 12, 00, 00);
sei();
while(1)
{
ds1307_getdate(&year, &month, &day, &hour, &minute, &second);
if (a == "N")
{
LCD_CLEAR;
men ++;
_delay_ms(20);
}
switch(men){
case 0:
LCD_LOCATE(5,1);
lcd_puts(itoa(hour, str, 10));
lcd_puts(":");
lcd_puts(itoa(minute, str, 10));
lcd_puts(":");
lcd_puts(itoa(second, str, 10));
lcd_puts(a);
break;
case 1:
LCD_LOCATE(5,1);
lcd_puts("20");
lcd_puts(itoa(year, str, 10));
lcd_puts("-");
lcd_puts(itoa(month, str, 10));
lcd_puts("-");
lcd_puts(itoa(day, str, 10));
break;
case 2:
men = 0;
break;
}
if (count == 20)
{
Send_Znak(a);
count=0;
}
count++;
_delay_ms(50);
}
}
// default
Adafruit_LSM9DS0::Adafruit_LSM9DS0( int32_t sensorID ) {
initI2C(sensorID);
}
void main(void){
//Initialize the clock to run the microprocessor
ARC_setup_lv();//sets up initializes the clocks and should be called at the beginning of main
//initCLK();//this is now set up in ARC_setup
//Initialize the uart to talk with terra term
P4DIR |= BIT1|BIT2|BIT3|BIT5|BIT6|BIT7;//LIGHT UP LED'S AS OUTPUTS
P4OUT &= ~(BIT1|BIT2|BIT3|BIT5|BIT6|BIT7);
//P4OUT |= BIT5;
VREGinit();//INITALIZE THE VOLTAGE REGULATOR
//initUART();//initalize when using TxChar(ch)
//setup I2C for use of UCB1
initI2C();
//set up timer
init_timerA(); // some of the set up is now started in ARC_setup
mmcInit_msp_off();
setup_launch_detect();
//setup_orbit_start();
UnusedPinSetup();//drive all unused pins to outputs
GyroOff();
SENSORSoff();
MAGoff();
ACCoff();
RESET_LED();
//Initialize the main task
initARCbus_pd(BUS_ADDR_LEDL);
// initARCbus(BUS_ADDR_LEDL);
//run MSP test
/*
MSPtest();
//RUN Oscillator Test
OscillatorTest();
//Turn temperature sensor/gyro/SD card on
SENSORSon();
//Turn temperature sensor/gyro/SD card off
SENSORSoff();
//Turn accelerometers on
ACCon();
//turn accelerometers off
ACCoff();
//Turn magnetometers on
MAGon();
//Turn magnetometers off
MAGoff();
*/
//Test the ADC functionality
//ADC_test();
//logging data for launch
//launch_data_log();
//test finished
//printf("YOU ARE FINISHED!!!\n\r");
memset(stack1,0xcd,sizeof(stack1));//function memset, sets all values(array stack1, everything equals this value,
//size of array so everything is changed)
stack1[0]=stack1[sizeof(stack1)/sizeof(stack1[0])-1]=0xfeed;//put marker values at the words before/after the stack.
memset(stack2,0xcd,sizeof(stack2)); // write known values into the stack
stack2[0]=stack2[sizeof(stack2)/sizeof(stack2[0])-1]=0xfeed; // put marker values at the words before/after the stack
memset(stack3,0xcd,sizeof(stack3)); // write known values into the stack
stack3[0]=stack3[sizeof(stack3)/sizeof(stack3[0])-1]=0xfeed; // put marker values at the words before/after the stack
memset(stack5,0xcd,sizeof(stack5)); // write known values into the stack
stack5[0]=stack5[sizeof(stack5)/sizeof(stack5[0])-1]=0xfeed; // put marker values at the words before/after the stack
memset(stack6,0xcd,sizeof(stack6)); // write known values into the stack
stack6[0]=stack6[sizeof(stack6)/sizeof(stack6[0])-1]=0xfeed; // put marker values at the words before/after the stack
ctl_events_init(&handle_SDcard, 0);
//start timer A (taken from Jesse's code so that I can have an interrupt for my timer)
//start_timerA();
ctl_task_run(&Perif_SetUp,BUS_PRI_LOW,Periferial_SetUp,"ARC Bus Test Program","Periferial_SetUp",sizeof(stack2)/sizeof(stack2[0])-2,stack2+1,0);//side note, the termainal can be used in two ways by either passing the uart functin or the async function
ctl_task_run(&I2C,BUS_PRI_NORMAL,(void(*)(void*))takeI2Cdata,NULL,"takeI2Cdata",sizeof(stack3)/sizeof(stack3[0])-2,stack3+1,0);
ctl_task_run(&LaunchData,BUS_PRI_HIGH,launch_data_log,NULL,"launch_data_log",sizeof(stack1)/sizeof(stack1[0])-2,stack1+1,0);//&LaunchData takes the address
ctl_task_run(&LEDL_events,BUS_PRI_NORMAL+10,sub_events,NULL,"sub_events",sizeof(stack6)/sizeof(stack6[0])-2,stack6+1,0);//this is to run orbit code
//ctl_task_run(&LaunchDetect,4,VerifyLaunchDetect,NULL,"VerifyLaunchDetect",sizeof(stack5)/sizeof(stack5[0])-2,stack5+1,0);
//of the variable which is the task structure is ,2 is the priority,launch_data_log is the function I want to run,"launch_data_log" is
//the name when I look at the threads window to identify the task,the size of the memory stack minus the guard bits,
//first location where data is stored second element in array (first element is guard bit), the zero is a placeholder
//since the MSP doesn't support this function.
//put this here for now
ctl_task_run(&ACDS_sen_task,BUS_PRI_LOW+10,ACDS_sensor_interface,NULL,"ACDS_sensor_interface",sizeof(stack5)/sizeof(stack5[0])-2,stack5+1,0);
//Use I2C sensor function to receive data
//Stay in an infinite loop
//for(;;){// taken care of in main loop
//P5SEL |= BIT6;//OUTPUT aclk
//P5DIR |= BIT6;//output aclk
mainLoop_lp();
mainLoop();
}
/**
* @brief Main function
* @param None
* @retval None
*/
int main(void)
{
char temp;
char str[20];
char c = '%';
int interval = 0;
int i;
unsigned int valid_data = 0;
int temperature, voltage;
signed int AverageCurrent;
unsigned int RemainingCapacity;
unsigned int soc; /* Stores State of Charge */
unsigned int dcap; /* Stores Design Capacity */
WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
initI2C();
/* Init UART for print message */
initUART();
printf("******************************************\r\n");
printf("This is a battery demo ! \r\n");
printf("Press: \r\n");
printf("1. To see the battery main parameter \r\n");
printf("2. To see the battery State of charge! \r\n");
printf("******************************************\r\n");
printf("\r\n");
printf("\r\n");
printf("\r\n");
temp = receiveByte();
while (1) {
if (temp == '1') {
/* Start the timer */
initTimer();
while (1) {
valid_data = 1;
/* Read temperature (units = 0.1K) */
if(!USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_TEMP_LSB)) {
/* Convert K to Celsius degree */
temperature = (transBytes2Int(RxDataBuff[1], RxDataBuff[0])) / 10 - 273;
} else {
valid_data = 0;
}
/* Read voltage (units = mV) */
if(!USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_VOLT_LSB)) {
voltage = transBytes2Int(RxDataBuff[1], RxDataBuff[0]);
} else {
valid_data = 0;
}
/* Read AverageCurrent (units = mA) */
if(!USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_AI_LSB)) {
AverageCurrent = transBytes2Int(RxDataBuff[1], RxDataBuff[0]);
} else {
valid_data = 0;
}
/* Read state of charge (units = %) */
if(!USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_SOC_LSB)){
soc = transBytes2Int(RxDataBuff[1], RxDataBuff[0]);
} else {
valid_data = 0;
}
/* Read DesignCapacity (units = mAH) */
if(!USCI_I2C_READ(RxDataBuff, 2, 0x2e)) {
dcap = transBytes2Int(RxDataBuff[1], RxDataBuff[0]);
} else {
valid_data = 0;
}
/* Read RemainingCapacity (units = mAH) */
if(!USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_RM_LSB)) {
RemainingCapacity = transBytes2Int(RxDataBuff[1], RxDataBuff[0]);
} else {
valid_data = 0;
}
/* every 10*0.5s print the battery message */
if (timerCount >= 10) {
/* Clear the console */
printf("\033[2J");
printf("\033[H");
if (valid_data) {
/* Read AverageCurrent (units = mA) */
USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_AI_LSB);
AverageCurrent = transBytes2Int(RxDataBuff[1], RxDataBuff[0]);
if (AverageCurrent > 0) {
printf("The battery is charging!\r\n");
} else {
printf("The battery is discharging!\r\n");
}
timerCount = 0;
printf("Current Temperature :%d¡æ\r\n", temperature);
printf("Current Voltage :%dmV\r\n", voltage);
printf("AverageCurrent :%dmA\r\n", AverageCurrent);
printf("State of Charge :%d", soc);
printf("%c\r\n", c);
printf("DesignCapacity :%dmAH\r\n", dcap);
printf("RemainingCapacity :%dmAH\r\n", RemainingCapacity);
} else {
timerCount = 0;
printf("There is no battery or the battery's capacity is too low\n\r");
printf("Please plugin a battery or charge the battery\n\r");
}
}
}
}
if (temp == '2') {
printf("Please set the show time interval(units = s)\r\n");
/* Get your input and store in str */
getstring(str);
/* Convert the string into int */
for (i = 0; str[i] != '\r'; i++) {
interval = interval * 10 + str[i] - '0';
}
/* Star the timer */
initTimer();
printf("\r\n");
timerCount = interval * 2;
while (1) {
/* Read state of charge (units = %) */
USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_SOC_LSB);
USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_SOC_LSB);
if(!USCI_I2C_READ(RxDataBuff, 2, bq27510CMD_SOC_LSB)) {
soc = transBytes2Int(RxDataBuff[1], RxDataBuff[0]);
} else {
if (timerCount >= interval * 2) {
timerCount = 0;
/* Clear the console */
printf("\033[2J");
printf("\033[H");
printf("There is no battery or the battery's capacity is too low\n\r");
printf("Please plugin a battery or charge the battery\n\r");
continue;
}
}
/* Show the state of charge every interval*2*0.5s */
//if (timerCount >= interval * 2) {
{
timerCount = 0;
printf("State of Charge :%d", soc);
printf("%c\r\n", c);
}
if (soc == 100) {
printf("State of Charge :%d", soc);
printf("%c\r\n", c);
temp = '0';
break;
}
}
}
}
}
void main(void) {
unsigned char state, menuState, x, y, menuButtonTouched,
currentProgramEditing, currentPeriodEditing,
currentMenuViewing = 0;
unsigned char tempTime;
char currentTempMenuViewing;
unsigned char released = 1; // Semaphore
unsigned char touched = 0;
extern struct room rooms[2]; // For programs Tab
extern unsigned char weeklySchedule[]; // For days tab
//EnableInterrupts; /* enable interrupts */
/* include your code here */
CONFIG1_COPD = 1;
INTSCR_MODE = 1;
INTSCR_IMASK = 1;
initI2C();
initPortX();
initADC();
initSCI();
configureTemp();
startTemp();
initFlash();
initializeDisplay();
initializeThermostat(); // Pass this function before enabling interrupts
drawMainScreen();
drawSolidButton(homeButton);
state = MAIN;
menuState = NONE;
//setModeMain(82,I_HEAT);
EnableInterrupts;
INTSCR_IMASK = 0;
for(;;) {
//sendModeAux(72, I_COOL);
saveProgramData();
// Poll clock
drawTopBar();
switch (state) {
case MAIN:
updateTemp();
break;
case PROGRAMS_TAB:
break;
case DAYS_TAB:
break;
case SETTINGS:
break;
}
// Poll touchscreen
if (!isScreenTouched()) {
released = 1;
}
if (isScreenTouched() && released) {
released = 0;
x = getX();
y = getY();
x = mapToXPixel(x);
y = mapToYPixel(y);
switch (state) {
case MAIN:
if (isOverride[currentRoom]) {
if (isButtonTouched(x, y, overrideButton)) {
isOverride[currentRoom] = 0;
drawMainScreen();
}
}
if (isButtonTouched(x, y, programButton)) {
drawProgramsTab();
state = PROGRAMS_TAB;
menuState = NONE;
}
else if (isButtonTouched(x, y, settingsButton)) {
drawSettingsScreen();
state = SETTINGS;
menuState = NONE;
}
else {
switch (menuState) {
case NONE:
if (isButtonTouched(x, y, setToButton)) {
switch (isOverride[currentRoom]) {
case 0:
currentMenuViewing = determineTempMenu(currentPeriod[currentRoom].temperature);
break;
case 1:
currentMenuViewing = determineTempMenu(overridePeriod[currentRoom].temperature);
break;
}
goToText(20, 1);
printNum(menuButtonTouched);
drawMainSetToMenu(currentMenuViewing);
menuState = SET_TO_MENU;
}
else if (isButtonTouched(x, y, roomButton)) {
drawMainRoomMenu();
menuState = ROOM_MENU;
}
else if (isButtonTouched(x, y, fanButton)) {
drawMainFanMenu();
menuState = FAN_MENU;
}
else if (isButtonTouched(x, y, modeButton)) {
drawMainModeMenu();
menuState = MAIN_MODE_MENU;
}
break;
case SET_TO_MENU:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, setToMenu);
if(menuButtonTouched) {
switch (currentMenuViewing) {
case 1:
if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 59 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 2:
if (menuButtonTouched == 1)
drawMainSetToMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 62 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 3:
if (menuButtonTouched == 1)
drawMainSetToMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 65 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 4:
if (menuButtonTouched == 1)
drawMainSetToMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 68 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 5:
if (menuButtonTouched == 1)
drawMainSetToMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 71 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 6:
if (menuButtonTouched == 1)
drawMainSetToMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 74 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 7:
if (menuButtonTouched == 1)
drawMainSetToMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 77 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 8:
if (menuButtonTouched == 1) {
drawMainSetToMenu(--currentMenuViewing);
}
else if (menuButtonTouched == 5)
drawMainSetToMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 80 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
case 9:
if (menuButtonTouched == 1) {
drawMainSetToMenu(--currentMenuViewing);
}
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 83 + menuButtonTouched);
drawMainScreen();
menuState = NONE;
}
break;
}
}
break;
case ROOM_MENU:
menuButtonTouched = isHorizontalMenuButtonTouched(x, y, roomMenu);
switch (menuButtonTouched) {
case 1:
currentRoom = ROOM_MAIN;
drawMainScreen();
menuState = NONE;
break;
case 2:
currentRoom = ROOM_AUX;
drawMainScreen();
menuState = NONE;
break;
}
break;
case FAN_MENU:
menuButtonTouched = isHorizontalMenuButtonTouched(x, y, fanMenu);
switch (menuButtonTouched) {
case 1:
fanMode[currentRoom] = FAN_ON;
drawMainScreen();
menuState = NONE;
break;
case 2:
fanMode[currentRoom] = FAN_OFF;
drawMainScreen();
menuState = NONE;
break;
case 3:
fanMode[currentRoom] = FAN_AUTO;
drawMainScreen();
menuState = NONE;
break;
}
break;
// Will cause manual override
case MAIN_MODE_MENU:
menuButtonTouched = isHorizontalMenuButtonTouched(x, y, modeMenu);
switch (menuButtonTouched) {
case 1:
overridePeriod[currentRoom].mode = HEAT;
menuState = NONE;
break;
case 2:
overridePeriod[currentRoom].mode = COOL;
menuState = NONE;
break;
case 3:
overridePeriod[currentRoom].mode = OFF;
menuState = NONE;
break;
}
if (overridePeriod[currentRoom].mode != currentPeriod[currentRoom].mode) {
isOverride[currentRoom] = 1;
}
else {
isOverride[currentRoom] = 0;
}
if (menuButtonTouched) {
drawMainScreen();
}
break;
}
}
/****END MENUSTATE****/
break;
/****END MAIN****/
case PROGRAMS_TAB:
if (isButtonTouched(x, y, homeButton)) {
drawMainScreen();
state = MAIN;
}
else if (isButtonTouched(x, y, settingsButton)) {
drawSettingsScreen();
state = SETTINGS;
}
else if (isButtonTouched(x, y, daysTab)) {
drawDaysTab();
state = DAYS_TAB;
}
else if (isButtonTouched(x, y, program1Button)) {
drawProgrammingScreen(0);
state = PROGRAMMING_SCREEN;
currentProgramEditing = 0;
}
else if (isButtonTouched(x, y, program2Button)) {
drawProgrammingScreen(1);
state = PROGRAMMING_SCREEN;
currentProgramEditing = 1;
}
else if (isButtonTouched(x, y, program3Button)) {
drawProgrammingScreen(2);
state = PROGRAMMING_SCREEN;
currentProgramEditing = 2;
}
else if (isButtonTouched(x, y, program4Button)) {
drawProgrammingScreen(3);
state = PROGRAMMING_SCREEN;
currentProgramEditing = 3;
}
break;
case PROGRAMMING_SCREEN:
if (isButtonTouched(x, y, homeButton)) {
drawMainScreen();
state = MAIN;
menuState = NONE;
}
else if (isButtonTouched(x, y, settingsButton)) {
drawSettingsScreen();
state = SETTINGS;
menuState = NONE;
}
else if (isButtonTouched(x, y, okButton)) {
drawProgramsTab();
state = PROGRAMS_TAB;
menuState = NONE;
}
switch (menuState) {
case NONE:
if (isButtonTouched(x, y, hour1Button)) {
currentPeriodEditing = 0;
currentMenuViewing = determineHoursMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
drawHoursMenu(currentMenuViewing);
menuState = HOURS_MENU;
}
else if (isButtonTouched(x, y, hour2Button)) {
currentPeriodEditing = 1;
currentMenuViewing = determineHoursMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
drawHoursMenu(currentMenuViewing);
menuState = HOURS_MENU;
}
else if (isButtonTouched(x, y, hour3Button)) {
currentPeriodEditing = 2;
currentMenuViewing = determineHoursMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
drawHoursMenu(currentMenuViewing);
menuState = HOURS_MENU;
}
else if (isButtonTouched(x, y, hour4Button)) {
currentPeriodEditing = 3;
currentMenuViewing = determineHoursMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
drawHoursMenu(currentMenuViewing);
menuState = HOURS_MENU;
}
else if (isButtonTouched(x, y, minutes1Button)) {
currentPeriodEditing = 0;
drawMinutesMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
menuState = MINUTES_MENU;
}
else if (isButtonTouched(x, y, minutes2Button)) {
currentPeriodEditing = 1;
drawMinutesMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
menuState = MINUTES_MENU;
}
else if (isButtonTouched(x, y, minutes3Button)) {
currentPeriodEditing = 2;
drawMinutesMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
menuState = MINUTES_MENU;
}
else if (isButtonTouched(x, y, minutes4Button)) {
currentPeriodEditing = 3;
drawMinutesMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime);
menuState = MINUTES_MENU;
}
else if (isButtonTouched(x, y, amPm1Button)) {
toggleAmPm(currentProgramEditing, 0);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
else if (isButtonTouched(x, y, amPm2Button)) {
toggleAmPm(currentProgramEditing, 1);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
else if (isButtonTouched(x, y, amPm3Button)) {
toggleAmPm(currentProgramEditing, 2);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
else if (isButtonTouched(x, y, amPm4Button)) {
toggleAmPm(currentProgramEditing, 3);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
else if (isButtonTouched(x, y, temp1Button)) {
currentPeriodEditing = 0;
currentMenuViewing = determineTempMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature);
drawProgrammingTempMenu(currentMenuViewing);
menuState = TEMP_MENU;
}
else if (isButtonTouched(x, y, temp2Button)) {
currentPeriodEditing = 1;
currentMenuViewing = determineTempMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature);
drawProgrammingTempMenu(currentMenuViewing);
menuState = TEMP_MENU;
}
else if (isButtonTouched(x, y, temp3Button)) {
currentPeriodEditing = 2;
currentMenuViewing = determineTempMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature);
drawProgrammingTempMenu(currentMenuViewing);
menuState = TEMP_MENU;
}
else if (isButtonTouched(x, y, temp4Button)) {
currentPeriodEditing = 3;
currentMenuViewing = determineTempMenu(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature);
drawProgrammingTempMenu(currentMenuViewing);
menuState = TEMP_MENU;
}
else if (isButtonTouched(x, y, mode1Button)) {
currentPeriodEditing = 0;
drawProgrammingModeMenu(currentPeriodEditing);
menuState = PROGRAM_MODE_MENU;
}
else if (isButtonTouched(x, y, mode2Button)) {
currentPeriodEditing = 1;
drawProgrammingModeMenu(currentPeriodEditing);
menuState = PROGRAM_MODE_MENU;
}
else if (isButtonTouched(x, y, mode3Button)) {
currentPeriodEditing = 2;
drawProgrammingModeMenu(currentPeriodEditing);
menuState = PROGRAM_MODE_MENU;
}
else if (isButtonTouched(x, y, mode4Button)) {
currentPeriodEditing = 3;
drawProgrammingModeMenu(currentPeriodEditing);
menuState = PROGRAM_MODE_MENU;
}
break;
case HOURS_MENU:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, hoursMenu);
if (menuButtonTouched) {
switch (currentMenuViewing) {
case 1:
if (menuButtonTouched == 5) {
drawHoursMenu(++currentMenuViewing);
}
else {
updateHours(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime), menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 2:
if (menuButtonTouched == 1)
drawHoursMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawHoursMenu(++currentMenuViewing);
else {
updateHours(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime), menuButtonTouched + 3);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 3:
if (menuButtonTouched == 1)
drawHoursMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawHoursMenu(++currentMenuViewing);
else {
updateHours(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime), menuButtonTouched + 6);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 4:
if (menuButtonTouched == 1)
drawHoursMenu(--currentMenuViewing);
else if (menuButtonTouched == 2) {
updateHours(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime), 11);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
else if (menuButtonTouched == 3) {
updateHours(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime), 12);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
}
}
break;
case MINUTES_MENU:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, minutesMenu);
if(menuButtonTouched) {
updateMinutes(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].startTime), menuButtonTouched - 1);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case TEMP_MENU:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, programmingTempMenu);
if(menuButtonTouched) {
switch (currentMenuViewing) {
case 1:
if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 59 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 2:
if (menuButtonTouched == 1)
drawProgrammingTempMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 62 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 3:
if (menuButtonTouched == 1)
drawProgrammingTempMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 65 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 4:
if (menuButtonTouched == 1)
drawProgrammingTempMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 68 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 5:
if (menuButtonTouched == 1)
drawProgrammingTempMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 71 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 6:
if (menuButtonTouched == 1)
drawProgrammingTempMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 74 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 7:
if (menuButtonTouched == 1)
drawProgrammingTempMenu(--currentMenuViewing);
else if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 77 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 8:
if (menuButtonTouched == 1) {
drawProgrammingTempMenu(--currentMenuViewing);
}
else if (menuButtonTouched == 5)
drawProgrammingTempMenu(++currentMenuViewing);
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 80 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
case 9:
if (menuButtonTouched == 1) {
drawProgrammingTempMenu(--currentMenuViewing);
}
else {
updateProgrammingTemp(&(rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].temperature), 83 + menuButtonTouched);
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
}
break;
}
}
break;
case PROGRAM_MODE_MENU:
programmingModeMenu[1] = (1 + 3*(currentPeriodEditing+1));
menuButtonTouched = isHorizontalMenuButtonTouched(x, y, programmingModeMenu);
switch (menuButtonTouched) {
case 1:
rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].mode = HEAT;
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
break;
case 2:
rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].mode = COOL;
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
break;
case 3:
rooms[currentRoom].programs[currentProgramEditing].periods[currentPeriodEditing].mode = OFF;
drawProgrammingScreen(currentProgramEditing);
menuState = NONE;
break;
}
programmingModeMenu[1] = 1;
break;
}
break;
case DAYS_TAB:
if (isButtonTouched(x, y, homeButton)) {
drawMainScreen();
state = MAIN;
menuState = NONE;
}
else if (isButtonTouched(x, y, settingsButton)) {
drawSettingsScreen();
state = SETTINGS;
menuState = NONE;
}
else if (isButtonTouched(x, y, programsTab)) {
drawProgramsTab();
state = PROGRAMS_TAB;
menuState = NONE;
}
switch (menuState) {
case NONE:
if (isButtonTouched(x, y, monButton)) {
drawDaysMenu(monMenu);
menuState = MONDAY;
}
else if (isButtonTouched(x, y, tueButton)) {
drawDaysMenu(tueMenu);
menuState = TUESDAY;
}
else if (isButtonTouched(x, y, wedButton)) {
drawDaysMenu(wedMenu);
menuState = WEDNESDAY;
}
else if (isButtonTouched(x, y, thuButton)) {
drawDaysMenu(thuMenu);
menuState = THURSDAY;
}
else if (isButtonTouched(x, y, friButton)) {
drawDaysMenu(friMenu);
menuState = FRIDAY;
}
else if (isButtonTouched(x, y, satButton)) {
drawDaysMenu(satMenu);
menuState = SATURDAY;
}
else if (isButtonTouched(x, y, sunButton)) {
drawDaysMenu(sunMenu);
menuState = SUNDAY;
}
break;
case MONDAY:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, monMenu);
if (menuButtonTouched) {
weeklySchedule[0] = menuButtonTouched - 1;
drawDaysTab();
menuState = NONE;
}
break;
case TUESDAY:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, tueMenu);
if (menuButtonTouched) {
weeklySchedule[1] = menuButtonTouched - 1;
drawDaysTab();
menuState = NONE;
}
break;
case WEDNESDAY:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, wedMenu);
if (menuButtonTouched) {
weeklySchedule[2] = menuButtonTouched - 1;
drawDaysTab();
menuState = NONE;
}
break;
case THURSDAY:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, thuMenu);
if (menuButtonTouched) {
weeklySchedule[3] = menuButtonTouched - 1;
drawDaysTab();
menuState = NONE;
}
break;
case FRIDAY:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, friMenu);
if (menuButtonTouched) {
weeklySchedule[4] = menuButtonTouched - 1;
drawDaysTab();
menuState = NONE;
}
break;
case SATURDAY:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, satMenu);
if (menuButtonTouched) {
weeklySchedule[5] = menuButtonTouched - 1;
drawDaysTab();
menuState = NONE;
}
break;
case SUNDAY:
menuButtonTouched = isVerticalMenuButtonTouched(x, y, sunMenu);
if (menuButtonTouched) {
weeklySchedule[6] = menuButtonTouched - 1;
drawDaysTab();
menuState = NONE;
}
break;
}
break;
case SETTINGS:
if (isButtonTouched(x, y, homeButton)) {
drawMainScreen();
state = MAIN;
}
else if (isButtonTouched(x, y, programButton)) {
drawProgramsTab();
state = PROGRAMS_TAB;
}
break;
}
refreshThermostat();
}
__RESET_WATCHDOG(); /* feeds the dog */
} /* loop forever */
/* please make sure that you never leave main */
}
