//-------pin definition of LEDs---------------//
#define LED4	5
#define LED3	4
#define LED2	3
#define LED1	2

void setup()
{
	/*Initialization for the hardware.*/
	init_pins();
}
void loop()
{
	byte speed = 1;
	runLED(speed);//Sweeping speed of LEDs, range from 1 to 10.
}
/*Initialization for the hardware,and should be call first*/
void init_pins()
{
	pinMode(LED4, OUTPUT);
	pinMode(LED3, OUTPUT);
	pinMode(LED2, OUTPUT);
	pinMode(LED1, OUTPUT);
	turnOffAll();//Turn off all the LEDs first.
}
/*Turn on one LED*/
inline void turnOn(int pinLED)
{
	digitalWrite(pinLED, HIGH);
}
/*Turn Off one LED*/
inline void turnOff(int pinLED)
{
	digitalWrite(pinLED, LOW);
}
/*Turn on all the LEDs*/
inline void turnOnAll()
{
	turnOn(LED4);
	turnOn(LED3);
	turnOn(LED2);
	turnOn(LED1);
}
/*Turn off all the LEDs*/
inline void turnOffAll()
{
	turnOff(LED4);
	turnOff(LED3);
	turnOff(LED2);
	turnOff(LED1);
}
/****************************************************************/
/*Function:Sweep all LEDs.								        */
/*Parameter:byte speed,range from 1 to 10,1 = lowest,10 = fastest*/
/*Return:	void 												 */
void runLED(byte speed)
{
	if((speed > 0)&&(speed < 11))//If the value of speed is valid?
	{
		uint8_t shifter = 0x01;
		for(uint8_t i = 0;i < 4;i ++)
		{
			if(shifter&0x01)//if the lowest significant bit that represents LED1 is HIGH? 
				turnOn(LED1);//yes, turn on LED1.
			else			
				turnOff(LED1);//no, turn off LED1.
			if(shifter&0x02) 
				turnOn(LED2);
			else			
				turnOff(LED2);
			if(shifter&0x04) 
				turnOn(LED3);
			else			
				turnOff(LED3);
			if(shifter&0x08)
				turnOn(LED4);
			else			
				turnOff(LED4);
			shifter <<= 1;//left shift 1 bit, light up the next LED and put out the current one.
			delay(500/speed);
		}
		turnOffAll();//Turn off all LEDs after running the LEDs
	}
}

/*The end of the runLED.ino*/

        

#include <TimerOne.h>

#define DEBUG 1//comment out if you don't need debug information

//-------pin definition of LEDs---------------//
#define LED_CLOCK_ADJUST	5
#define LED_ALARM_ADJUST	4
#define LED_ALARM_ENABLE	3
#define LED_BRIGHTNESS_ADJUST	2
//-------pin definition of keys---------------//
#define KEY_MENU	11
#define KEY_UP		10
#define KEY_DOWN	9

//------the status of the test---------------//
/*Every time the MENU key pressed, it toggle status between TEST_START and TEST_END	*/
/*When it is TEST_START, it turns to be TESTING if UP key or DOWN key is pressed.*/
uint8_t status;
	#define TEST_END   0 //the LEDs are off
	#define TEST_START 1 //the LEDs blink once per second
	#define TESTING	   2 //UP key or DOWN key can control the LEDs
	
const int LEDS_PIN[] = 
{
	LED_BRIGHTNESS_ADJUST,
	LED_ALARM_ENABLE,
	LED_ALARM_ADJUST,
	LED_CLOCK_ADJUST
};
/*Store ID of highest ranked lit LED.*/
/*eg:If highest ranked lit LED is LED1, LED_on_number is 0.*/
/*	 If it is LED2, LED_on_number is 1 and so on.*/
int8_t LED_on_number = -1;

/*Toggle the status between TEST_START and TEST_END.*/
/*If flag_test_start is 0, the status is TEST_END.*/
/*Otherwise, the status is TEST_START.*/
boolean flag_test_start;//the initial value is 0

/*If flag_all_on is 0,then turn on all LEDs.*/
/*Otherwise, turn off all LEDs.*/
/*Use only when the status is TEST_START.*/
boolean flag_all_on;

void setup()
{
#ifdef DEBUG//if debug message needed, start serial communication
	Serial.begin(9600);
#endif
	/*Initialization for the hardware*/
	init_pins();
	Timer1.initialize(500000); // set a timer of length 500000 microseconds 
	Timer1.attachInterrupt( timer1Isr ); // attach the interrupt service routine to the timer1
}
void loop()
{
	int16_t key_pressed = scanKey();//poll status of all keys
	if(key_pressed == KEY_MENU)
	{
	/*Every time the menu key pressed, it toggle status between TEST_START and TEST_END	*/
		flag_test_start = ~flag_test_start;
		if(flag_test_start)status = TEST_START;
		else status = TEST_END;
	}
	else if(key_pressed == KEY_UP)
	{
	/*When it is TESTING, "UP" key can turn on one more LED from right to left*/
	/*every time the "UP" key pressed. */
		if(status == TEST_START)status = TESTING;
		if(status == TESTING)turnOnMoreLED();
	}
	else if(key_pressed == KEY_DOWN)
	{
	/*When it is TESTING, "DOWN" key can turn off one more LED from left to right*/
	/*every time the "DOWN" key pressed. */
		if(status == TEST_START)status = TESTING;
		if(status == TESTING)turnOffMoreLED();
	}
	/*if a key has been pressed, wait for extra 200ms*/
	if(key_pressed > 0)delay(200);
}
/*Initialization for the hardware,and should be called first*/
void init_pins()
{
	/*set keys to be inputs and define the initial status as HIGH*/
	pinMode(KEY_MENU, INPUT);
	digitalWrite(KEY_MENU, HIGH);
	pinMode(KEY_UP, INPUT);
	digitalWrite(KEY_UP, HIGH);
	pinMode(KEY_DOWN, INPUT);
	digitalWrite(KEY_DOWN, HIGH);
	/*define the pin mode of LEDs*/
	pinMode(LED_CLOCK_ADJUST, OUTPUT);
	pinMode(LED_ALARM_ADJUST, OUTPUT);
	pinMode(LED_BRIGHTNESS_ADJUST, OUTPUT);
	pinMode(LED_ALARM_ENABLE, OUTPUT);
	turnOffAll();//Turn off all the LEDs first.
}
/*Turn on one LED*/
inline void turnOn(int pinLED)
{
	digitalWrite(pinLED, HIGH);
}
/*Turn Off one LED*/
inline void turnOff(int pinLED)
{
	digitalWrite(pinLED, LOW);
}
/*Turn on all the LEDs*/
inline void turnOnAll()
{
	turnOn(LED_CLOCK_ADJUST);
	turnOn(LED_ALARM_ADJUST);
	turnOn(LED_BRIGHTNESS_ADJUST);
	turnOn(LED_ALARM_ENABLE);
}
/*Turn off all the LEDs*/
inline void turnOffAll()
{
	turnOff(LED_CLOCK_ADJUST);
	turnOff(LED_ALARM_ADJUST);
	turnOff(LED_BRIGHTNESS_ADJUST);
	turnOff(LED_ALARM_ENABLE);
}

/*Turn on one more LED*/
void turnOnMoreLED()
{
	if(LED_on_number < 3) //when not all LEDs are on
	{
		LED_on_number ++;
		turnOn(LEDS_PIN[LED_on_number]);
		for(byte i = LED_on_number + 1;i < 4;i ++)
			turnOff(LEDS_PIN[i]);//make sure the higher ranked LEDs are off
	}
}

/*Turn off one more LED*/
void turnOffMoreLED()
{
	if((LED_on_number > 0) || (LED_on_number == 0))//when not all LEDs are off
	{
		turnOff(LEDS_PIN[LED_on_number]);
		LED_on_number --;
	}
}

/*Scan keys and get to know which one is pressed*/
int16_t scanKey()
{
	int16_t pin_number = -1;//define non-existent pin number
	if(digitalRead(KEY_MENU) == LOW)
	{
		delay(20);
		if(digitalRead(KEY_MENU) == LOW)
		{
			pin_number = KEY_MENU;
		}
	#ifdef DEBUG //print out the message on serial monitor
		Serial.println("KEY_MENU is pressed");
	#endif
		
	}
	else if(digitalRead(KEY_UP) == LOW)
	{
		delay(20);
		if(digitalRead(KEY_UP) == LOW)
		{
			pin_number = KEY_UP;
		}
	#ifdef DEBUG
		Serial.println("KEY_UP is pressed");
	#endif
	}
	else if(digitalRead(KEY_DOWN) == LOW)
	{
		delay(20);
		if(digitalRead(KEY_DOWN) == LOW)
		{
			pin_number = KEY_DOWN;
		}
	#ifdef DEBUG
		Serial.println("KEY_DOWN is pressed");
	#endif
	}
	return pin_number;
}
/*Timer one interrupt service routine*/
void timer1Isr()
{
	if(status == TEST_START)
	{
	/*if it start, all the LEDs will blink once a second.*/
		flag_all_on = ~flag_all_on;
		if(flag_all_on)
		{
			LED_on_number = 3;//no more LED to turn on
			turnOnAll();
		}
		else 
		{
			LED_on_number = -1;//no more LED to turn off
			turnOffAll();
		}
	}
	else if(status == TEST_END) 
	{
		turnOffAll();
		LED_on_number = -1;
	}
}
        

#define DEBUG 1//comment out if you don't need debug information
//-------pin definition of keys---------------//
#define KEY_UP		10
#define KEY_DOWN	9
//-------pin definition of the buzzer--------//
#define ALARM_BUZZER 6

int tempo = 300;

/*play a tone, the larger the tone is, the lower the frequency becomes*/
void playTone(int tone, int duration) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(ALARM_BUZZER, HIGH);
    delayMicroseconds(tone);
    digitalWrite(ALARM_BUZZER, LOW);
    delayMicroseconds(tone);
  }
}

void setup() 
{
#ifdef DEBUG
		Serial.begin(9600);
#endif
 	init_pins();
}

void loop() 
{
	static int tone = 1000;
	int16_t key_pressed = scanKey();
	if(KEY_UP == key_pressed)
	{
	/*Every time the menu key pressed, it will raise the pitch of the */
	/*buzzer sound. */
		if(tone > 100)
		tone -= 100;
		playTone(tone,tempo);
	#ifdef DEBUG
		Serial.print("tone");
		Serial.println(tone);
	#endif
	}
	else if(KEY_DOWN == key_pressed)
	{
	/*Every time the menu key pressed, it will lower the pitch of the */
	/*buzzer sound. */
		if(tone < 2000)
		tone += 100;
		playTone(tone,tempo);
	#ifdef DEBUG//output debug message
		Serial.print("tone");
		Serial.println(tone);
	#endif
	}
	/*if a key has been pressed, wait for extra 200ms*/
	if(key_pressed > 0)delay(200);
}
/*Initialization for the keys and the buzzer*/
void init_pins()
{
	/*K1 and K2 are set to be input pins*/
	pinMode(KEY_UP, INPUT);
	digitalWrite(KEY_UP, HIGH);
	pinMode(KEY_DOWN, INPUT);
	digitalWrite(KEY_DOWN, HIGH);
	/*The buzzer is set to be output pin*/
	pinMode(ALARM_BUZZER, OUTPUT);
	digitalWrite(ALARM_BUZZER, LOW);
	
}

/*Scan keys and get to know which one is pressed*/
/*Return: if no key is pressed, return -1.*/
int16_t scanKey()
{
	int16_t pin_number = -1;//define non-existent pin number
	if(digitalRead(KEY_UP) == LOW)
	{
		delay(20);
		if(digitalRead(KEY_UP) == LOW)//validate a press that outlasts 20ms
		{
			pin_number = KEY_UP;
		}
	#ifdef DEBUG
		Serial.println("KEY_UP is pressed");
	#endif
	}
	else if(digitalRead(KEY_DOWN) == LOW)
	{
		delay(20);
		if(digitalRead(KEY_DOWN) == LOW)
		{
			pin_number = KEY_DOWN;
		}
	#ifdef DEBUG
		Serial.println("KEY_DOWN is pressed");
	#endif
	}
	return pin_number;
}

        

#include "TM1636.h"

//--Declare a TM1636 Class object that control the 4-digit display--//
TM1636 tm1636(7,8);
//-Declare the resistance of the resistor that connects with the temperature sensor-//
#define RESISTOR_CONNECT_THERMISTOR	10000//the resistance is 8k ohm
//-------pin definition of temperature sensor-------------//
#define TEMPERATURE_SENSOR	A0

void setup()
{
	init_pins();
	/*Set the default brightness is BRIGHT_TYPICAL and clear the display*/
	tm1636.init();
}
void loop()
{
	int8_t temperature;
	/*Read the ambient temperature and display on the digital tube.*/
	temperature = getTemperature();
	displayTemperature(temperature);
	delay(500);
}
/*Initialization for the hardware.*/
void init_pins()
{
	/*set the temperature sensor that connects with A0 to be input*/
	pinMode(TEMPERATURE_SENSOR, INPUT);
}
/****************************************************************/
/*Return:int8_t,Temperature that range from -40 to 125 degrees.	*/
int8_t getTemperature()
{
	float temperature,resistance;
	int a;
	a = analogRead(TEMPERATURE_SENSOR);
	resistance   = (float)(1023-a)*RESISTOR_CONNECT_THERMISTOR/a; //Calculate the resistance of the thermistor
	int B = 3975;
	/*Calculate the temperature according to the following formula.*/
	temperature  = 1/(log(resistance/RESISTOR_CONNECT_THERMISTOR)/B+1/298.15)-273.15;
	return (int8_t)temperature;// the type convert from floating point to 8-bit integer
}
/*********************************************************************/
/*Function:Display 8-bit integer temperature on the 4-digit display. */
/*Parameter:-int8_t temperature,Temperature that range from -40 to 125 degrees. */
/*Return:	  void													*/
void displayTemperature(int8_t temperature)
{
	int8_t temp[4];
	if(temperature < 0)//if the temperature is below zero?
	{
	/*Yes, then the left-most bit will display "-".*/
		temp[0] = INDEX_NEGATIVE_SIGN;
		temperature = abs(temperature);
	}
	else if(temperature < 100)//if temperature >= 0 and temperature < 100?
	{
	/*Yes, then the left-most bit will display nothing.*/
		temp[0] = INDEX_BLANK;
	}
	else //if temperature > 100?
	{
	/*Yes, then the left-most bit will normally display.*/
		temp[0] = temperature/100;
	}
	temperature %= 100;
	temp[1] = temperature / 10;//index of second bit from left
	temp[2] = temperature % 10;//index of the third bit from left
	temp[3] = 12;	          //index of 'C' for celsius degree symbol.
	tm1636.display(temp);
}

/*The end of the "MeasureTemperature.ino"*/
        

/*Definition of the LED and the light sensor*/
#define LED2	3
#define LED4	5
#define LIGHT_SENSOR	A1

void setup()
{
	Serial.begin(9600);
	init_pins();
}
void loop()
{
	/*The brighter the ambient light intensity, the darker the LED*/
	uint8_t light_level,duty_cycle;
	light_level = getLightLevel();//should be 0~7
	duty_cycle = light_level*30;  //the duty_cycle of the PWM should be 0~210
	
	/*The LED that is controled by PWM pin should be LED2 or LED4.*/
	/*The greater the duty_cycle,the brighter the LED.*/
	analogWrite(LED2,duty_cycle);
	delay(500);
}
/*Initialization for the hardware.*/
void init_pins()
{
	/*Set LED2 and LED4 to be output.*/
	/*The initialization of the output level is LOW.*/
	pinMode(LED2, OUTPUT);
	digitalWrite(LED2, LOW);
	pinMode(LED4, OUTPUT);
	digitalWrite(LED4, LOW);
	/*set the light sensor that connects with A1 to be input*/
	pinMode(LIGHT_SENSOR, INPUT);
}
/****************************************************************/
/*Function:Get the ambient light level.							*/
/*Parameter:void												*/
/*Return:	uint8_t,range from 0 to 7,0 = brightest,7 = darkest */
uint8_t getLightLevel()
{
	uint16_t resistance;
	uint8_t light_level;
	resistance = (uint16_t)getLightIntensity();
	Serial.print("resistance = ");
	Serial.println(resistance);
	if(resistance < 10) light_level = 0;
	else if(resistance < 50)light_level = 1;
	else if(resistance < 80)light_level = 2;
	else if(resistance < 110)light_level = 3;
	else if(resistance < 140)light_level = 4;
	else if(resistance < 170)light_level = 5;
	else if(resistance < 200)light_level = 6;
	else light_level = 7;
	return light_level;
}
/*********************************************************************/
/*Function:Get the resistance of the light sensor					 */
/*Parameter:void													 */
/*Return:	float,the resistance of the light sensor,its unit is kohm */
/*			The brighter the ambient light intensity,the smaller the */
/*			resistance.												 */
float getLightIntensity()
{
	int sensorValue = analogRead(LIGHT_SENSOR);
	float rsensor;
	rsensor=(float)(1023-sensorValue)*10/sensorValue;
	return rsensor;
}

/*The end of the file "SensorControlBrightness.ino"*/
        

#include "TM1636.h"
//--Declare a TM1636 Class object that control the 4-digit display--//
TM1636 tm1636(7,8);

void setup()
{
	/*Set the default brightness is BRIGHT_TYPICAL and clear the display*/
	tm1636.init();
}
void loop()
{
	int8_t NumTab[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};//index of 0~9,A,b,C,d,E,F
	int8_t table_length;
	table_length = sizeof(NumTab);//get the length of the number table: NumTab
	int8_t disp[4];//store the index of the 4 digit to display. 
	unsigned char digit_index = 0;
	unsigned char starting_index = 0;//starting index of NumTab
	while(1)
	{
		digit_index = starting_index;
		starting_index ++;
		if(starting_index == table_length) 
		{
			starting_index = 0;//start again
		}
		for(unsigned char BitSelect = 0;BitSelect < 4;BitSelect ++)
		{
		  disp[BitSelect] = NumTab[digit_index];
		  digit_index ++;
		  if(digit_index == table_length) digit_index = 0;
		}
		tm1636.display(disp);//display on the 4-digit display.
		delay(300);//display 4-digit number for 300ms and then it will change.
	}
}


/*The end of the file "CharacterFlow.ino"*/
        

#include "Wire.h"
#include <TimerOne.h>
#include <MsTimer2.h>
#include <EEPROM.h>
#include "TM1636.h"
#include "TickTockShield.h"

#define ON 1
#define OFF 0

//definitions of global variables
boolean flag_update;//1 = update the time on the 4-digit display
unsigned char halfsecond;//each time the timer2 interrupts,halfsecond plus one.
boolean flag_clockpoint = 1;//change between 0 and 1 every 500ms. If it is 1,
						//the clockpoint is on.Else the clockpoint is off.
boolean flag_2s;//2 seconds flag.1 = to the end of 2 seconds so as to set 
				//flag_display_time
boolean flag_10s;//10 seconds flag.1 = to the end of 10 seconds so as to 
				//display temperature
boolean flag_display_time = 1;//1 = can display time that get from the RTC
uint8_t counter_times = 20;//20*halfsecond = 10seconds.
					//If it is 20,to count for 10s,so display time for 10s.
					//If it is 4,to count for 2s,so display the temperture for 2s
boolean flag_500ms_blink;//when adjusting the time or the alarm,the hour or minute
						//displayed on the 4-digit display will blink every 500ms.
boolean flag_scan_again;//1 = can scan key again at the state of SYSTEM_NORAML
						//To avoid the mistake of entering the state of SYSTEM_ADJUSTING 
						//again when pressing MENU for 3s to confirm the setting.
uint8_t counter_500ms;//when counter_500 reach 6,flag_scan_again is set 1.

/*status definitions for the tick shield control system*/
uint8_t system_states;
	#define SYSTEM_NORAML    0 //default status,and the system will turn to "normal" status 
	#define SYSTEM_ADJUSTING 1 //triggered when key MENU is pressed at the "normal" status.
	#define SYSTEM_ALARMING  2

//--Declare a TickTockShield Class object--//
TickTockShield ticktockshield;

extern int8_t disp[4];//external global array defined in TickTockShield.cpp

extern byte g_hand;//external global variable.
					//the clock hand, HOUR shows that it is adjusting the hour, 
				   	//MINUTE shows that it is adjusting the minute.

void setup() 
{
#ifdef DEBUG
	Serial.begin(9600);
#endif
	ticktockshield.init();

	/*Run the 4 LEDs from left to right*/
	ticktockshield.runLED();
	if(isFirstLoad())//if it is the first time to load the firmware?
	{
		ticktockshield.setAlarm(12,0);//Yes,the alarm clock is initialized to 12:00
									//and the data in the EEPROM.
	}
	else ticktockshield.getAlarm();//No,read the alarm clock stored in EEPROM
	/*When system starts, adjust the brightness of the digital tube 
			according to the ambient light intensity.*/
	uint8_t lightlevel; 
	lightlevel = ticktockshield.getLightLevel();
	ticktockshield.adjustBrightness(lightlevel);
	/*Read the ambient temperature and display on the digital tube.*/
	ticktockshield.displayTemperature(ticktockshield.getTemperature());
	delay(1000);
	MsTimer2::set(500, Timer2ISR);//Timer2 generates an interrupt every 500ms
	MsTimer2::start();//Timer2 starts counting
}
void loop() 
{
  clockStart();
}
/****************************************************************/
/*Function:Implement the function of a clock with an alarm clock, and */
/*			the buttons can adjust the clock.*/
void clockStart()
{
  if(system_states == SYSTEM_NORAML)//if it is normal states?
  {
  /*Yes, the clock will update every 500ms,and check whether the Menu is pressed */
  /*to enter SYSTEM_ADJUSTING state and check if it should be enter SYSTEM_ALARMING state.*/
    if(flag_update)//if update flag is not zero?
    { 
      flag_update = 0;
      if(flag_clockpoint)
      {
        tm1636.point(POINT_ON);
      }
      else tm1636.point(POINT_OFF); 
      ticktockshield.getTime();
      if(ticktockshield.isAlarmEnable())
      {
        tm1636.point(POINT_ON);
        ticktockshield.displayTime();
        system_states = SYSTEM_ALARMING;
        return;
      }
      if(flag_display_time)ticktockshield.displayTime();

      if(flag_2s)
      {
        flag_2s = 0;
        flag_display_time = 1;

        counter_times = 20;
        halfsecond = 0;
      }
      if(flag_10s)
      {
        flag_10s = 0;
        flag_display_time = 0;
        tm1636.point(POINT_OFF);
        ticktockshield.displayTemperature(ticktockshield.getTemperature());
        counter_times = 4;
        halfsecond = 0;
      }
      if((flag_scan_again)&&(KEY_MENU == ticktockshield.scanKey()))
      {
        ticktockshield.writeToAdjustArea();
        ticktockshield.processKey();
        system_states = SYSTEM_ADJUSTING;
      }

    }
  }
  else if(system_states == SYSTEM_ADJUSTING)
  {
    ticktockshield.scanKey();
    ticktockshield.processKey();
    ticktockshield.processSystemStatus();
    if(ticktockshield.getQuitReq())
    {
      system_states = SYSTEM_NORAML;
      counter_500ms = 0;
      flag_scan_again = 0;
    }
    else flag_scan_again = 1;
  }
  else if(system_states == SYSTEM_ALARMING)
  {
    /*It will sound alarm for a minute untill the "MENU" key is pressed*/
    if(ticktockshield.isAlarmEnable())
    {
      ticktockshield.alarming();
    }
    else 
    {
      ticktockshield.turnOffAlarm();
      system_states = SYSTEM_NORAML;
    }
    if(KEY_MENU == ticktockshield.scanKey())
    {
      ticktockshield.turnOffAlarm();
      system_states = SYSTEM_NORAML;
    }
  }
}

//--------------------------------------
boolean isFirstLoad()
{
  unsigned char mark[] = "ALARM";
  unsigned char temp_data[5];
  for(unsigned char i = 0;i < 5;i ++)
  {
    temp_data[i] = EEPROM.read(i);
    if(temp_data[i] != mark[i])
    {
      EEPROM.write(0,mark[0]);
      EEPROM.write(1,mark[1]);
      EEPROM.write(2,mark[2]);
      EEPROM.write(3,mark[3]);
      EEPROM.write(4,mark[4]);
      return true;
    }
  }
  return false;
}

/*Function:It is timer 2 interrupt service routine.Timer2 generates an interrupt*/ 
/*  every 500ms.And every time it interrupts,this function will be executed.*/		
void Timer2ISR()
{
  halfsecond ++;
  if(halfsecond  == counter_times)
  {
    halfsecond  = 0;
    if(counter_times == 4)flag_2s = 1;
    else if(counter_times == 20)flag_10s = 1;
  }
  flag_update = 1;
  flag_clockpoint = (~flag_clockpoint) & 0x01;//change between 0 and 1 every 500ms.
  flag_500ms_blink = ~flag_500ms_blink;
  if(ticktockshield.isAdjustingTime())
  {
    if(g_hand == HOUR)
    {
      if(flag_500ms_blink)
      {
        disp[0] = INDEX_BLANK;
        disp[1] = INDEX_BLANK;
      }
    }
    else
    {
      if(flag_500ms_blink)
      {
        disp[2] = INDEX_BLANK;
        disp[3] = INDEX_BLANK;
      }
    }
    tm1636.display(disp);
  }
  counter_500ms ++;
  if(counter_500ms == 6)
  {
    counter_500ms = 0;
    flag_scan_again = 1;
  }

}
        

TTSTime time;                                       // TTS: Tick Tock Shield

time.setTime(int hour, int min, int sec);           // set time
time.getTime(int *hour, int *min, int *sec);
time.getHour();                                     // return hour
time.getMinute();                                   // return minutes
time.getSecond();                                   // return seconds
                

TTSBuzzer buzzer;

buzzer.on();                                        // on
buzzer.off();                                       // off
buzzer.state();                                     // return state of buzzer, HIGH:on, LOW:off
                

TTSLight light;

light.get();                                        // return light sensor data, 0-1023
                

TTSTemperature temp;

temp get();                                         // return temperature value, int
                

TTSButton button(Pin);                              // TTSK1, TTSK2, TTSK3

button.get();                                       // return button state, HIGH or LOW
button.pressed();                                   // return HIGH when button is pressed
button.released();                                  // return HIGH when button is released
                

TTSDisplay disp();

disp.display(int loca, int num);                    // control a  nixie tube 
disp.num(int num);                                  // display a number  
disp.time(int hour, int min);                       // display time
disp.clear();                                       // clear display
disp.pointOn();                                     // display :
disp.pointOff();                                    // clear :
                

TTSLed led(Pin);                                    // TTSLED1, TTSLED2, TTSLED3, TTSLED4

led.on();                                           // led on
led.off();                                          // led off
led.state();                                        // return led state
                

temp_data[i] = EEPROM.read(i);
                

if(temp_data[i] != mark[i])
    {
      EEPROM.write(0,mark[0]);
      EEPROM.write(1,mark[1]);
      EEPROM.write(2,mark[2]);
      EEPROM.write(3,mark[3]);
      EEPROM.write(4,mark[4]);
      return true;
    }
                

if(flag_clockpoint)
      {
        tm1636.point(POINT_ON);
      }
      else tm1636.point(POINT_OFF); 
                

tm1636.display(disp);
                

/*Run the 4 LEDs from left to right*/
ticktockshield.runLED(1,LEFT_TO_RIGHT);
                

void TickTockShield::turnOffLED()
{
	setLed(LOW,LED_CLOCK_ADJUST);
	setLed(LOW,LED_ALARM_ADJUST);
	setLed(LOW,LED_BRIGHT_ADJUST);
	setLed(LOW,LED_ALARM_ENABLE);
}
                

/*It will sound alarm for a minute untill the "MENU" key is pressed*/
    if(ticktockshield.isAlarmEnable())
    {
      ticktockshield.alarming();
    }
                

ticktockshield.setAlarm(12,0);//Yes,the alarm clock is initialized to 12:00 and the data in the EEPROM.
                

if(isFirstLoad())//if it is the first time to load the firmware?
	{
		ticktockshield.setAlarm(12,0);
 	}
	else ticktockshield.getAlarm();//No,read the alarm clock stored in EEPROM
                

/*Read the ambient temperature and display on the digital tube.*/
	ticktockshield.displayTemperature(ticktockshield.getTemperature());
                

ticktockshield.displayTemperature(ticktockshield.getTemperature());
                

if((flag_scan_again)&&(KEY_MENU == ticktockshield.scanKey()))
      {
        ticktockshield.writeToAdjustArea();
        ticktockshield.processKey();
        system_states = SYSTEM_ADJUSTING;
      }
                

 if(ticktockshield.isAlarmEnable())
      {
        tm1636.point(POINT_ON);
        ticktockshield.displayTime();
        system_states = SYSTEM_ALARMING;
        return;
      }