kopia lustrzana https://github.com/mobilinkd/tnc3-firmware
462 wiersze
8.3 KiB
C++
462 wiersze
8.3 KiB
C++
// Copyright 2017 Rob Riggs <rob@mobilinkd.com>
|
|
// All rights reserved.
|
|
|
|
#include "LEDIndicator.h"
|
|
|
|
#include <stm32l4xx_hal.h>
|
|
#include <stm32l4xx_hal_tim.h>
|
|
#include <stm32l4xx_hal_tim_ex.h>
|
|
|
|
#include <functional>
|
|
|
|
#include <stdint.h>
|
|
|
|
extern "C" void _Error_Handler(char *, int);
|
|
|
|
extern TIM_HandleTypeDef htim1;
|
|
|
|
namespace mobilinkd { namespace tnc {
|
|
|
|
}} // mobilinkd::tnc
|
|
|
|
/**
|
|
* No connection shows a low, slow breathing. Each breath inhale takes
|
|
* for 500ms, is held for 500ms, and exhaled in 500ms. This is repeated
|
|
* every 10 seconds. Maximum brightness is 20%.
|
|
*
|
|
* Each interrupt occurs at 10ms intervals.
|
|
*
|
|
* The sequence is:
|
|
* - ramp up 300ms(30)
|
|
* - hold 400ms (40)
|
|
* - ramp down 300ms (30)
|
|
* - wait 9000ms (900)
|
|
*
|
|
*
|
|
*/
|
|
struct NoConnection {
|
|
enum STATE {
|
|
RAMP_UP_1, WAIT_1, RAMP_DN_1, WAIT_2
|
|
};
|
|
|
|
int count{0};
|
|
int state{RAMP_UP_1};
|
|
|
|
int operator()()
|
|
{
|
|
int result;
|
|
switch (state) {
|
|
case RAMP_UP_1:
|
|
result = count * 40;
|
|
if (count == 49) {
|
|
count = 0;
|
|
state = WAIT_1;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case WAIT_1:
|
|
result = 2000;
|
|
if (count == 49) {
|
|
state = RAMP_DN_1;
|
|
count = 49;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_DN_1:
|
|
result = count * 40;
|
|
if (count == 0) {
|
|
count = 0;
|
|
state = WAIT_2;
|
|
} else {
|
|
--count;
|
|
}
|
|
break;
|
|
case WAIT_2:
|
|
result = 0;
|
|
if (count == 849) {
|
|
state = RAMP_UP_1;
|
|
count = 0;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Bluetooth connection shows a double blip. Each blip lasts for 200ms
|
|
* and is separated by 200ms, and is repeated ever 5 seconds.
|
|
*
|
|
* Each interrupt occurs at 10ms intervals.
|
|
*
|
|
* The sequence is:
|
|
* - ramp up 100s(10)
|
|
* - ramp down 100ms (10)
|
|
* - wait 200ms (20)
|
|
* - ramp up 100ms (10)
|
|
* - ramp down 100ms (10)
|
|
* - wait 4400ms (440)
|
|
*
|
|
*
|
|
*/
|
|
struct BluetoothConnection {
|
|
enum STATE {
|
|
RAMP_UP_1, RAMP_DN_1, WAIT_1, RAMP_UP_2, RAMP_DN_2, WAIT_2
|
|
};
|
|
|
|
int count{0};
|
|
int pulse{0};
|
|
int state{RAMP_UP_1};
|
|
int ramp[10] = {1564,3090,4540,5878,7071,8090,8910,9510,9877,9999};
|
|
|
|
int operator()()
|
|
{
|
|
int result;
|
|
switch (state) {
|
|
case RAMP_UP_1:
|
|
result = ramp[count] / 2;
|
|
if (count == 9) {
|
|
state = RAMP_DN_1;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_DN_1:
|
|
result = ramp[count] / 2;
|
|
if (count == 0) {
|
|
state = WAIT_1;
|
|
} else {
|
|
--count;
|
|
}
|
|
break;
|
|
case WAIT_1:
|
|
result = 0;
|
|
if (count == 19) {
|
|
state = RAMP_UP_2;
|
|
count = 0;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_UP_2:
|
|
result = ramp[count] / 2;
|
|
if (count == 9) {
|
|
state = RAMP_DN_2;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_DN_2:
|
|
result = ramp[count] / 2;
|
|
if (count == 0) {
|
|
state = WAIT_2;
|
|
} else {
|
|
--count;
|
|
}
|
|
break;
|
|
case WAIT_2:
|
|
result = 0;
|
|
if (count == 439) {
|
|
state = RAMP_UP_1;
|
|
count = 0;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* USB connection shows a triple blip. Each blip lasts for 200ms. The
|
|
* first two are separated by 400ms. The third comes 200ms later. This
|
|
* is repeated ever 5 seconds.
|
|
*
|
|
* Each interrupt occurs at 10ms intervals.
|
|
*
|
|
* The sequence is:
|
|
* - ramp up 100s(10)
|
|
* - ramp down 100ms (10)
|
|
* - wait 200ms (20)
|
|
* - ramp up 100s(10)
|
|
* - ramp down 100ms (10)
|
|
* - wait 400ms (20)
|
|
* - ramp up 100ms (10)
|
|
* - ramp down 100ms (10)
|
|
* - wait 3800ms (440)
|
|
*
|
|
*
|
|
*/
|
|
struct USBConnection {
|
|
enum STATE {
|
|
RAMP_UP_1, RAMP_DN_1, WAIT_1, RAMP_UP_2, RAMP_DN_2, WAIT_2, RAMP_UP_3, RAMP_DN_3, WAIT_3
|
|
};
|
|
|
|
int count{0};
|
|
int pulse{0};
|
|
int state{RAMP_UP_1};
|
|
int ramp[10] = {1564,3090,4540,5878,7071,8090,8910,9510,9877,9999};
|
|
|
|
int operator()()
|
|
{
|
|
int result;
|
|
switch (state) {
|
|
case RAMP_UP_1:
|
|
result = ramp[count];
|
|
if (count == 9) {
|
|
state = RAMP_DN_1;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_DN_1:
|
|
result = ramp[count];
|
|
if (count == 0) {
|
|
state = WAIT_1;
|
|
} else {
|
|
--count;
|
|
}
|
|
break;
|
|
case WAIT_1:
|
|
result = 0;
|
|
if (count == 39) {
|
|
state = RAMP_UP_2;
|
|
count = 0;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_UP_2:
|
|
result = ramp[count];
|
|
if (count == 9) {
|
|
state = RAMP_DN_2;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_DN_2:
|
|
result = ramp[count];
|
|
if (count == 0) {
|
|
state = WAIT_2;
|
|
} else {
|
|
--count;
|
|
}
|
|
break;
|
|
case WAIT_2:
|
|
result = 0;
|
|
if (count == 19) {
|
|
state = RAMP_UP_3;
|
|
count = 0;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_UP_3:
|
|
result = ramp[count];
|
|
if (count == 9) {
|
|
state = RAMP_DN_3;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
case RAMP_DN_3:
|
|
result = ramp[count];
|
|
if (count == 0) {
|
|
state = WAIT_3;
|
|
} else {
|
|
--count;
|
|
}
|
|
break;
|
|
case WAIT_3:
|
|
result = 0;
|
|
if (count == 379) {
|
|
state = RAMP_UP_1;
|
|
count = 0;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
struct Flash {
|
|
enum STATE {
|
|
RAMP_UP, ON, RAMP_DN, OFF
|
|
};
|
|
|
|
int gr_count{9};
|
|
STATE gr_state{OFF};
|
|
int rd_count{9};
|
|
STATE rd_state{OFF};
|
|
int ramp[10] = {1564,3090,4540,5878,7071,8090,8910,9510,9877,9999};
|
|
|
|
typedef std::function<int(void)> function_type;
|
|
|
|
NoConnection noConnection;
|
|
BluetoothConnection btConnection;
|
|
USBConnection usbConnection;
|
|
|
|
function_type blue_func{noConnection};
|
|
|
|
int blue()
|
|
{
|
|
return blue_func();
|
|
}
|
|
|
|
int green()
|
|
{
|
|
int result = 0;
|
|
switch (gr_state) {
|
|
case RAMP_UP:
|
|
result = ramp[gr_count] / 3;
|
|
if (gr_count == 9) {
|
|
gr_state = ON;
|
|
} else {
|
|
++gr_count;
|
|
}
|
|
break;
|
|
case ON:
|
|
result = ramp[gr_count] / 3;
|
|
break;
|
|
case RAMP_DN:
|
|
result = ramp[gr_count] / 3;
|
|
if (gr_count == 0) {
|
|
gr_state = OFF;
|
|
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3);
|
|
} else {
|
|
--gr_count;
|
|
}
|
|
break;
|
|
case OFF:
|
|
result = 0;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int red()
|
|
{
|
|
int result = 0;
|
|
switch (rd_state) {
|
|
case RAMP_UP:
|
|
result = ramp[rd_count] / 3;
|
|
if (rd_count == 9) {
|
|
rd_state = ON;
|
|
} else {
|
|
++rd_count;
|
|
}
|
|
break;
|
|
case ON:
|
|
result = ramp[rd_count] / 3;
|
|
break;
|
|
case RAMP_DN:
|
|
result = ramp[rd_count] / 3;
|
|
if (rd_count == 0) {
|
|
rd_state = OFF;
|
|
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_2);
|
|
} else {
|
|
--rd_count;
|
|
}
|
|
break;
|
|
case OFF:
|
|
result = 0;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void dcd_on() {
|
|
if (gr_state == OFF)
|
|
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);
|
|
gr_state = RAMP_UP;
|
|
}
|
|
void dcd_off() {
|
|
if (gr_state != OFF) gr_state = RAMP_DN;
|
|
}
|
|
|
|
void tx_on() {
|
|
if (rd_state == OFF)
|
|
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
|
|
rd_state = RAMP_UP;
|
|
}
|
|
void tx_off() {
|
|
if (rd_state != OFF) rd_state = RAMP_DN;
|
|
}
|
|
void disconnect() { blue_func = noConnection; }
|
|
void usb() { blue_func = usbConnection; }
|
|
void bt() { blue_func = btConnection; }
|
|
};
|
|
|
|
Flash flash;
|
|
|
|
void HTIM1_PeriodElapsedCallback()
|
|
{
|
|
htim1.Instance->CCR1 = flash.blue();
|
|
htim1.Instance->CCR2 = flash.red();
|
|
htim1.Instance->CCR3 = flash.green();
|
|
}
|
|
|
|
void indicate_turning_on(void)
|
|
{
|
|
HAL_TIM_Base_Start_IT(&htim1);
|
|
tx_on();
|
|
|
|
HAL_Delay(200);
|
|
}
|
|
|
|
void indicate_initializing_ble(void)
|
|
{
|
|
rx_on();
|
|
}
|
|
|
|
void indicate_on()
|
|
{
|
|
tx_off();
|
|
rx_off();
|
|
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
|
|
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
|
|
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);
|
|
}
|
|
|
|
void indicate_waiting_to_connect(void)
|
|
{
|
|
flash.disconnect();
|
|
}
|
|
void indicate_connected_via_usb(void)
|
|
{
|
|
flash.usb();
|
|
}
|
|
void indicate_connected_via_ble(void)
|
|
{
|
|
flash.bt();
|
|
}
|
|
|
|
void tx_on(void)
|
|
{
|
|
flash.tx_on();
|
|
}
|
|
|
|
void tx_off(void)
|
|
{
|
|
flash.tx_off();
|
|
}
|
|
|
|
// DCD is active.
|
|
void rx_on()
|
|
{
|
|
flash.dcd_on();
|
|
}
|
|
|
|
// DCD is active.
|
|
void rx_off()
|
|
{
|
|
flash.dcd_off();
|
|
}
|