/*
* Workshop Clock
*
- * (c) 2020 Martin Mareš <mj@ucw.cz>
+ * (c) 2020-2023 Martin Mareš <mj@ucw.cz>
*/
#include "util.h"
#include <libopencm3/stm32/gpio.h>
#include <libopencm3/stm32/usart.h>
#include <libopencm3/stm32/i2c.h>
+#include <libopencm3/stm32/timer.h>
#include <libopencm3/usb/dfu.h>
#include <libopencm3/usb/usbd.h>
#include <string.h>
+static void ep82_send(u32 key_code);
+
/*** Hardware init ***/
static void clock_init(void)
{
- rcc_clock_setup_in_hse_8mhz_out_72mhz();
+ rcc_clock_setup_pll(&rcc_hse_configs[RCC_CLOCK_HSE8_72MHZ]);
rcc_periph_clock_enable(RCC_GPIOA);
rcc_periph_clock_enable(RCC_GPIOB);
rcc_periph_clock_enable(RCC_I2C1);
rcc_periph_clock_enable(RCC_USART1);
rcc_periph_clock_enable(RCC_USB);
+ rcc_periph_clock_enable(RCC_TIM1);
rcc_periph_reset_pulse(RST_GPIOA);
rcc_periph_reset_pulse(RST_GPIOB);
rcc_periph_reset_pulse(RST_I2C1);
rcc_periph_reset_pulse(RST_USART1);
rcc_periph_reset_pulse(RST_USB);
+ rcc_periph_reset_pulse(RST_TIM1);
}
static void gpio_init(void)
// PB6 = SCL for display controller
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_OPENDRAIN, GPIO6 | GPIO7);
- // PB8 = SFH5110 output (5V tolerant)
+ // PA8 = SFH5110 output (5V tolerant) connected to TIM1_CH1
gpio_set_mode(GPIOC, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO8);
}
static byte disp[4];
static byte ctrl = 0x56;
+static const byte disp_font[] = {
+ [0] = 0xee,
+ [1] = 0x82,
+ [2] = 0xdc,
+ [3] = 0xd6,
+ [4] = 0xb2,
+ [5] = 0x76,
+ [6] = 0x7e,
+ [7] = 0xc2,
+ [8] = 0xfe,
+ [9] = 0xf6,
+ [10] = 0xea,
+ [11] = 0x3e,
+ [12] = 0x6c,
+ [13] = 0x9e,
+ [14] = 0x7c,
+ [15] = 0x78,
+};
+
static void display_update(void)
{
- debug_puts("Display update\n");
+ // debug_puts("Display update\n");
+
byte cmds[4];
cmds[0] = 0;
cmds[1] = ctrl;
cmds[3] = disp[2];
i2c_transfer7(I2C1, 0x70/2, (byte *) cmds, sizeof(cmds), NULL, 0);
- debug_puts("Update done\n");
+ // debug_puts("Update done\n");
}
static void display_init(void)
i2c_set_speed(I2C1, i2c_speed_sm_100k, rcc_apb1_frequency / 1000000);
i2c_peripheral_enable(I2C1);
- disp[0] = 0x82;
- disp[1] = 0xdc;
- disp[2] = 0xd6;
- disp[3] = 0xb2;
+ disp[0] = 0x10;
+ disp[1] = 0x10;
+ disp[2] = 0x10;
+ disp[3] = 0x10;
display_update();
}
-static void display_test(void)
+/*** Infrared Remote Control ***/
+
+static void ir_init(void)
{
- static byte mode;
+ debug_puts("IR init\n");
- disp[0] ^= 0x01;
- display_update();
+ // TIM1 will measure pulses and spaces between them with 1μs resolution
+ timer_set_prescaler(TIM1, 71); // 72 MHz / 72 = 1 MHz
+ timer_set_mode(TIM1, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP);
+ timer_set_period(TIM1, 65535);
+ timer_update_on_overflow(TIM1);
-#if 0
- byte cmds[] = { 0x00, mode ? 0x77 : 0x77 };
- i2c_transfer7(I2C1, 0x70/2, (byte *) cmds, sizeof(cmds), NULL, 0);
-#endif
+ // IC1 will trigger on TI1 (TIM1_CH1) falling edge
+ timer_ic_set_input(TIM1, TIM_IC1, TIM_IC_IN_TI1);
+ // timer_ic_set_filter(TIM1, TIM_IC1, TIM_IC_OFF);
+ timer_set_oc_polarity_low(TIM1, TIM_OC1); // OC functions affect IC, too
-#if 0
- byte disp[] = { 0xff, 0xff, mode ? 0xff : 0x00, mode ? 0xff : 0xff };
- byte cmds[] = { 0x00, 0x77, 0, 0, 0, 0 };
- cmds[2] = (disp[0] & 0xf0) | (disp[2] >> 4);
- cmds[3] = (disp[1] & 0xf0) | (disp[3] >> 4);
- cmds[4] = (disp[2] & 0x0f) | (disp[0] << 4);
- cmds[5] = (disp[3] & 0x0f) | (disp[1] << 4);
- i2c_transfer7(I2C1, 0x70/2, (byte *) cmds, sizeof(cmds), NULL, 0);
-#endif
+ // IC2 will trigger on TI1 (TIM1_CH1) rising edge
+ timer_ic_set_input(TIM1, TIM_IC2, TIM_IC_IN_TI1);
+ timer_set_oc_polarity_high(TIM1, TIM_OC2);
+
+ // OC3 will trigger on a break longer than 50 ms
+ timer_set_oc_mode(TIM1, TIM_OC3, TIM_OCM_ACTIVE);
+ timer_set_oc_value(TIM1, TIM_OC3, 30000);
+
+ // Program slave controller to reset the timer on IC1
+ timer_slave_set_trigger(TIM1, TIM_SMCR_TS_TI1FP1);
+ timer_slave_set_mode(TIM1, TIM_SMCR_SMS_RM);
- mode = !mode;
+ // Request interrupts
+ timer_enable_irq(TIM1, TIM_DIER_CC1IE | TIM_DIER_CC2IE | TIM_DIER_CC3IE);
+ nvic_enable_irq(NVIC_TIM1_CC_IRQ);
+
+ // Enable ICs and OCs
+ timer_enable_oc_output(TIM1, TIM_OC1);
+ timer_enable_oc_output(TIM1, TIM_OC2);
+ timer_enable_oc_output(TIM1, TIM_OC3);
+
+ timer_enable_counter(TIM1);
}
-static const byte lcd_font[] = {
- [0] = 0xee,
- [1] = 0x82,
- [2] = 0xdc,
- [3] = 0xd6,
- [4] = 0xb2,
- [5] = 0x76,
- [6] = 0x7e,
- [7] = 0xc2,
- [8] = 0xfe,
- [9] = 0xf6,
- [10] = 0xea,
- [11] = 0x3e,
- [12] = 0x6c,
- [13] = 0x9e,
- [14] = 0x7c,
- [15] = 0x78,
-};
+// Circular queue of pulse durations
+#define IR_MAX_PULSES 32
+static u32 ir_pulses[IR_MAX_PULSES]; // Top 16 bits = mark, bottom 16 bits = space
+static u16 ir_last_pulse;
+static uint ir_pulses_rx, ir_pulses_tx;
+
+#define IR_INF 0xffff
+
+#define IR_MARK(x) (uint)((x) >> 16)
+#define IR_SPACE(x) (uint)((x) & 0xffff)
+
+static inline bool between(uint x, uint min, uint max)
+{
+ return x >= min && x <= max;
+}
+
+static void ir_record_pulse(uint mark, uint space)
+{
+ uint i = ir_pulses_tx;
+ ir_pulses_tx = (i + 1) % IR_MAX_PULSES;
+ if (ir_pulses_tx != ir_pulses_rx) {
+ ir_pulses[i] = (mark << 16) | space;
+ } else {
+ // Overflow detected
+ ir_pulses[i] = (IR_INF << 16) | IR_INF;
+ }
+}
+
+void tim1_cc_isr(void)
+{
+ if (TIM_SR(TIM1) & TIM_SR_CC1IF) {
+ TIM_SR(TIM1) &= ~TIM_SR_CC1IF;
+ u16 now = TIM_CCR1(TIM1);
+ if (ir_last_pulse) {
+ ir_record_pulse(ir_last_pulse, now - ir_last_pulse);
+ ir_last_pulse = 0;
+ }
+ }
+ if (TIM_SR(TIM1) & TIM_SR_CC2IF) {
+ TIM_SR(TIM1) &= ~TIM_SR_CC2IF;
+ ir_last_pulse = TIM_CCR2(TIM1);
+ }
+ if (TIM_SR(TIM1) & TIM_SR_CC3IF) {
+ TIM_SR(TIM1) &= ~TIM_SR_CC3IF;
+ if (ir_last_pulse) {
+ ir_record_pulse(ir_last_pulse, IR_INF);
+ ir_last_pulse = 0;
+ }
+ }
+}
+
+static u32 ir_get_pulse(void)
+{
+ u32 out = 0;
+
+ cm_disable_interrupts();
+ if (ir_pulses_rx != ir_pulses_tx) {
+ out = ir_pulses[ir_pulses_rx];
+ ir_pulses_rx = (ir_pulses_rx + 1) % IR_MAX_PULSES;
+ }
+ cm_enable_interrupts();
+ return out;
+}
+
+// Decoder for Onkyo RC-748S
+
+static void ir_decode(void)
+{
+ u32 pulse = ir_get_pulse();
+ if (!pulse)
+ return;
+
+ uint mark = IR_MARK(pulse);
+ uint space = IR_SPACE(pulse);
+
+#ifdef IR_TEST
+ debug_printf("IR: %d %d\n", mark, space);
+ return;
+#endif
+
+ static u16 ir_bits;
+ static u32 ir_code;
+#define IR_ERR 0xff
+
+ // debug_printf("IR(%d): %d %d\n", ir_bits, mark, space);
+
+ if (space == IR_INF) {
+ ir_bits = 0;
+ } else if (ir_bits == IR_ERR) {
+ // Error state
+ } else if (ir_bits == 0) {
+ // Start?
+ if (between(mark, 8900, 9200)) {
+ if (between(space, 4200, 4600)) {
+ ir_bits = 1;
+ ir_code = 0;
+ } else if (between(space, 2000, 2300)) {
+ debug_printf("IR: => REP\n");
+ ir_bits = IR_ERR;
+ }
+ }
+ } else {
+ if (between(mark, 500, 700)) {
+ ir_bits++;
+ if (between(space, 400, 700)) {
+ // 0
+ } else if (between(space, 1500, 1800)) {
+ // 1
+ ir_code |= 1U << (33 - ir_bits);
+ } else {
+ ir_bits = IR_ERR;
+ }
+ if (ir_bits == 33) {
+ debug_printf("IR: => %08x\n", (uint)ir_code);
+ disp[3] ^= 0x01;
+ display_update();
+ ir_bits = IR_ERR;
+ ep82_send(ir_code);
+ }
+ } else {
+ ir_bits = IR_ERR;
+ }
+ }
+}
/*** USB ***/
.bmAttributes = USB_ENDPOINT_ATTR_BULK,
.wMaxPacketSize = 64,
.bInterval = 1,
+}, {
+ // Bulk end-point for receiving remote control keys
+ .bLength = USB_DT_ENDPOINT_SIZE,
+ .bDescriptorType = USB_DT_ENDPOINT,
+ .bEndpointAddress = 0x82,
+ .bmAttributes = USB_ENDPOINT_ATTR_BULK,
+ .wMaxPacketSize = 4,
+ .bInterval = 1,
}};
static const struct usb_interface_descriptor iface = {
.bDescriptorType = USB_DT_INTERFACE,
.bInterfaceNumber = 0,
.bAlternateSetting = 0,
- .bNumEndpoints = 1,
+ .bNumEndpoints = 2,
.bInterfaceClass = 0xFF,
.bInterfaceSubClass = 0,
.bInterfaceProtocol = 0,
.interface = ifaces,
};
-static byte usb_configured;
+static bool usb_configured;
static uint8_t usbd_control_buffer[64];
+static bool usb_tx_in_flight;
+static byte ep82_tx_buffer[4];
+
+static byte disp_alive;
+
static void dfu_detach_complete(usbd_device *dev UNUSED, struct usb_setup_data *req UNUSED)
{
// Reset to bootloader, which implements the rest of DFU
debug_printf("USB: Host sent %u bytes\n", len);
if (len >= 5) {
for (uint i=0; i<4; i++) {
+ disp[i] &= 0x01;
if (buf[i] < 16)
- disp[i] = lcd_font[buf[i]];
- else
- disp[i] = 0;
+ disp[i] |= disp_font[buf[i]];
}
+ disp[1] &= 0xfe;
if (buf[4])
- disp[1] |= 1;
+ disp[1] |= 0x01;
display_update();
+ disp_alive = 10;
}
}
+static void ep82_send(u32 key_code)
+{
+ if (usb_tx_in_flight) {
+ debug_printf("USB: Send overrun!\n");
+ return;
+ }
+
+ debug_printf("USB: Sending key to host\n");
+ put_u32_be(ep82_tx_buffer, key_code);
+ usbd_ep_write_packet(usbd_dev, 0x82, ep82_tx_buffer, 4);
+ usb_tx_in_flight = true;
+}
+
+static void ep82_cb(usbd_device *dev UNUSED, uint8_t ep UNUSED)
+{
+ // We completed sending a frame to the USB host
+ usb_tx_in_flight = false;
+ debug_printf("USB: Key sending complete\n");
+}
+
static void set_config_cb(usbd_device *dev, uint16_t wValue UNUSED)
{
usbd_register_control_callback(
USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT,
dfu_control_cb);
usbd_ep_setup(dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, ep01_cb);
- usb_configured = 1;
+ usbd_ep_setup(dev, 0x82, USB_ENDPOINT_ATTR_BULK, 4, ep82_cb);
+ usb_configured = true;
}
static void reset_cb(void)
{
debug_printf("USB: Reset\n");
- usb_configured = 0;
+ usb_configured = false;
}
static volatile bool usb_event_pending;
usb_event_pending = 1;
}
-/*** Testing of IR receiver ***/
-
-#ifdef IR_TEST
-
-static u16 get_bit(void)
-{
-#if 1
- return !gpio_get(GPIOB, GPIO8);
-#else
- int x = 0;
- x += !gpio_get(GPIOB, GPIO8);
- x += !gpio_get(GPIOB, GPIO8);
- x += !gpio_get(GPIOB, GPIO8);
- x += !gpio_get(GPIOB, GPIO8);
- return x >= 2;
-#endif
-}
-
-#define MAX_SAMPLES 1024
-u32 samples[MAX_SAMPLES];
-
-static void ir_test_loop(void)
-{
- debug_puts("\n\n### Infrared Remote Control receiver ###\n\n");
-
- systick_set_reload(0xffffff);
- systick_counter_enable();
- systick_interrupt_disable();
- systick_clear();
-
- for (;;) {
- gpio_set(GPIOC, GPIO13);
-
- if (get_bit()) {
- debug_puts("Waiting for silence\n");
- while (get_bit())
- ;
- }
- debug_puts("Ready...");
-
- u16 last = 0;
- uint nsamp = 0;
- u32 start;
-
- do {
- start = systick_get_value();
- last = get_bit();
- } while (!last);
-
- gpio_clear(GPIOC, GPIO13);
-
- for (;;) {
- u32 now;
- u16 curr;
- uint len;
- do {
- now = systick_get_value();
- len = (start - now) & 0xffffff;
- if (len > 5000000) {
- samples[nsamp++] = len;
- goto timeout;
- }
- curr = get_bit();
- } while (curr == last);
- samples[nsamp++] = len;
- if (nsamp >= MAX_SAMPLES)
- break;
- start = now;
- last = curr;
- }
-
- timeout:
- for (uint i=0; i<nsamp; i++) {
- debug_putc(i ? ' ' : '\n');
- debug_printf("%u", (unsigned int)((samples[i] + CPU_CLOCK_MHZ - 1) / CPU_CLOCK_MHZ)); // in μs
- }
- debug_putc('\n');
- }
-}
-
-#endif
-
/*** Main ***/
int main(void)
gpio_init();
usart_init();
-#ifdef IR_TEST
- ir_test_loop();
-#endif
-
tick_init();
desig_get_unique_id_as_dfu(usb_serial_number);
usb_init();
display_init();
+ ir_init();
u32 last_blink = 0;
if (ms_ticks - last_blink >= 500) {
debug_led_toggle();
last_blink = ms_ticks;
- display_test();
+ if (disp_alive) {
+ if (!--disp_alive) {
+ disp[0] = (disp[0] & 0x01) | 0x10;
+ disp[1] = (disp[1] & 0x01) | 0x10;
+ disp[2] = (disp[2] & 0x01) | 0x10;
+ disp[3] = (disp[3] & 0x01) | 0x10;
+ }
+ }
+ disp[0] ^= 0x01;
+ display_update();
}
+ ir_decode();
+
if (usb_event_pending) {
usbd_poll(usbd_dev);
usb_event_pending = 0;
projects / home-hw.git / blobdiff