inline void hexbright::adjust_leds() {
// turn off led if it's expired
#if (DEBUG==DEBUG_LED)
if(led_on_time[GLED]>=0) {
Serial.print("green on countdown: ");
Serial.println(led_on_time[GLED]*update_delay);
} else if (led_on_time[GLED]<0 && led_wait_time[GLED]>=0) {
Serial.print("green wait countdown: ");
Serial.println((led_wait_time[GLED])*update_delay);
}
if(led_on_time[RLED]>=0) {
Serial.print("red on countdown: ");
Serial.println(led_on_time[RLED]*update_delay);
} else if (led_on_time[RLED]<0 && led_wait_time[RLED]>=0) {
Serial.print("red wait countdown: ");
Serial.println((led_wait_time[RLED])*update_delay);
}
#endif
int i=0;
for(i=0; i<2; i++) {
if(led_on_time[i]>0) {
_led_on(i);
led_on_time[i]--;
} else if(led_on_time[i]==0) {
_led_off(i);
led_on_time[i]--;
} else if (led_wait_time[i]>=0) {
led_wait_time[i]--;
}
}
}
void led_set(led_t mode) {
switch(mode) {
case IDLE:
if (has_error) {
init_prg(0);
} else {
_leds_off();
}
break;
case OFF:
has_error = 0;
_leds_off();
break;
case ACTIVE:
if(!has_error) _active_led_on();
break;
case ON:
_led_on();
break;
case PANIC:
init_prg(PANIC_OFFSET);
break;
case ERROR:
has_error = 1;
_leds_off();
default:
init_prg(0);
break;
}
}
void _led_set(unsigned char led,unsigned char val)
{
if(val==1)
_led_on(led);
else
_led_off(led);
}
static inline void _active_led_on() {
# ifdef ACTIVE_LED_DDR
device_active_led_on();
# else
_led_on();
# endif
}
/******************************************************************************
Led manager callback
*******************************************************************************
Must be called at regular intervals. Typicalls from an interrupt vector at about 10Hz.
******************************************************************************/
void led_callback_10hz(void)
{
// Process the 2 leds
for(unsigned char l=0; l<2; l++)
{
switch(_led_mode[l])
{
// Case 0: LED in static mode.
case 0:
break;
// Case 1: LED in blink sequence mode
case 1:
//printf_P(PSTR("LED %d\r"),l);
//printf_P(PSTR("B dotrans %d istate %d ctr %d rctr %d inf %d\r"),_led_istatedotrans[l],_led_istate[l],_led_istate_ctr[l],_led_istate_rctr[l],_led_inf[l]);
// Transient code (entering a state)
if(_led_istatedotrans[l])
{
_led_istatedotrans[l]=0;
switch(_led_istate[l])
{
// Reset transition
case 0:
_led_istate[l]=1; // First state after reset
// Reset initialization
_led_istate_rctr[l]=0;
// No break on purpose to ensure initialization, and entering in the first state upon power up.
// Transition to LED on
case 1:
_led_on(l);
_led_istate_ctr[l]=0;
break;
// Transition to LED off
case 2:
_led_off(l);
_led_istate_ctr[l]=0;
break;
// Transition to wait
case 3:
_led_istate_ctr[l]=0;
_led_istate_rctr[l]=0;
break;
// Transition to end of sequence repetition
case 4:
_led_idone[l]=1;
}
}
// State code (in a state)
switch(_led_istate[l])
{
// State LED on
case 1:
INCREMENT_WRAP(_led_istate_ctr[l],_led_ton[l]);
if(!_led_istate_ctr[l]) // Time elapsed
{
_led_istate[l]=2;
_led_istatedotrans[l]=1;
}
break;
// State LED off
case 2:
INCREMENT_WRAP(_led_istate_ctr[l],_led_toff[l]);
if(!_led_istate_ctr[l]) // Time elapsed
{
// Go to wait, or repeat?
INCREMENT_WRAP(_led_istate_rctr[l],_led_rep[l]);
// We blink on again if: the sequence is not complete, or the sequence is complete but we should not wait at the end of the sequence, and we want infinite blinks
if(_led_istate_rctr[l] || (_led_w[l]==0 && _led_inf[l]==1))
{
_led_istate[l]=1;
_led_istatedotrans[l]=1;
}
else
{
if(_led_inf[l]==0 && _led_w[l]==0) // no need to wait and no infinite loop -> end
{
_led_istate[l]=4;
_led_istatedotrans[l]=1;
}
else // need to wait, state 3: wait
{
_led_istate[l]=3;
_led_istatedotrans[l]=1;
}
}
}
break;
// State wait
case 3:
INCREMENT_WRAP(_led_istate_ctr[l],_led_w[l]);
if(!_led_istate_ctr[l]) // Time elapsed
{
// wait is done
if(_led_inf[l]==1) // infinite blinks: state1
{
_led_istate[l]=1;
_led_istatedotrans[l]=1;
}
else
{
_led_istate[l]=4;
_led_istatedotrans[l]=1;
}
}
break;
}
//printf_P(PSTR("B t%d s%d c%d r %d\r\r"),_led_istate0dotrans,_led_istate0,_led_istate0_ctr,_led_istate0_rctr);
break;
}
}
}
