diff --git a/lib/bluetooth_hc-05.c b/lib/bluetooth_hc-05.c
deleted file mode 100644
index 3a13503..0000000
--- a/lib/bluetooth_hc-05.c
+++ /dev/null
@@ -1,235 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library handles the communication with a HC-05 bluetooth module */
-/* peripherals used: USART (check source for details) */
-
-/* standard libraries */
-#include // standard integer types
-#include // standard I/O facilities
-#include // general utilities
-#include // string utilities
-
-/* STM32 (including CM3) libraries */
-#include // real-time control clock library
-#include // general purpose input output library
-#include // universal synchronous asynchronous receiver transmitter library
-#include // interrupt handler
-#include // Cortex M3 utilities
-
-#include "global.h" // common utilities
-#include "bluetooth_hc-05.h" // USART header and definitions
-
-/* which USART to use to talk to the bluetooth module */
-#define USART USART2
-#define USART_RCC RCC_USART2
-#define USART_IRQ NVIC_USART2_IRQ
-#define USART_PORT GPIOA
-#define USART_PIN_TX GPIO_USART2_TX
-#define USART_PIN_RX GPIO_USART3_RX
-#define USART_BAUDRATE 9600
-/* AT mode pin
- * to configure the HC-05 bluetooth module you need to put it in AT mode and use AT commands
- * there are several ways to get into AT mode, and there are several AT modes
- * - in full AT mode you can send all [defined] AT commands
- * - in mini AT mode you can't send some AT commands, such as AT+NAME
- * the AT mode is defined by the state of pin 34 of the module (top right)
- * - high: full AT mode
- * - low: mini AT mode
- * this pin is often connect to a switch on the adapter board (connected to VCC)
- * to enter AT mode:
- * - set pin 34 high when powering up, the LED will blink slowly, the baudrate will be 38400, bluetooth will be off
- * - set pin 34 high after powering up, the LED will keep blinking fast, the baudrate is user defined (AT+UART), bluetooth communication will keep working
- * setting pin 34 low after setting it high will put it into mini AT mode, except when bluetooth is not connected
- * when booting normally (fast blinking LED), the module will not respond to AT commands before setting pin 34 high
- * connect pin 34 to a STM32 GPIO to be able to go into AT mode */
-#define AT_PORT GPIOB
-#define AT_RCC RCC_GPIOB
-#define AT_PIN GPIO5
-
-/* input and output ring buffer, indexes, and available memory */
-static uint8_t rx_buffer[BT_BUFFER] = {0};
-static volatile uint8_t rx_i = 0;
-static volatile uint8_t rx_used = 0;
-static uint8_t tx_buffer[BT_BUFFER] = {0};
-static volatile uint8_t tx_i = 0;
-static volatile uint8_t tx_used = 0;
-/* show the user how much data received over bluetooth is ready */
-volatile uint8_t bt_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
-
-/* display configuration of bluetooth module */
-void bt_info(void)
-{
- char* at_commands[] = {"AT+VERSION?","AT+ADDR?","AT+ROLE?","AT+UART?","AT+CMODE?","AT+STATE?","AT+NAME?"};
- char* ok = "OK\r\n";
- gpio_set(AT_PORT, AT_PIN); // enable AT mode
- for (uint8_t i=0; i=sizeof(tx_buffer)) { // idle until buffer has some space
- usart_enable_tx_interrupt(USART); // enable transmit interrupt
- __WFI(); // sleep until something happened
- }
- tx_buffer[(tx_i+tx_used)%sizeof(tx_buffer)] = c; // put character in buffer
- tx_used++; // update used buffer
- usart_enable_tx_interrupt(USART); // enable transmit interrupt
-}
-
-#if (USART==USART1)
-void usart1_isr(void)
-#elif (USART==USART2)
-void usart2_isr(void)
-#elif (USART==USART3)
-void usart3_isr(void)
-#endif
-{ // USART interrupt
- if (usart_get_interrupt_source(USART, USART_SR_TXE)) { // data has been transmitted
- if (!tx_used) { // no data in the buffer to transmit
- usart_disable_tx_interrupt(USART); // disable transmit interrupt
- } else {
- usart_send(USART,tx_buffer[tx_i]); // put data in transmit register
- tx_i = (tx_i+1)%sizeof(rx_buffer); // update location on buffer
- tx_used--; // update used size
- }
- }
- if (usart_get_interrupt_source(USART, USART_SR_RXNE)) { // data has been received
- // only save data if there is space in the buffer
- if (rx_used>=sizeof(rx_buffer)) {
- usart_recv(USART); // read to clear interrupt
- } else {
- rx_buffer[(rx_i+rx_used)%sizeof(rx_buffer)] = usart_recv(USART); // put character in buffer
- rx_used++; // update used buffer
- bt_received = rx_used; // update available data
- }
- }
-}
diff --git a/lib/bluetooth_hc-05.h b/lib/bluetooth_hc-05.h
deleted file mode 100644
index a4d8fc7..0000000
--- a/lib/bluetooth_hc-05.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library handles the communication with a HC-05 bluetooth module */
-/* peripherals used: USART (check source for details) */
-#pragma once
-
-/* RX and TX buffer sizes */
-#define BT_BUFFER 128
-/* show the user how much received is available */
-extern volatile uint8_t bt_received;
-
-/* display configuration of bluetooth module */
-void bt_info(void);
-/* setup communication to bluetooth module */
-void bt_setup(void);
-/* send character over bluetooth (blocking) */
-void bt_putchar_blocking(char c);
-/* ensure all data has been transmitted (blocking) */
-void bt_flush(void);
-/* get character received over bluetooth (blocking) */
-char bt_getchar(void);
-/* send character over bluetooth (non-blocking until buffer is full) */
-void bt_putchar_nonblocking(char c);
diff --git a/lib/flash_storage.c b/lib/flash_storage.c
deleted file mode 100644
index b7df97e..0000000
--- a/lib/flash_storage.c
+++ /dev/null
@@ -1,113 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library is used to store (read and write) data in flash */
-/* peripherals used: none */
-
-/* standard libraries */
-#include // standard integer types
-#include // general utilities
-
-/* STM32 (including CM3) libraries */
-#include // device signature utilities
-#include // flash utilities
-
-#include "flash_storage.h" // flash storage library API
-#include "global.h" // global definitions
-
-// the flash page size (medium-density devices have 1KiB page size)
-#define PAGE_SIZE 1024
-
-/* read data from address into
- * returns if read succeeded */
-bool storage_read(uint32_t address, uint8_t *buffer, size_t size)
-{
- // verify it's in the storage area
- if (addressSTORAGE_END) {
- return false;
- }
- if (buffer==NULL || size==0) {
- return false;
- }
-
- // copy data byte per byte
- // a more efficient way would be to copy words, than the remaining bytes
- for (size_t i=0; i data from to address
- * returns if write succeeded */
-bool storage_write(uint32_t address, uint8_t *buffer, size_t size)
-{
- // verify it's in the storage area
- if (addressSTORAGE_END) {
- return false;
- }
- if (buffer==NULL || size==0) {
- return false;
- }
-
- uint8_t page[PAGE_SIZE]; // the complete page to write
-
- flash_unlock(); // unlock flash to be able to write it
- // go through memory
- while (size) {
- uint32_t page_pre = address%PAGE_SIZE; // the beginning data size in the page
- address -= page_pre; // go to beginning of the page
- storage_read(address, &page[0], page_pre); // copy existing data
- if (size>=PAGE_SIZE-page_pre) { // no need to read tailing page data
- for (uint16_t i=0; i.
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library is used to store (read and write) data in flash */
-/* peripherals used: none */
-#include // device signature utilities
-
-// how much data (in bytes) should we be able to store (be sure it's available and does not overlap the firmware)
-#define STORAGE_SIZE 2048
-// the end of the flash area where to store data
-#define STORAGE_END FLASH_BASE+DESIG_FLASH_SIZE
-// the start of the flash area where to store data (be sure it's after the firmware data)
-// we will only use the last kilobytes
-#define STORAGE_START STORAGE_END-STORAGE_SIZE
-
-/* read data from address into
- * returns if read succeeded */
-bool storage_read(uint32_t address, uint8_t *buffer, size_t size);
-/* write data from to address
- * returns if write succeeded */
-bool storage_write(uint32_t address, uint8_t *buffer, size_t size);
diff --git a/lib/usart_ir.c b/lib/usart_ir.c
deleted file mode 100644
index 68859dd..0000000
--- a/lib/usart_ir.c
+++ /dev/null
@@ -1,175 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library handles USART communication over pulse coded InfraRed transmission */
-/* peripherals used: USART, timer (check source for details) */
-
-/* standard libraries */
-#include // standard integer types
-#include // standard I/O facilities
-#include // general utilities
-
-/* STM32 (including CM3) libraries */
-#include // real-time control clock library
-#include // general purpose input output library
-#include // universal synchronous asynchronous receiver transmitter library
-#include // timer library
-#include // interrupt handler
-#include // Cortex M3 utilities
-
-#include "usart_ir.h" // USART InfraRed header and definitions
-
-/* which USART to use */
-#define USART USART3
-#define USART_RCC RCC_USART3
-#define USART_IRQ NVIC_USART3_IRQ
-#define USART_PORT GPIOB
-#define USART_PIN_TX GPIO_USART3_TX
-#define USART_PIN_RX GPIO_USART3_RX
-
-/* which timer to use to create PWM for IR modulation */
-#define TIMER TIM2
-#define TIMER_RCC RCC_TIM2
-#define TIMER_OC TIM_OC2
-#define TIMER_PORT GPIOA
-#define TIMER_PORT_RCC RCC_GPIOA
-#define TIMER_PIN GPIO_TIM2_CH2
-
-#define USART_BAUDRATE 2400 // serial baudrate (in bits per second, with 8N1 configuration)
-#define USART_BUFFER 128 // RX and TX buffer sizes
-#define IR_MODULATION 38000 // infra-red modulation frequency
-
-/* input and output ring buffer, indexes, and available memory */
-static uint8_t rx_buffer[USART_BUFFER] = {0};
-static volatile uint8_t rx_i = 0;
-static volatile uint8_t rx_used = 0;
-static uint8_t tx_buffer[USART_BUFFER] = {0};
-static volatile uint8_t tx_i = 0;
-static volatile uint8_t tx_used = 0;
-/* show the user how much data received over USART is ready */
-volatile uint8_t usart_ir_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
-
-/* setup USART/IR peripheral */
-void usart_ir_setup(void)
-{
- /* setup timer to generate infra-red pulse modulation (using PWM) */
- rcc_periph_clock_enable(TIMER_PORT_RCC); // enable clock for GPIO peripheral
- gpio_set_mode(TIMER_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, TIMER_PIN); // set pin a output
- rcc_periph_clock_enable(RCC_AFIO); // enable clock for alternate function (PWM)
- rcc_periph_clock_enable(TIMER_RCC); // enable clock for timer peripheral
- timer_reset(TIMER); // reset timer state
- timer_set_mode(TIMER, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
- timer_set_prescaler(TIMER, 0); // no pre-scaler to keep most precise timer (72MHz/2^16=1099Hz)
- timer_set_period(TIMER, rcc_ahb_frequency/IR_MODULATION-1+15); // set the infra-red modulation frequency (plus hand tuning)
- timer_set_oc_value(TIMER, TIMER_OC, rcc_ahb_frequency/IR_MODULATION/2-1); // duty cycle to 50%
- timer_set_oc_mode(TIMER, TIMER_OC, TIM_OCM_PWM1); // set timer to generate PWM
- timer_enable_oc_output(TIMER, TIMER_OC); // enable output to provide the modulation
- timer_enable_counter(TIMER); // start timer to generate modulation
-
- /* enable USART I/O peripheral */
- rcc_periph_clock_enable(USART_RCC); // enable clock for USART peripheral
- gpio_set_mode(USART_PORT, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, USART_PIN_TX); // setup GPIO pin USART transmit
- gpio_set_mode(USART_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, USART_PIN_RX); // setup GPIO pin USART receive
- gpio_set(USART_PORT, USART_PIN_RX); // pull up to avoid noise when not connected
-
- /* setup UART parameters */
- usart_set_baudrate(USART, USART_BAUDRATE);
- usart_set_databits(USART, 8);
- usart_set_stopbits(USART, USART_STOPBITS_1);
- usart_set_mode(USART, USART_MODE_TX_RX);
- usart_set_parity(USART, USART_PARITY_NONE);
- usart_set_flow_control(USART, USART_FLOWCONTROL_NONE);
-
- nvic_enable_irq(USART_IRQ); // enable the USART interrupt
- usart_enable_rx_interrupt(USART); // enable receive interrupt
- usart_enable(USART); // enable USART
-
- /* reset buffer states */
- tx_i = 0;
- tx_used = 0;
- rx_i = 0;
- rx_used = 0;
- usart_ir_received = 0;
-}
-
-/* put character on USART/IR (blocking) */
-void usart_ir_putchar_blocking(char c)
-{
- usart_ir_flush(); // empty buffer first
- usart_send_blocking(USART, c); // send character
-}
-
-/* ensure all data has been transmitted (blocking) */
-void usart_ir_flush(void)
-{
- while (tx_used) { // idle until buffer is empty
- __WFI(); // sleep until interrupt
- }
- usart_wait_send_ready(USART); // wait until transmit register is empty (transmission might not be complete)
-}
-
-/* get character from USART/IR (blocking) */
-char usart_ir_getchar(void)
-{
- while (!rx_used) { // idle until data is available
- __WFI(); // sleep until interrupt;
- }
- char to_return = rx_buffer[rx_i]; // get the next available character
- rx_i = (rx_i+1)%sizeof(rx_buffer); // update used buffer
- rx_used--; // update used buffer
- usart_ir_received = rx_used; // update available data
- return to_return;
-}
-
-/* put character on USART/IR (non-blocking until buffer is full) */
-void usart_ir_putchar_nonblocking(char c)
-{
- while (tx_used>=sizeof(tx_buffer)) { // idle until buffer has some space
- usart_enable_tx_interrupt(USART); // enable transmit interrupt
- __WFI(); // sleep until something happened
- }
- tx_buffer[(tx_i+tx_used)%sizeof(tx_buffer)] = c; // put character in buffer
- tx_used++; // update used buffer
- usart_enable_tx_interrupt(USART); // enable transmit interrupt
-}
-
-#if (USART==USART1)
-void usart1_isr(void)
-#elif (USART==USART2)
-void usart2_isr(void)
-#elif (USART==USART3)
-void usart3_isr(void)
-#endif
-{ // USART interrupt
- if (usart_get_interrupt_source(USART, USART_SR_TXE)) { // data has been transmitted
- if (!tx_used) { // no data in the buffer to transmit
- usart_disable_tx_interrupt(USART); // disable transmit interrupt
- } else {
- usart_send(USART,tx_buffer[tx_i]); // put data in transmit register
- tx_i = (tx_i+1)%sizeof(rx_buffer); // update location on buffer
- tx_used--; // update used size
- }
- }
- if (usart_get_interrupt_source(USART, USART_SR_RXNE)) { // data has been received
- // only save data if there is space in the buffer
- if (rx_used>=sizeof(rx_buffer)) {
- usart_recv(USART); // read to clear interrupt
- } else {
- rx_buffer[(rx_i+rx_used)%sizeof(rx_buffer)] = usart_recv(USART); // put character in buffer
- rx_used++; // update used buffer
- usart_ir_received = rx_used; // update available data
- }
- }
-}
diff --git a/lib/usart_ir.h b/lib/usart_ir.h
deleted file mode 100644
index 59bd915..0000000
--- a/lib/usart_ir.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library handles USART communication over pulse coded InfraRed transmission */
-/* peripherals used: USART, timer (check source for details) */
-#pragma once
-
-/* show the user how much data has been received and is available */
-extern volatile uint8_t usart_ir_received;
-
-/* setup USART/IR peripheral */
-void usart_ir_setup(void);
-/* put character on USART/IR (blocking) */
-void usart_ir_putchar_blocking(char c);
-/* ensure all data has been transmitted (blocking) */
-void usart_ir_flush(void);
-/* get character from USART/IR (blocking) */
-char usart_ir_getchar(void);
-/* put character on USART/IR (non-blocking until buffer is full) */
-void usart_ir_putchar_nonblocking(char c);
diff --git a/lib/usart_irda.c b/lib/usart_irda.c
deleted file mode 100644
index ed18def..0000000
--- a/lib/usart_irda.c
+++ /dev/null
@@ -1,152 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library handles IrDA SIR (USART based) communication */
-/* this library handles IrDA communication */
-
-/* standard libraries */
-#include // standard integer types
-#include // standard I/O facilities
-#include // general utilities
-
-/* STM32 (including CM3) libraries */
-#include // real-time control clock library
-#include // general purpose input output library
-#include // universal synchronous asynchronous receiver transmitter library
-#include // interrupt handler
-#include // Cortex M3 utilities
-
-#include "usart_irda.h" // IrDA header and definitions
-
-/* which USART to use for IrDA */
-#define IRDA USART3
-#define IRDA_RCC RCC_USART3
-#define IRDA_IRQ NVIC_USART3_IRQ
-#define IRDA_PORT GPIOB
-#define IRDA_PIN_TX GPIO_USART3_TX
-#define IRDA_PIN_RX GPIO_USART3_RX
-/* serial baudrate, in bits per second (with 8N1 8 bits, no parity bit, 1 stop bit settings) */
-#define IRDA_BAUDRATE 9600
-/* RX and TX buffer sizes */
-#define IRDA_BUFFER 128
-
-/* input and output ring buffer, indexes, and available memory */
-static uint8_t rx_buffer[IRDA_BUFFER] = {0};
-static volatile uint8_t rx_i = 0;
-static volatile uint8_t rx_used = 0;
-static uint8_t tx_buffer[IRDA_BUFFER] = {0};
-static volatile uint8_t tx_i = 0;
-static volatile uint8_t tx_used = 0;
-/* show the user how much data received over IrDA is ready */
-volatile uint8_t irda_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
-
-/* setup IrDA peripheral */
-void irda_setup(void)
-{
- rcc_periph_clock_enable(IRDA_RCC); // enable clock for USART/IrDA block
- gpio_set_mode(IRDA_PORT, GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, IRDA_PIN_TX); // setup GPIO pin USART/IrDA transmit
- gpio_set_mode(IRDA_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, IRDA_PIN_RX); // setup GPIO pin USART/IrDA receive
- gpio_set(IRDA_PORT, IRDA_PIN_RX); // pull up to avoid noise when not connected
-
- /* setup UART/IrDA parameters */
- usart_set_baudrate(IRDA, IRDA_BAUDRATE);
- usart_set_databits(IRDA, 8);
- usart_set_stopbits(IRDA, USART_STOPBITS_1);
- usart_set_mode(IRDA, USART_MODE_TX_RX);
- usart_set_parity(IRDA, USART_PARITY_NONE);
- usart_set_flow_control(IRDA, USART_FLOWCONTROL_NONE);
- USART_CR3(IRDA) |= USART_CR3_IREN; // enable IrDA SIR ENDEC block (using IREN)
-
- nvic_enable_irq(IRDA_IRQ); // enable the USART/IrDA interrupt
- usart_enable_rx_interrupt(IRDA); // enable receive interrupt
- usart_enable(IRDA); // enable USART/IrDA
-
- /* reset buffer states */
- tx_i = 0;
- tx_used = 0;
- rx_i = 0;
- rx_used = 0;
- irda_received = 0;
-}
-
-/* put character on IrDA (blocking) */
-void irda_putchar_blocking(char c)
-{
- irda_flush(); // empty buffer first
- usart_send_blocking(IRDA, c); // send character
-}
-
-/* ensure all data has been transmitted (blocking) */
-void irda_flush(void)
-{
- while (tx_used) { // idle until buffer is empty
- __WFI(); // sleep until interrupt
- }
- usart_wait_send_ready(IRDA); // wait until transmit register is empty (transmission might not be complete)
-}
-
-/* get character from IrDA (blocking) */
-char irda_getchar(void)
-{
- while (!rx_used) { // idle until data is available
- __WFI(); // sleep until interrupt;
- }
- char to_return = rx_buffer[rx_i]; // get the next available character
- rx_i = (rx_i+1)%sizeof(rx_buffer); // update used buffer
- rx_used--; // update used buffer
- irda_received = rx_used; // update available data
- return to_return;
-}
-
-/* put character on IrDA (non-blocking until buffer is full) */
-void irda_putchar_nonblocking(char c)
-{
- while (tx_used>=sizeof(tx_buffer)) { // idle until buffer has some space
- usart_enable_tx_interrupt(IRDA); // enable transmit interrupt
- __WFI(); // sleep until something happened
- }
- tx_buffer[(tx_i+tx_used)%sizeof(tx_buffer)] = c; // put character in buffer
- tx_used++; // update used buffer
- usart_enable_tx_interrupt(IRDA); // enable transmit interrupt
-}
-
-#if (IRDA==USART1)
-void usart1_isr(void)
-#elif (IRDA==USART2)
-void usart2_isr(void)
-#elif (IRDA==USART3)
-void usart3_isr(void)
-#endif
-{ // USART interrupt
- if (usart_get_interrupt_source(IRDA, USART_SR_TXE)) { // data has been transmitted
- if (!tx_used) { // no data in the buffer to transmit
- usart_disable_tx_interrupt(IRDA); // disable transmit interrupt
- } else {
- usart_send(IRDA,tx_buffer[tx_i]); // put data in transmit register
- tx_i = (tx_i+1)%sizeof(rx_buffer); // update location on buffer
- tx_used--; // update used size
- }
- }
- if (usart_get_interrupt_source(IRDA, USART_SR_RXNE)) { // data has been received
- // only save data if there is space in the buffer
- if (rx_used>=sizeof(rx_buffer)) {
- usart_recv(IRDA); // read to clear interrupt
- } else {
- rx_buffer[(rx_i+rx_used)%sizeof(rx_buffer)] = usart_recv(IRDA); // put character in buffer
- rx_used++; // update used buffer
- irda_received = rx_used; // update available data
- }
- }
-}
diff --git a/lib/usart_irda.h b/lib/usart_irda.h
deleted file mode 100644
index b5e1a77..0000000
--- a/lib/usart_irda.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library handles IrDA SIR (USART based) communication */
-/* peripherals used: USART (check source for details) */
-
-/* show the user how much received is available */
-extern volatile uint8_t irda_received;
-
-/* setup IrDA peripheral */
-void irda_setup(void);
-/* put character on IrDA (blocking) */
-void irda_putchar_blocking(char c);
-/* ensure all data has been transmitted (blocking) */
-void irda_flush(void);
-/* get character from IrDA (blocking) */
-char irda_getchar(void);
-/* put character on IrDA (non-blocking until buffer is full) */
-void irda_putchar_nonblocking(char c);
diff --git a/lib/vfd_hv518.c b/lib/vfd_hv518.c
deleted file mode 100644
index 03b9952..0000000
--- a/lib/vfd_hv518.c
+++ /dev/null
@@ -1,523 +0,0 @@
-/* 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, either version 3 of the License, or
- * (at your option) any later version.
- *
- * 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, see .
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library is used to drive the vacuum fluorescent display extracted from a Samsung SER-6500 cash register
- * it uses three chained supertex HV518 shift register VFD drivers */
-
-/* standard libraries */
-#include // standard integer types
-#include // general utilities
-
-/* STM32 (including CM3) libraries */
-#include // real-time control clock library
-#include // general purpose input output library
-#include // SPI library
-#include // timer library
-#include // interrupt handler
-
-#include "global.h" // global definitions
-#include "vfd_hv518.h" // VFD library API
-
-/* supertex HV518 VFD driver pins */
-/* port on which the pins to control the supertex HV518 VFD driver are
- * we use port A because of the SPI interface */
-#define VFD_PORT GPIOA
-#define VFD_PORT_RCC RCC_GPIOA
-/* SPI port to use */
-#define VFD_SPI SPI1
-#if (VFD_SPI==SPI1)
-#define VFD_SPI_RCC RCC_SPI1
-#define VFD_SPI_IRQ NVIC_SPI1_IRQ
-#elif (VFD_SPI==SPI2)
-#define VFD_SPI_RCC RCC_SPI2
-#define VFD_SPI_IRQ NVIC_SPI2_IRQ
-#endif
-/* strobe pin to enable high voltage output
- * high voltage is output on low
- * drive using a GPIO PA6 (normally MISO) */
-#define VFD_STR GPIO6
-/* latch enable pin
- * store the shifted data on low
- * output the parallel data on high
- * use GPIO (PA4) (NSS does not work as SS) */
-#define VFD_NLE GPIO4
-/* clock signal
- * drive using SPI SCK (PA5) */
-#define VFD_CLK GPIO_SPI1_SCK
-/* data input, where the data is shifted to
- * drive using SPI MOSI (PA7) */
-#define VFD_DIN GPIO_SPI1_MOSI
-/* timer for automatic refresh */
-#define VFD_TIMER TIM2
-#if (VFD_TIMER==TIM2)
-#define VFD_TIMER_RCC RCC_TIM2
-#define VFD_TIMER_IRQ NVIC_TIM2_IRQ
-#elif (VFD_TIMER==TIM3)
-#define VFD_TIMER_RCC RCC_TIM3
-#define VFD_TIMER_IRQ NVIC_TIM3_IRQ
-#elif (VFD_TIMER==TIM4)
-#define VFD_TIMER_RCC RCC_TIM4
-#define VFD_TIMER_IRQ NVIC_TIM4_IRQ
-#elif (VFD_TIMER==TIM5)
-#define VFD_TIMER_RCC RCC_TIM5
-#define VFD_TIMER_IRQ NVIC_TIM5_IRQ
-#endif
-
-/* ASCII characters encoded for 7 segments display
- * starts with space
- */
-static const uint8_t ascii_7segments[] = {
- 0b00000000, // space
- 0b00110000, // ! (I)
- 0b00100010, // "
- 0b01011100, // # (o)
- 0b01101101, // $ (s)
- 0b01010010, // % (/)
- 0b01111101, // & (6)
- 0b00100000, // '
- 0b00111001, // ( ([)
- 0b00001111, // )
- 0b01110000, // *
- 0b01000110, // +
- 0b00010000, // ,
- 0b01000000, // -
- 0b00010000, // . (,)
- 0b01010010, // /
- 0b00111111, // 0
- 0b00000110, // 1
- 0b01011011, // 2
- 0b01001111, // 3
- 0b01100110, // 4
- 0b01101101, // 5
- 0b01111101, // 6
- 0b00000111, // 7
- 0b01111111, // 8
- 0b01101111, // 9
- 0b01001000, // : (=)
- 0b01001000, // ; (=)
- 0b01011000, // <
- 0b01001000, // =
- 0b01001100, // >
- 0b01010011, // ?
- 0b01111011, // @
- 0b01110111, // A
- 0b01111111, // B
- 0b00111001, // C
- 0b01011110, // D
- 0b01111001, // E
- 0b01110001, // F
- 0b00111101, // G
- 0b01110110, // H
- 0b00110000, // I
- 0b00011110, // J
- 0b01110110, // K
- 0b00111000, // L
- 0b00110111, // M
- 0b00110111, // N
- 0b00111111, // O
- 0b01110011, // P
- 0b01101011, // Q
- 0b00110011, // R
- 0b01101101, // S
- 0b01111000, // T
- 0b00111110, // U
- 0b00111110, // V (U)
- 0b00111110, // W (U)
- 0b01110110, // X (H)
- 0b01101110, // Y
- 0b01011011, // Z
- 0b00111001, // [
- 0b01100100, // '\'
- 0b00001111, // /
- 0b00100011, // ^
- 0b00001000, // _
- 0b00000010, // `
- 0b01011111, // a
- 0b01111100, // b
- 0b01011000, // c
- 0b01011110, // d
- 0b01111011, // e
- 0b01110001, // f
- 0b01101111, // g
- 0b01110100, // h
- 0b00010000, // i
- 0b00001100, // j
- 0b01110110, // k
- 0b00110000, // l
- 0b01010100, // m
- 0b01010100, // n
- 0b01011100, // o
- 0b01110011, // p
- 0b01100111, // q
- 0b01010000, // r
- 0b01101101, // s
- 0b01111000, // t
- 0b00011100, // u
- 0b00011100, // v (u)
- 0b00011100, // w (u)
- 0b01110110, // x
- 0b01101110, // y
- 0b01011011, // z
- 0b00111001, // { ([)
- 0b00110000, // |
- 0b00001111, // } ([)
- 0b01000000, // ~
-};
-
-/* font for the 5x7 dot matrix display
- * from http://sunge.awardspace.com/glcd-sd/node4.html
- * first value is left-most line
- * LSB is top dot, MSB is not used
- */
-static const uint8_t font5x7[][5] = {
- {0x00, 0x00, 0x00, 0x00, 0x00}, // (space)
- {0x00, 0x00, 0x5F, 0x00, 0x00}, // !
- {0x00, 0x07, 0x00, 0x07, 0x00}, // "
- {0x14, 0x7F, 0x14, 0x7F, 0x14}, // #
- {0x24, 0x2A, 0x7F, 0x2A, 0x12}, // $
- {0x23, 0x13, 0x08, 0x64, 0x62}, // %
- {0x36, 0x49, 0x55, 0x22, 0x50}, // &
- {0x00, 0x05, 0x03, 0x00, 0x00}, // '
- {0x00, 0x1C, 0x22, 0x41, 0x00}, // (
- {0x00, 0x41, 0x22, 0x1C, 0x00}, // )
- {0x08, 0x2A, 0x1C, 0x2A, 0x08}, // *
- {0x08, 0x08, 0x3E, 0x08, 0x08}, // +
- {0x00, 0x50, 0x30, 0x00, 0x00}, // ,
- {0x08, 0x08, 0x08, 0x08, 0x08}, // -
- {0x00, 0x60, 0x60, 0x00, 0x00}, // .
- {0x20, 0x10, 0x08, 0x04, 0x02}, // /
- {0x3E, 0x51, 0x49, 0x45, 0x3E}, // 0
- {0x00, 0x42, 0x7F, 0x40, 0x00}, // 1
- {0x42, 0x61, 0x51, 0x49, 0x46}, // 2
- {0x21, 0x41, 0x45, 0x4B, 0x31}, // 3
- {0x18, 0x14, 0x12, 0x7F, 0x10}, // 4
- {0x27, 0x45, 0x45, 0x45, 0x39}, // 5
- {0x3C, 0x4A, 0x49, 0x49, 0x30}, // 6
- {0x01, 0x71, 0x09, 0x05, 0x03}, // 7
- {0x36, 0x49, 0x49, 0x49, 0x36}, // 8
- {0x06, 0x49, 0x49, 0x29, 0x1E}, // 9
- {0x00, 0x36, 0x36, 0x00, 0x00}, // :
- {0x00, 0x56, 0x36, 0x00, 0x00}, // ;
- {0x00, 0x08, 0x14, 0x22, 0x41}, // <
- {0x14, 0x14, 0x14, 0x14, 0x14}, // =
- {0x41, 0x22, 0x14, 0x08, 0x00}, // >
- {0x02, 0x01, 0x51, 0x09, 0x06}, // ?
- {0x32, 0x49, 0x79, 0x41, 0x3E}, // @
- {0x7E, 0x11, 0x11, 0x11, 0x7E}, // A
- {0x7F, 0x49, 0x49, 0x49, 0x36}, // B
- {0x3E, 0x41, 0x41, 0x41, 0x22}, // C
- {0x7F, 0x41, 0x41, 0x22, 0x1C}, // D
- {0x7F, 0x49, 0x49, 0x49, 0x41}, // E
- {0x7F, 0x09, 0x09, 0x01, 0x01}, // F
- {0x3E, 0x41, 0x41, 0x51, 0x32}, // G
- {0x7F, 0x08, 0x08, 0x08, 0x7F}, // H
- {0x00, 0x41, 0x7F, 0x41, 0x00}, // I
- {0x20, 0x40, 0x41, 0x3F, 0x01}, // J
- {0x7F, 0x08, 0x14, 0x22, 0x41}, // K
- {0x7F, 0x40, 0x40, 0x40, 0x40}, // L
- {0x7F, 0x02, 0x04, 0x02, 0x7F}, // M
- {0x7F, 0x04, 0x08, 0x10, 0x7F}, // N
- {0x3E, 0x41, 0x41, 0x41, 0x3E}, // O
- {0x7F, 0x09, 0x09, 0x09, 0x06}, // P
- {0x3E, 0x41, 0x51, 0x21, 0x5E}, // Q
- {0x7F, 0x09, 0x19, 0x29, 0x46}, // R
- {0x46, 0x49, 0x49, 0x49, 0x31}, // S
- {0x01, 0x01, 0x7F, 0x01, 0x01}, // T
- {0x3F, 0x40, 0x40, 0x40, 0x3F}, // U
- {0x1F, 0x20, 0x40, 0x20, 0x1F}, // V
- {0x7F, 0x20, 0x18, 0x20, 0x7F}, // W
- {0x63, 0x14, 0x08, 0x14, 0x63}, // X
- {0x03, 0x04, 0x78, 0x04, 0x03}, // Y
- {0x61, 0x51, 0x49, 0x45, 0x43}, // Z
- {0x00, 0x00, 0x7F, 0x41, 0x41}, // [
- {0x02, 0x04, 0x08, 0x10, 0x20}, // '\'
- {0x41, 0x41, 0x7F, 0x00, 0x00}, // ]
- {0x04, 0x02, 0x01, 0x02, 0x04}, // ^
- {0x40, 0x40, 0x40, 0x40, 0x40}, // _
- {0x00, 0x01, 0x02, 0x04, 0x00}, // `
- {0x20, 0x54, 0x54, 0x54, 0x78}, // a
- {0x7F, 0x48, 0x44, 0x44, 0x38}, // b
- {0x38, 0x44, 0x44, 0x44, 0x20}, // c
- {0x38, 0x44, 0x44, 0x48, 0x7F}, // d
- {0x38, 0x54, 0x54, 0x54, 0x18}, // e
- {0x08, 0x7E, 0x09, 0x01, 0x02}, // f
- {0x08, 0x14, 0x54, 0x54, 0x3C}, // g
- {0x7F, 0x08, 0x04, 0x04, 0x78}, // h
- {0x00, 0x44, 0x7D, 0x40, 0x00}, // i
- {0x20, 0x40, 0x44, 0x3D, 0x00}, // j
- {0x00, 0x7F, 0x10, 0x28, 0x44}, // k
- {0x00, 0x41, 0x7F, 0x40, 0x00}, // l
- {0x7C, 0x04, 0x18, 0x04, 0x78}, // m
- {0x7C, 0x08, 0x04, 0x04, 0x78}, // n
- {0x38, 0x44, 0x44, 0x44, 0x38}, // o
- {0x7C, 0x14, 0x14, 0x14, 0x08}, // p
- {0x08, 0x14, 0x14, 0x18, 0x7C}, // q
- {0x7C, 0x08, 0x04, 0x04, 0x08}, // r
- {0x48, 0x54, 0x54, 0x54, 0x20}, // s
- {0x04, 0x3F, 0x44, 0x40, 0x20}, // t
- {0x3C, 0x40, 0x40, 0x20, 0x7C}, // u
- {0x1C, 0x20, 0x40, 0x20, 0x1C}, // v
- {0x3C, 0x40, 0x30, 0x40, 0x3C}, // w
- {0x44, 0x28, 0x10, 0x28, 0x44}, // x
- {0x0C, 0x50, 0x50, 0x50, 0x3C}, // y
- {0x44, 0x64, 0x54, 0x4C, 0x44}, // z
- {0x00, 0x08, 0x36, 0x41, 0x00}, // {
- {0x00, 0x00, 0x7F, 0x00, 0x00}, // |
- {0x00, 0x41, 0x36, 0x08, 0x00}, // }
- {0b00001000, 0b00000100, 0b00001100, 0b00001000, 0b00000100} // ~
-};
-
-/* pictures for the 5x7 dot matrix display
- * first value is left-most line
- * LSB is top dot, MSB is not used
- */
-static const uint8_t pict5x7[][5] = {
- {0x08, 0x08, 0x2A, 0x1C, 0x08}, // ->
- {0x08, 0x1C, 0x2A, 0x08, 0x08}, // <-
- {0b01110000, 0b01110000, 0b01111010, 0b01111100, 0b01011000}, // bunny side 1
- {0b00100000, 0b01110000, 0b01110010, 0b01111100, 0b01011000}, // bunny side 2
- {0b00111110, 0b01001001, 0b01010110, 0b01001001, 0b00111110}, // bunny face 1
- {0b00111110, 0b01010001, 0b01100110, 0b01010001, 0b00111110}, // bunny face 2
- {0b00111000, 0b01010111, 0b01100100, 0b01010111, 0b00111000}, // bunny face 3
- {0b00111000, 0b01001111, 0b01010100, 0b01001111, 0b00111000}, // bunny face 4
- {0b00111000, 0b01011110, 0b01101000, 0b01011110, 0b00111000}, // bunny face 5
- {0b01000001, 0b00110110, 0b00001000, 0b00110110, 0b01000001}, // cross 1
- {~0b01000001, ~0b00110110, ~0b00001000, ~0b00110110, ~0b01000001}, // cross 1 negated
- {0b00100010, 0b00010100, 0b00001000, 0b00010100, 0b00100010}, // cross 2
- {~0b00100010, ~0b00010100, ~0b00001000, ~0b00010100, ~0b00100010}, // cross 2 negated
- {0x00, 0x00, 0x00, 0x00, 0x00} // nothing
-};
-
-/* the 32 bits values to be shifted out to the VFD driver
- * split into 16 bit for SPI transfer
- * since the bits for digits and matrix are independent, they can be combined
- * we have more matrix (12) than digits (10)
- */
-static uint16_t driver_data[VFD_MATRIX][VFD_DRIVERS*2] = {0};
-static volatile uint8_t spi_i = 0; // which driver data is being transmitted
-static volatile uint8_t vfd_grid = 0; // which grid/part to activate (single digits and matrix can be combined)
-static const uint32_t digit_mask = 0x00fffff0; // the bits used for selecting then digit and 7 segment anodes (for the second driver)
-
-/* set digit to ASCII character
- * use the MSB of to enable the dot */
-void vfd_digit(uint8_t nb, char c)
-{
- if (!(nb=' ') { // only take printable characters
- uint8_t i = c-' '; // get index for character
- if (i>16); // write back data (most significant half)
-}
-
-/* set dot matrix to ASCII character
- * non ASCII characters are used for pictures */
-void vfd_matrix(uint8_t nb, char c)
-{
- // check the matrix exists
- if (!(nb=' ')) { // only take printable characters
- uint8_t i = c-' '; // get index for character
- if (i0x7f) { // the non ASCII character are used for pictures
- uint8_t i = c-0x80; // get index for character
- if (i>16;
- }
-}
-
-/* clear VFD display */
-void vfd_clear(void)
-{
- for (uint8_t i=0; i.
- *
- */
-/* Copyright (c) 2016 King Kévin */
-/* this library is used to drive the vacuum fluorescent display extracted from a Samsung SER-6500 cash register
- * it uses three chained supertex HV518 shift register VFD drivers */
-
-/* the number of blocks available on the VFD */
-#define VFD_DRIVERS 3
-#define VFD_DIGITS 10
-#define VFD_MATRIX 12
-
-/* set digit to ASCII character
- * use the MSB of to enable the dot */
-void vfd_digit(uint8_t nb, char c);
-/* set dot matrix to ASCII character
- * non ASCII characters are used for pictures */
-void vfd_matrix(uint8_t nb, char c);
-/* clear VFD display */
-void vfd_clear(void);
-/* test VFD display (light up all anodes) */
-void vfd_test(void);
-/* transmit every digit and matrix */
-void vfd_on(void);
-/* switch VFD display off */
-void vfd_off(void);
-/* setup VFD */
-void vfd_setup(void);