Browse Source

Move LED fading to own file

master
Olaf Rempel 3 months ago
parent
commit
b9c11c6860
  1. 30
      event.c
  2. 18
      event.h
  3. 199
      ledfade.c
  4. 25
      ledfade.h
  5. 62
      main.c
  6. 214
      pwm.c
  7. 19
      pwm.h
  8. 32
      timer.c
  9. 13
      timer.h

30
event.c

@ -1,5 +1,5 @@
/***************************************************************************
* Copyright (C) 01/2019 by Olaf Rempel *
* Copyright (C) 02/2021 by Olaf Rempel *
* razzor@kopf-tisch.de *
* *
* This program is free software; you can redistribute it and/or modify *
@ -23,9 +23,9 @@
/* *********************************************************************** */
static event_entry_t events[EVENT_COUNT];
static volatile uint8_t event_in_idx;
static volatile uint8_t event_out_idx;
static event_entry_t m_events[EVENT_COUNT];
static volatile uint8_t m_event_in_idx;
static volatile uint8_t m_event_out_idx;
/* *********************************************************************** */
@ -38,14 +38,14 @@ void event_queue(uint8_t type, uint8_t num, uint16_t value)
sreg_save = SREG;
cli();
idx = event_in_idx;
p_event = &events[idx++];
idx = m_event_in_idx;
p_event = &m_events[idx];
if (p_event->type == EVENT_TYPE_EMPTY)
{
p_event->type = type;
p_event->num = num;
p_event->value = value;
event_in_idx = idx % EVENT_COUNT;
m_event_in_idx = (idx +1) % EVENT_COUNT;
}
SREG = sreg_save;
@ -54,13 +54,19 @@ void event_queue(uint8_t type, uint8_t num, uint16_t value)
event_entry_t * event_get(void)
{
return &events[event_out_idx];
return &m_events[m_event_out_idx];
} /* event_get */
void event_clear(void)
void event_clear(event_entry_t * p_event)
{
uint8_t idx = event_out_idx;
events[idx++].type = EVENT_TYPE_EMPTY;
event_out_idx = idx % EVENT_COUNT;
uint8_t idx = m_event_out_idx;
if ((p_event == &m_events[idx]) &&
(p_event->type != EVENT_TYPE_EMPTY)
)
{
p_event->type = EVENT_TYPE_EMPTY;
m_event_out_idx = (idx +1) % EVENT_COUNT;
}
} /* event_clear */

18
event.h

@ -1,13 +1,19 @@
#ifndef __EVENT_H__
#define __EVENT_H__
#ifndef EVENT_H_SEEN
#define EVENT_H_SEEN
#include <stdint.h>
/* *********************************************************************** */
#define EVENT_COUNT 16
#define EVENT_COUNT 16
#define EVENT_TYPE_EMPTY 0x00
#define EVENT_TYPE_EMPTY 0x00
#define EVENT_TYPE_TIMER_SET 0x01
#define EVENT_TYPE_TIMER_ELAPSED 0x02
#define EVENT_TYPE_PWM_VALUE 0x03
#define EVENT_TYPE_LEDFADE_COMMAND 0x04
#define EVENT_TYPE_LEDFADE_VALUE 0x05
#define EVENT_TYPE_LEDFADE_STATUS 0x06
typedef struct event_entry_s
{
@ -20,8 +26,8 @@ typedef struct event_entry_s
void event_queue (uint8_t type, uint8_t num, uint16_t value);
event_entry_t * event_get (void);
void event_clear (void);
void event_clear (event_entry_t * p_event);
/* *********************************************************************** */
#endif /* __EVENT_H__ */
#endif /* EVENT_H_SEEN */

199
ledfade.c

@ -0,0 +1,199 @@
/***************************************************************************
* Copyright (C) 02/2021 by Olaf Rempel *
* razzor@kopf-tisch.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; version 2 of the License, *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <avr/pgmspace.h>
#include "event.h"
#include "ledfade.h"
#include "timer.h"
/* *********************************************************************** */
#define LEDFADE_CHANNEL_COUNT 2
#define LEDFADE_FULL_FADE_MS 1000
#define LEDFADE_16BIT 1
#if (LEDFADE_16BIT)
#define LEDFADE_TABLE_SIZE 128
#define LEDFADE_TABLE_GET(x) pgm_read_word(&m_ledfade_table16[x])
const uint16_t m_ledfade_table16[LEDFADE_TABLE_SIZE] PROGMEM =
{
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5,
6, 6, 7, 8, 9, 9, 10, 11, 12, 14, 15, 16, 18, 20, 22, 24, 26,
28, 31, 34, 37, 40, 44, 48, 53, 58, 63, 69, 75, 82, 90, 98,
107, 116, 127, 139, 151, 165, 180, 196, 214, 234, 255, 278,
303, 331, 361, 394, 430, 469, 511, 557, 608, 663, 723, 789,
860, 938, 1023, 1116, 1217, 1327, 1447, 1578, 1721, 1877,
2047, 2232, 2434, 2655, 2895, 3157, 3443, 3755, 4095, 4466,
4870, 5311, 5792, 6316, 6888, 7511, 8191, 8932, 9741, 10623,
11584, 12633, 13776, 15023, 16383, 17866, 19483, 21246, 23169,
25267, 27553, 30047, 32767, 35733, 38967, 42494, 46340, 50534,
55108, 60096, 65535
};
#else
#define LEDFADE_TABLE_SIZE 32
#define LEDFADE_TABLE_GET(x) pgm_read_byte(&m_ledfade_table8[x])
const uint8_t m_ledfade_table8[LEDFADE_TABLE_SIZE] PROGMEM =
{
0, 0, 1, 1, 1, 2, 2, 3,
4, 5, 6, 7, 9, 10, 12, 15,
18, 22, 26, 31, 37, 44, 53, 63,
75, 90, 107, 127, 151, 180, 214, 255
};
#endif
#define LEDFADE_FADE_STEP_MS ((LEDFADE_FULL_FADE_MS + LEDFADE_TABLE_SIZE) / LEDFADE_TABLE_SIZE)
static uint8_t m_ledfade_value[LEDFADE_CHANNEL_COUNT];
static uint8_t m_ledfade_setpoint[LEDFADE_CHANNEL_COUNT];
static uint8_t m_ledfade_setpoint_save[LEDFADE_CHANNEL_COUNT];
static uint8_t m_ledfade_timer_running;
/* *********************************************************************** */
static void ledfade_update(uint8_t channel)
{
uint8_t update_pwm = 0;
if (m_ledfade_setpoint[channel] >= LEDFADE_TABLE_SIZE)
{
m_ledfade_setpoint[channel] = (LEDFADE_TABLE_SIZE -1);
}
if ((m_ledfade_setpoint[channel] > m_ledfade_value[channel]) &&
(m_ledfade_value[channel] < (LEDFADE_TABLE_SIZE -1))
)
{
m_ledfade_value[channel]++;
update_pwm = 1;
}
else if ((m_ledfade_setpoint[channel] < m_ledfade_value[channel]) &&
(m_ledfade_value[channel] > 0)
)
{
m_ledfade_value[channel]--;
update_pwm = 1;
}
if (update_pwm)
{
event_queue(EVENT_TYPE_PWM_VALUE,
channel,
LEDFADE_TABLE_GET(m_ledfade_value[channel]));
if (m_ledfade_value[channel] == m_ledfade_setpoint[channel])
{
event_queue(EVENT_TYPE_LEDFADE_STATUS,
channel,
m_ledfade_value[channel]);
}
else if (!m_ledfade_timer_running)
{
event_queue(EVENT_TYPE_TIMER_SET,
EVENT_NUM_TIMER_LEDFADE,
LEDFADE_FADE_STEP_MS);
m_ledfade_timer_running = 1;
}
}
} /* ledfade_update */
void ledfade_event_handler(event_entry_t * p_event)
{
if (p_event->type == EVENT_TYPE_LEDFADE_COMMAND)
{
uint8_t channel = p_event->num;
switch (p_event->value)
{
case EVENT_VALUE_LEDFADE_KEEP:
m_ledfade_setpoint[channel] = m_ledfade_value[channel];
break;
/* increment */
case EVENT_VALUE_LEDFADE_INC:
if (m_ledfade_setpoint[channel] < (LEDFADE_TABLE_SIZE -1))
{
m_ledfade_setpoint[channel]++;
}
break;
/* decrement */
case EVENT_VALUE_LEDFADE_DEC:
if (m_ledfade_setpoint[channel] > 0)
{
m_ledfade_setpoint[channel]--;
}
break;
/* fade to min */
case EVENT_VALUE_LEDFADE_MIN:
m_ledfade_setpoint[channel] = 0;
break;
/* fade to max */
case EVENT_VALUE_LEDFADE_MAX:
m_ledfade_setpoint[channel] = (LEDFADE_TABLE_SIZE -1);
break;
/* toggle between 0 and stored value */
case EVENT_VALUE_LEDFADE_TOGGLE:
if (m_ledfade_setpoint[channel] > 5)
{
m_ledfade_setpoint_save[channel] = m_ledfade_setpoint[channel];
m_ledfade_setpoint[channel] = 0;
}
else
{
m_ledfade_setpoint[channel] = m_ledfade_setpoint_save[channel];
}
break;
default:
break;
}
ledfade_update(channel);
}
else if (p_event->type == EVENT_TYPE_LEDFADE_VALUE)
{
uint8_t channel = p_event->num;
if (p_event->value < LEDFADE_TABLE_SIZE)
{
m_ledfade_setpoint[channel] = p_event->value;
}
else
{
m_ledfade_setpoint[channel] = (LEDFADE_TABLE_SIZE -1);
}
ledfade_update(channel);
}
else if ((p_event->type == EVENT_TYPE_TIMER_ELAPSED) &&
(p_event->num == EVENT_NUM_TIMER_LEDFADE)
)
{
m_ledfade_timer_running = 0;
ledfade_update(0);
ledfade_update(1);
}
} /* ledfade_event_handler */

25
ledfade.h

@ -0,0 +1,25 @@
#ifndef LEDFADE_H_SEEN
#define LEDFADE_H_SEEN
#include <stdint.h>
#include "event.h"
/* *********************************************************************** */
#define EVENT_NUM_LED_CH0 0x00
#define EVENT_NUM_LED_CH1 0x01
#define EVENT_VALUE_LEDFADE_KEEP 0x00
#define EVENT_VALUE_LEDFADE_INC 0x01
#define EVENT_VALUE_LEDFADE_DEC 0x02
#define EVENT_VALUE_LEDFADE_MIN 0x03
#define EVENT_VALUE_LEDFADE_MAX 0x04
#define EVENT_VALUE_LEDFADE_TOGGLE 0x05
/* *********************************************************************** */
void ledfade_event_handler (event_entry_t * p_event);
/* *********************************************************************** */
#endif /* LEDFADE_H_SEEN */

62
main.c

@ -6,6 +6,7 @@
#include "Descriptors.h"
#include "event.h"
#include "ledfade.h"
#include "pwm.h"
#include "timer.h"
@ -47,9 +48,9 @@ int main(void)
GlobalInterruptEnable();
event_queue(EVENT_TYPE_PWM_COMMAND, 0, EVENT_VALUE_PWM_FADE_MAX);
event_queue(EVENT_TYPE_PWM_COMMAND, 1, EVENT_VALUE_PWM_FADE_MAX);
event_queue(EVENT_TYPE_PWM_COMMAND, 2, EVENT_VALUE_PWM_FADE_MAX);
event_queue(EVENT_TYPE_LEDFADE_COMMAND, EVENT_NUM_LED_CH0, EVENT_VALUE_LEDFADE_MAX);
event_queue(EVENT_TYPE_LEDFADE_COMMAND, EVENT_NUM_LED_CH1, EVENT_VALUE_LEDFADE_MAX);
event_queue(EVENT_TYPE_PWM_VALUE, EVENT_NUM_PWM_CH2, 0x8000);
for (;;)
{
@ -59,35 +60,36 @@ int main(void)
timer_check(0);
event_entry_t* p_event = event_get();
if (p_event->type != EVENT_TYPE_EMPTY)
switch (p_event->type)
{
switch (p_event->type)
{
case EVENT_TYPE_PWM_COMMAND:
case EVENT_TYPE_PWM_VALUE:
pwm_event_handler(p_event);
break;
case EVENT_TYPE_PWM_STATUS:
break;
case EVENT_TYPE_TIMER_SET:
timer_event_handler(p_event);
break;
case EVENT_TYPE_TIMER_ELAPSED:
if (p_event->num == EVENT_NUM_TIMER_PWM)
{
pwm_event_handler(p_event);
}
break;
default:
break;
}
event_clear();
case EVENT_TYPE_TIMER_SET:
timer_event_handler(p_event);
break;
case EVENT_TYPE_TIMER_ELAPSED:
if (p_event->num == EVENT_NUM_TIMER_LEDFADE)
{
ledfade_event_handler(p_event);
}
break;
case EVENT_TYPE_PWM_VALUE:
pwm_event_handler(p_event);
break;
case EVENT_TYPE_LEDFADE_COMMAND:
case EVENT_TYPE_LEDFADE_VALUE:
ledfade_event_handler(p_event);
break;
case EVENT_TYPE_LEDFADE_STATUS:
break;
default:
break;
}
event_clear(p_event);
}
}

214
pwm.c

@ -1,5 +1,5 @@
/***************************************************************************
* Copyright (C) 01/2019 by Olaf Rempel *
* Copyright (C) 02/2021 by Olaf Rempel *
* razzor@kopf-tisch.de *
* *
* This program is free software; you can redistribute it and/or modify *
@ -17,34 +17,26 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
#include "pwm.h"
#include "timer.h"
/* *********************************************************************** */
#define PWM_TIM_16BIT 1
#define PWM_MIN 0x0000
#define PWM_MAX 0xFFFF
#define PWM_TIM_INIT() { \
/* enable output for OC1A, OC1B, OC3A */ \
DDRB |= (1<<PORTB5) | (1<<PORTB6); \
DDRC |= (1<<PORTC6); \
/* reset and hold prescaler */ \
GTCCR = (1<<TSM) | (1<<PSRSYNC); \
/* FastModePWM, ICRn is TOP */ \
TCCR1A = (1<<WGM11); \
TCCR1B = (1<<WGM13) | (1<<WGM12); \
ICR1 = 0xFFFF; \
TCNT1 = 0x0000; \
TCCR3A = (1<<WGM31); \
TCCR3B = (1<<WGM33) | (1<<WGM32); \
ICR3 = 0xFFFF; \
TCNT3 = 0x8000; \
/* release prescaler */ \
GTCCR = (1<<PSRSYNC); \
}
#define PWM_TIM1_ENABLE() { TCCR1B |= (1<<CS10); }
@ -57,107 +49,30 @@
#define PWM_TIM3_RUNNING() (TCCR3B & ((1<<CS30) | (1<<CS31) | (1<<CS32)))
#define PWM_TIM3_CHECK() (TCCR3A & ((1<<COM3A1) | (1<<COM3B1)))
#define PWM_TIMER_FADE_STEP_MS 10
#define PWM_CH0_PORT PORTB
#define PWM_CH0_NUM 5
#define PWM_CH0_OFF() { PWM_CH0_PORT &= ~(1<<PWM_CH0_NUM); TCCR1A &= ~(1<<COM1A1); }
#define PWM_CH0_ON() { PWM_CH0_PORT |= (1<<PWM_CH0_NUM); TCCR1A &= ~(1<<COM1A1); }
#define PWM_CH0_PWM(x) { PWM_CH0_PORT &= ~(1<<PWM_CH0_NUM); TCCR1A |= (1<<COM1A1); OCR1A = x; }
#define PWM_CH1_PORT PORTB
#define PWM_CH1_PORT PORTC
#define PWM_CH1_NUM 6
#define PWM_CH1_OFF() { PWM_CH1_PORT &= ~(1<<PWM_CH1_NUM); TCCR1A &= ~(1<<COM1B1); }
#define PWM_CH1_ON() { PWM_CH1_PORT |= (1<<PWM_CH1_NUM); TCCR1A &= ~(1<<COM1B1); }
#define PWM_CH1_PWM(x) { PWM_CH1_PORT &= ~(1<<PWM_CH1_NUM); TCCR1A |= (1<<COM1B1); OCR1B = x; }
#define PWM_CH1_OFF() { PWM_CH1_PORT &= ~(1<<PWM_CH1_NUM); TCCR3A &= ~(1<<COM3A1); }
#define PWM_CH1_ON() { PWM_CH1_PORT |= (1<<PWM_CH1_NUM); TCCR3A &= ~(1<<COM3A1); }
#define PWM_CH1_PWM(x) { PWM_CH1_PORT &= ~(1<<PWM_CH1_NUM); TCCR3A |= (1<<COM3A1); OCR3A = x; }
#define PWM_CH2_PORT PORTC
#define PWM_CH2_PORT PORTB
#define PWM_CH2_NUM 6
#define PWM_CH2_OFF() { PWM_CH2_PORT &= ~(1<<PWM_CH2_NUM); TCCR3A &= ~(1<<COM3A1); }
#define PWM_CH2_ON() { PWM_CH2_PORT |= (1<<PWM_CH2_NUM); TCCR3A &= ~(1<<COM3A1); }
#define PWM_CH2_PWM(x) { PWM_CH2_PORT &= ~(1<<PWM_CH2_NUM); TCCR3A |= (1<<COM3A1); OCR3A = x; }
#if (PWM_TIM_16BIT)
#define PWM_TABLE_SIZE 128
#define PWM_TABLE_GET(x) pgm_read_word(&pwmtable16[x])
const uint16_t pwmtable16[PWM_TABLE_SIZE] PROGMEM =
{
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5,
6, 6, 7, 8, 9, 9, 10, 11, 12, 14, 15, 16, 18, 20, 22, 24, 26,
28, 31, 34, 37, 40, 44, 48, 53, 58, 63, 69, 75, 82, 90, 98,
107, 116, 127, 139, 151, 165, 180, 196, 214, 234, 255, 278,
303, 331, 361, 394, 430, 469, 511, 557, 608, 663, 723, 789,
860, 938, 1023, 1116, 1217, 1327, 1447, 1578, 1721, 1877,
2047, 2232, 2434, 2655, 2895, 3157, 3443, 3755, 4095, 4466,
4870, 5311, 5792, 6316, 6888, 7511, 8191, 8932, 9741, 10623,
11584, 12633, 13776, 15023, 16383, 17866, 19483, 21246, 23169,
25267, 27553, 30047, 32767, 35733, 38967, 42494, 46340, 50534,
55108, 60096, 65535
};
#else
#define PWM_TABLE_SIZE 32
#define PWM_TABLE_GET(x) pgm_read_byte(&pwmtable8[x])
const uint8_t pwmtable8[PWM_TABLE_SIZE] PROGMEM =
{
0, 0, 1, 1, 1, 2, 2, 3,
4, 5, 6, 7, 9, 10, 12, 15,
18, 22, 26, 31, 37, 44, 53, 63,
75, 90, 107, 127, 151, 180, 214, 255
};
#endif
static uint8_t pwm_index[3];
static uint8_t pwm_setpoint[3];
static uint8_t pwm_setpoint_save[3];
static uint8_t pwm_fade_timer_running;
#define PWM_CH2_OFF() { PWM_CH2_PORT &= ~(1<<PWM_CH2_NUM); TCCR1A &= ~(1<<COM1B1); }
#define PWM_CH2_ON() { PWM_CH2_PORT |= (1<<PWM_CH2_NUM); TCCR1A &= ~(1<<COM1B1); }
#define PWM_CH2_PWM(x) { PWM_CH2_PORT &= ~(1<<PWM_CH2_NUM); TCCR1A |= (1<<COM1B1); OCR1B = x; }
/* *********************************************************************** */
static void pwm_update(uint8_t channel)
static void pwm_update(uint8_t channel, uint16_t value)
{
uint8_t check_setpoint = 0;
if (pwm_setpoint[channel] >= PWM_TABLE_SIZE)
{
pwm_setpoint[channel] = (PWM_TABLE_SIZE - 1);
}
if ((pwm_setpoint[channel] > pwm_index[channel]) &&
(pwm_index[channel] < (PWM_TABLE_SIZE - 1))
)
{
pwm_index[channel]++;
check_setpoint = 1;
}
else if ((pwm_setpoint[channel] < pwm_index[channel]) &&
(pwm_index[channel] > 0)
)
{
pwm_index[channel]--;
check_setpoint = 1;
}
/* setpoint reached, notify others */
if (check_setpoint)
{
if (pwm_index[channel] == pwm_setpoint[channel])
{
event_queue(EVENT_TYPE_PWM_STATUS,
channel,
pwm_setpoint[channel]);
}
else if (!pwm_fade_timer_running)
{
event_queue(EVENT_TYPE_TIMER_SET,
EVENT_NUM_TIMER_PWM,
PWM_TIMER_FADE_STEP_MS);
pwm_fade_timer_running = 1;
}
}
/* if PWM is zero, disable output */
if (pwm_index[channel] == 0)
if (value == PWM_MIN)
{
switch (channel)
{
@ -178,7 +93,7 @@ static void pwm_update(uint8_t channel)
}
}
/* if PWM is max, enable output */
else if (pwm_index[channel] == (PWM_TABLE_SIZE - 1))
else if (value == PWM_MAX)
{
switch (channel)
{
@ -204,15 +119,15 @@ static void pwm_update(uint8_t channel)
switch (channel)
{
case 0:
PWM_CH0_PWM(PWM_TABLE_GET(pwm_index[0]));
PWM_CH0_PWM(value);
break;
case 1:
PWM_CH1_PWM(PWM_TABLE_GET(pwm_index[1]));
PWM_CH1_PWM(value);
break;
case 2:
PWM_CH2_PWM(PWM_TABLE_GET(pwm_index[2]));
PWM_CH2_PWM(value);
break;
default:
@ -223,7 +138,7 @@ static void pwm_update(uint8_t channel)
switch (channel)
{
case 0:
case 1:
case 2:
/* disable timer if all channels are ON or OFF */
if (PWM_TIM1_CHECK())
{
@ -235,7 +150,7 @@ static void pwm_update(uint8_t channel)
}
break;
case 2:
case 1:
/* disable timer if all channels are ON or OFF */
if (PWM_TIM3_CHECK())
{
@ -252,99 +167,16 @@ static void pwm_update(uint8_t channel)
void pwm_event_handler(event_entry_t * p_event)
{
if (p_event->type == EVENT_TYPE_PWM_COMMAND)
{
uint8_t channel = p_event->num;
switch (p_event->value)
{
case EVENT_VALUE_PWM_KEEP:
pwm_setpoint[channel] = pwm_index[channel];
break;
/* increment PWM */
case EVENT_VALUE_PWM_INC:
if (pwm_setpoint[channel] < (PWM_TABLE_SIZE - 1))
{
pwm_setpoint[channel]++;
}
break;
/* decrement PWM */
case EVENT_VALUE_PWM_DEC:
if (pwm_setpoint[channel] > 0)
{
pwm_setpoint[channel]--;
}
break;
/* fade to min */
case EVENT_VALUE_PWM_FADE_MIN:
pwm_setpoint[channel] = 0;
break;
/* fade to max */
case EVENT_VALUE_PWM_FADE_MAX:
pwm_setpoint[channel] = (PWM_TABLE_SIZE - 1);
break;
/* toggle between 0 and stored value */
case EVENT_VALUE_PWM_TOGGLE:
if (pwm_setpoint[channel] > 5)
{
pwm_setpoint_save[channel] = pwm_setpoint[channel];
pwm_setpoint[channel] = 0;
}
else
{
pwm_setpoint[channel] = pwm_setpoint_save[channel];
}
break;
default:
break;
}
pwm_update(channel);
}
else if (p_event->type == EVENT_TYPE_PWM_VALUE)
if (p_event->type == EVENT_TYPE_PWM_VALUE)
{
uint8_t channel = p_event->num;
if (p_event->value < PWM_TABLE_SIZE)
{
pwm_setpoint[channel] = p_event->value;
}
else
{
pwm_setpoint[channel] = (PWM_TABLE_SIZE - 1);
}
pwm_update(channel);
}
else if ((p_event->type == EVENT_TYPE_TIMER_ELAPSED) &&
(p_event->num == EVENT_NUM_TIMER_PWM)
)
{
pwm_fade_timer_running = 0;
pwm_update(0);
pwm_update(1);
pwm_update(2);
pwm_update(p_event->num, p_event->value);
}
} /* pwm_event_handler */
uint8_t pwm_get_sleep_mode(void)
{
if (PWM_TIM1_RUNNING() || PWM_TIM3_RUNNING())
{
return SLEEP_MODE_IDLE;
}
else
{
return SLEEP_MODE_PWR_DOWN;
}
return !!(PWM_TIM1_RUNNING() || PWM_TIM3_RUNNING());
} /* pwm_get_sleep_mode */

19
pwm.h

@ -1,32 +1,21 @@
#ifndef __PWM_H__
#define __PWM_H__
#ifndef PWM_H_SEEN
#define PWM_H_SEEN
#include <stdint.h>
#include "event.h"
/* *********************************************************************** */
#define EVENT_TYPE_PWM_COMMAND 0x04
#define EVENT_TYPE_PWM_VALUE 0x05
#define EVENT_TYPE_PWM_STATUS 0x06
#define EVENT_NUM_PWM_CH0 0x00
#define EVENT_NUM_PWM_CH1 0x01
#define EVENT_NUM_PWM_CH2 0x02
#define EVENT_VALUE_PWM_KEEP 0x00
#define EVENT_VALUE_PWM_INC 0x01
#define EVENT_VALUE_PWM_DEC 0x02
#define EVENT_VALUE_PWM_FADE_MIN 0x03
#define EVENT_VALUE_PWM_FADE_MAX 0x04
#define EVENT_VALUE_PWM_TOGGLE 0x05
/* *********************************************************************** */
void pwm_init (void);
void pwm_event_handler (event_entry_t * p_event);
uint8_t pwm_get_sleep_mode (void);
uint8_t pwm_need_hw_clock (void);
/* *********************************************************************** */
#endif /* __PWM_H__ */
#endif /* PWM_H_SEEN */

32
timer.c

@ -18,7 +18,6 @@
***************************************************************************/
#include <avr/interrupt.h>
#include <avr/io.h>
#include <avr/sleep.h>
#include "event.h"
#include "timer.h"
@ -43,8 +42,8 @@
#define TIMER_MSEC2TICKS(x) ((x * F_CPU) / (TIMER_DIVISOR * 1000ULL))
#define TIMER_MSEC2IRQCNT(x) (x / TIMER_IRQFREQ_MS)
static uint16_t timers[TIMER_COUNT];
volatile static uint8_t timer_ticked;
static uint16_t m_timers[TIMER_COUNT];
volatile static uint8_t m_timer_ticked;
/* *********************************************************************** */
@ -53,24 +52,24 @@ ISR(TIMER_TIM_VECT)
/* 1ms interrupt */
TIMER_TIM_RELOAD(TIMER_MSEC2TICKS(TIMER_IRQFREQ_MS));
timer_ticked = 1;
m_timer_ticked = 1;
} /* TIM1_OVF_vect */
uint8_t timer_check(uint8_t timer_needed)
{
if (timer_ticked)
if (m_timer_ticked)
{
uint8_t i;
timer_ticked = 0;
m_timer_ticked = 0;
for (i = 0; i < TIMER_COUNT; i++)
{
if (timers[i] > 0)
if (m_timers[i] > 0)
{
timers[i]--;
if (timers[i] == 0)
m_timers[i]--;
if (m_timers[i] == 0)
{
event_queue(EVENT_TYPE_TIMER_ELAPSED, i, 0);
}
@ -100,7 +99,7 @@ void timer_event_handler(event_entry_t * p_event)
(p_event->num < TIMER_COUNT)
)
{
timers[p_event->num] = p_event->value;
m_timers[p_event->num] = p_event->value;
/* start timer if needed */
if (!TIMER_TIM_RUNNING())
@ -112,17 +111,10 @@ void timer_event_handler(event_entry_t * p_event)
} /* timer_event_handler */
uint8_t timer_get_sleep_mode(void)
uint8_t timer_need_hw_clock(void)
{
if (TIMER_TIM_RUNNING())
{
return SLEEP_MODE_IDLE;
}
else
{
return SLEEP_MODE_PWR_DOWN;
}
} /* timer_get_sleep_mode */
return !!TIMER_TIM_RUNNING();
} /* timer_get_sleep_mode */
void timer_init(void)

13
timer.h

@ -1,5 +1,5 @@
#ifndef __TIMER_H__
#define __TIMER_H__
#ifndef TIMER_H_SEEN
#define TIMER_H_SEEN
#include <stdint.h>
#include "event.h"
@ -8,18 +8,15 @@
#define TIMER_COUNT 1
#define EVENT_TYPE_TIMER_SET 0x01
#define EVENT_TYPE_TIMER_ELAPSED 0x02
#define EVENT_NUM_TIMER_PWM 0
#define EVENT_NUM_TIMER_LEDFADE 0
/* *********************************************************************** */
void timer_init (void);
uint8_t timer_check (uint8_t timer_needed);
void timer_event_handler (event_entry_t * p_event);
uint8_t timer_get_sleep_mode (void);
uint8_t timer_need_hw_clock (void);
/* *********************************************************************** */
#endif /* __TIMER_H__ */
#endif /* TIMER_H_SEEN */
Loading…
Cancel
Save