liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-572][FL-577] Irda receive feature (#282)

Browse Source 
* fix "state not acquired error"
* add InterruptTypeComparatorTrigger to interrupt mgr, use interrupt mgr in irda app
* separate init irda timer
* capture events buffer by app
* irda common decoder
* irda nec decoder realization
* finished work with decoder
* fix app path
* fix widget remove on exit
* nec receive, store and send
* init some packets
This commit is contained in:
DrZlo13
2021-01-08 02:28:35 +10:00
committed by GitHub
parent c70ed2f349
commit d65e9b04ce
12 changed files with 492 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
applications/irda/irda.c
View File

@@ -3,6 +3,7 @@
#include "irda_nec.h"
#include "irda_samsung.h"
#include "irda_protocols.h"
#include "irda-decoder/irda-decoder.h"
typedef enum {
EventTypeTick,
@@ -10,20 +11,34 @@ typedef enum {
EventTypeRX,
} EventType;
typedef struct {
bool edge;
uint32_t lasted;
} RXValue;
typedef struct {
union {
InputEvent input;
bool rx_edge;
RXValue rx;
} value;
EventType type;
} AppEvent;
typedef struct {
IrDAProtocolType protocol;
uint32_t address;
uint32_t command;
} IrDAPacket;
#define IRDA_PACKET_COUNT 8
typedef struct {
uint8_t mode_id;
uint16_t carrier_freq;
uint8_t carrier_duty_cycle_id;
uint8_t nec_packet_id;
uint8_t samsung_packet_id;
uint8_t packet_id;
IrDAPacket packets[IRDA_PACKET_COUNT];
} State;
typedef void (*ModeInput)(AppEvent*, State*);
@@ -31,47 +46,17 @@ typedef void (*ModeRender)(Canvas*, State*);
void input_carrier(AppEvent* event, State* state);
void render_carrier(Canvas* canvas, State* state);
void input_nec(AppEvent* event, State* state);
void render_nec(Canvas* canvas, State* state);
void render_carrier(Canvas* canvas, State* state);
void input_samsung(AppEvent* event, State* state);
void render_samsung(Canvas* canvas, State* state);
void input_packet(AppEvent* event, State* state);
void render_packet(Canvas* canvas, State* state);
typedef struct {
ModeRender render;
ModeInput input;
} Mode;
typedef struct {
uint8_t addr;
uint8_t data;
} NecPacket;
typedef struct {
uint16_t addr;
uint16_t data;
} SamsungPacket;
const Mode modes[] = {
{.render = render_carrier, .input = input_carrier},
{.render = render_nec, .input = input_nec},
{.render = render_samsung, .input = input_samsung},
};
const NecPacket nec_packets[] = {
{.addr = 0xFF, .data = 0x11},
{.addr = 0xF7, .data = 0x59},
{.addr = 0xFF, .data = 0x01},
{.addr = 0xFF, .data = 0x10},
{.addr = 0xFF, .data = 0x15},
{.addr = 0xFF, .data = 0x25},
{.addr = 0xFF, .data = 0xF0},
};
const SamsungPacket samsung_packets[] = {
{.addr = 0xE0E, .data = 0xF30C},
{.addr = 0xE0E, .data = 0xF40D},
{.addr = 0xE0E, .data = 0xF50E},
{.render = render_packet, .input = input_packet},
};
const float duty_cycles[] = {0.1, 0.25, 0.333, 0.5, 1.0};
@@ -90,36 +75,6 @@ void render_carrier(Canvas* canvas, State* state) {
}
}
void render_nec(Canvas* canvas, State* state) {
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 2, 25, "< nec mode >");
canvas_draw_str(canvas, 2, 37, "? /\\ \\/ packet");
{
char buf[24];
sprintf(
buf,
"packet: %02X %02X",
nec_packets[state->nec_packet_id].addr,
nec_packets[state->nec_packet_id].data);
canvas_draw_str(canvas, 2, 50, buf);
}
}
void render_samsung(Canvas* canvas, State* state) {
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 2, 25, "< samsung32 mode");
canvas_draw_str(canvas, 2, 37, "? /\\ \\/ packet");
{
char buf[24];
sprintf(
buf,
"packet: %02X %02X",
samsung_packets[state->samsung_packet_id].addr,
samsung_packets[state->samsung_packet_id].data);
canvas_draw_str(canvas, 2, 50, buf);
}
}
void input_carrier(AppEvent* event, State* state) {
if(event->value.input.input == InputOk) {
if(event->value.input.state) {
@@ -147,76 +102,86 @@ void input_carrier(AppEvent* event, State* state) {
}
}
void input_nec(AppEvent* event, State* state) {
uint8_t packets_count = sizeof(nec_packets) / sizeof(nec_packets[0]);
void render_packet(Canvas* canvas, State* state) {
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 2, 25, "< packet mode");
canvas_draw_str(canvas, 2, 37, "? /\\ \\/ packet");
{
const char* protocol;
if(event->value.input.input == InputOk) {
if(event->value.input.state) {
vTaskSuspendAll();
ir_nec_send(
nec_packets[state->nec_packet_id].addr, nec_packets[state->nec_packet_id].data);
xTaskResumeAll();
switch(state->packets[state->packet_id].protocol) {
case IRDA_NEC:
protocol = "NEC";
break;
case IRDA_SAMSUNG:
protocol = "SAMS";
break;
case IRDA_UNKNOWN:
default:
protocol = "UNK";
break;
}
}
if(event->value.input.state && event->value.input.input == InputUp) {
if(state->nec_packet_id < (packets_count - 1)) {
state->nec_packet_id++;
} else {
state->nec_packet_id = 0;
}
}
if(event->value.input.state && event->value.input.input == InputDown) {
if(state->nec_packet_id > 0) {
state->nec_packet_id--;
} else {
state->nec_packet_id = packets_count - 1;
}
char buf[24];
sprintf(
buf,
"P[%d]: %s 0x%X 0x%X",
state->packet_id,
protocol,
state->packets[state->packet_id].address,
state->packets[state->packet_id].command);
canvas_draw_str(canvas, 2, 50, buf);
}
}
void input_samsung(AppEvent* event, State* state) {
uint8_t packets_count = sizeof(samsung_packets) / sizeof(samsung_packets[0]);
void input_packet(AppEvent* event, State* state) {
if(event->value.input.input == InputOk) {
if(event->value.input.state) {
vTaskSuspendAll();
ir_samsung_send(
samsung_packets[state->samsung_packet_id].addr,
samsung_packets[state->samsung_packet_id].data);
switch(state->packets[state->packet_id].protocol) {
case IRDA_NEC:
ir_nec_send(
state->packets[state->packet_id].address,
state->packets[state->packet_id].command);
break;
case IRDA_SAMSUNG:
ir_samsung_send(
state->packets[state->packet_id].address,
state->packets[state->packet_id].command);
break;
default:
break;
}
xTaskResumeAll();
}
}
if(event->value.input.state && event->value.input.input == InputUp) {
if(state->samsung_packet_id < (packets_count - 1)) {
state->samsung_packet_id++;
} else {
state->samsung_packet_id = 0;
}
if(event->value.input.state && event->value.input.input == InputDown) {
if(state->packet_id < (IRDA_PACKET_COUNT - 1)) {
state->packet_id++;
};
}
if(event->value.input.state && event->value.input.input == InputDown) {
if(state->samsung_packet_id > 0) {
state->samsung_packet_id--;
} else {
state->samsung_packet_id = packets_count - 1;
}
if(event->value.input.state && event->value.input.input == InputUp) {
if(state->packet_id > 0) {
state->packet_id--;
};
}
}
static void render_callback(Canvas* canvas, void* ctx) {
State* state = (State*)acquire_mutex((ValueMutex*)ctx, 25);
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 2, 12, "irda test");
if(state != NULL) {
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 2, 12, "irda test");
modes[state->mode_id].render(canvas, state);
modes[state->mode_id].render(canvas, state);
release_mutex((ValueMutex*)ctx, state);
release_mutex((ValueMutex*)ctx, state);
}
}
static void input_callback(InputEvent* input_event, void* ctx) {
@@ -228,11 +193,49 @@ static void input_callback(InputEvent* input_event, void* ctx) {
osMessageQueuePut(event_queue, &event, 0, 0);
}
osMessageQueueId_t irda_event_queue;
void irda_timer_capture_callback(void* htim, void* comp_ctx) {
TIM_HandleTypeDef* _htim = (TIM_HandleTypeDef*)htim;
osMessageQueueId_t event_queue = (osMessageQueueId_t)comp_ctx;
if(_htim->Instance == TIM2) {
AppEvent event;
event.type = EventTypeRX;
uint32_t channel;
if(_htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
// falling event
event.value.rx.edge = false;
channel = TIM_CHANNEL_1;
} else if(_htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {
// rising event
event.value.rx.edge = true;
channel = TIM_CHANNEL_2;
} else {
// not our event
return;
}
event.value.rx.lasted = HAL_TIM_ReadCapturedValue(_htim, channel);
__HAL_TIM_SET_COUNTER(_htim, 0);
osMessageQueuePut(event_queue, &event, 0, 0);
}
}
void init_packet(
State* state,
uint8_t index,
IrDAProtocolType protocol,
uint32_t address,
uint32_t command) {
if(index >= IRDA_PACKET_COUNT) return;
state->packets[index].protocol = protocol;
state->packets[index].address = address;
state->packets[index].command = command;
}
void irda(void* p) {
osMessageQueueId_t event_queue = osMessageQueueNew(32, sizeof(AppEvent), NULL);
irda_event_queue = event_queue;
State _state;
uint8_t mode_count = sizeof(modes) / sizeof(modes[0]);
@@ -241,8 +244,20 @@ void irda(void* p) {
_state.carrier_duty_cycle_id = duty_cycles_count - 2;
_state.carrier_freq = 36000;
_state.mode_id = 0;
_state.nec_packet_id = 0;
_state.samsung_packet_id = 0;
_state.packet_id = 0;
for(uint8_t i = 0; i < IRDA_PACKET_COUNT; i++) {
init_packet(&_state, i, IRDA_UNKNOWN, 0, 0);
}
init_packet(&_state, 0, IRDA_NEC, 0xFF00, 0x11);
init_packet(&_state, 1, IRDA_NEC, 0xF708, 0x59);
init_packet(&_state, 2, IRDA_NEC, 0xFF00, 0x10);
init_packet(&_state, 3, IRDA_NEC, 0xFF00, 0x15);
init_packet(&_state, 4, IRDA_NEC, 0xFF00, 0x25);
init_packet(&_state, 5, IRDA_SAMSUNG, 0xE0E, 0xF30C);
init_packet(&_state, 6, IRDA_SAMSUNG, 0xE0E, 0xF40D);
init_packet(&_state, 7, IRDA_SAMSUNG, 0xE0E, 0xF50E);
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, &_state, sizeof(State))) {
@@ -265,26 +280,38 @@ void irda(void* p) {
// Red LED
// TODO open record
const GpioPin* led_record = &led_gpio[0];
const GpioPin* red_led_record = &led_gpio[0];
const GpioPin* green_led_record = &led_gpio[1];
// configure pin
gpio_init(led_record, GpioModeOutputOpenDrain);
gpio_init(red_led_record, GpioModeOutputOpenDrain);
gpio_init(green_led_record, GpioModeOutputOpenDrain);
// setup irda rx timer
tim_irda_rx_init();
// add timer capture interrupt
api_interrupt_add(irda_timer_capture_callback, InterruptTypeTimerCapture, event_queue);
IrDADecoder* decoder = alloc_decoder();
AppEvent event;
while(1) {
osStatus_t event_status = osMessageQueueGet(event_queue, &event, NULL, osWaitForever);
osStatus_t event_status = osMessageQueueGet(event_queue, &event, NULL, 500);
State* state = (State*)acquire_mutex_block(&state_mutex);
if(event_status == osOK) {
if(event.type == EventTypeKey) {
// press events
if(event.value.input.state && event.value.input.input == InputBack) {
printf("[irda] bye!\n");
// TODO remove all widgets create by app
// remove all widgets create by app
widget_enabled_set(widget, false);
gui_remove_widget(gui, widget);
// free decoder
free_decoder(decoder);
// exit
furiac_exit(NULL);
}
@@ -302,7 +329,44 @@ void irda(void* p) {
modes[state->mode_id].input(&event, state);
} else if(event.type == EventTypeRX) {
gpio_write(led_record, event.value.rx_edge);
IrDADecoderOutputData out;
const uint8_t out_data_length = 4;
uint8_t out_data[out_data_length];
out.data_length = out_data_length;
out.data = out_data;
gpio_write(red_led_record, event.value.rx.edge);
bool decoded =
process_decoder(decoder, event.value.rx.edge, &event.value.rx.lasted, 1, &out);
if(decoded) {
// save only if we in packet mode
if(state->mode_id == 1) {
if(out.protocol == IRDA_NEC) {
printf("P=NEC ");
printf("A=0x%02X%02X ", out_data[1], out_data[0]);
printf("C=0x%02X ", out_data[2]);
if(out.flags & IRDA_REPEAT) {
printf("R");
}
printf("\r\n");
state->packets[state->packet_id].protocol = IRDA_NEC;
state->packets[state->packet_id].address = out_data[1] << 8 |
out_data[0];
state->packets[state->packet_id].command = out_data[2];
} else {
printf("Unknown protocol\r\n");
}
}
// blink anyway
gpio_write(green_led_record, false);
delay(10);
gpio_write(green_led_record, true);
}
}
} else {
@@ -312,23 +376,4 @@ void irda(void* p) {
release_mutex(&state_mutex, state);
widget_update(widget);
}
}
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef* htim) {
if(htim->Instance == TIM2) {
if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
// falling event
AppEvent event;
event.type = EventTypeRX;
event.value.rx_edge = false;
osMessageQueuePut(irda_event_queue, &event, 0, 0);
} else if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {
// rising event
//uint32_t period_in_us = HAL_TIM_ReadCapturedValue();
AppEvent event;
event.type = EventTypeRX;
event.value.rx_edge = true;
osMessageQueuePut(irda_event_queue, &event, 0, 0);
}
}
}