remove trivial incomplete library
This commit is contained in:
parent
a51d127733
commit
54d8f82353
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
|
||||
/* this library handles the communication with a HC-05 bluetooth module */
|
||||
/* peripherals used: USART (check source for details) */
|
||||
|
||||
/* standard libraries */
|
||||
#include <stdint.h> // standard integer types
|
||||
#include <stdio.h> // standard I/O facilities
|
||||
#include <stdlib.h> // general utilities
|
||||
#include <string.h> // string utilities
|
||||
|
||||
/* STM32 (including CM3) libraries */
|
||||
#include <libopencm3/stm32/rcc.h> // real-time control clock library
|
||||
#include <libopencm3/stm32/gpio.h> // general purpose input output library
|
||||
#include <libopencm3/stm32/usart.h> // universal synchronous asynchronous receiver transmitter library
|
||||
#include <libopencm3/cm3/nvic.h> // interrupt handler
|
||||
#include <libopencmsis/core_cm3.h> // 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<LENGTH(at_commands); i++) { // go through commands
|
||||
for (uint8_t j=0; j<strlen(at_commands[i]); j++) { // send command
|
||||
bt_putchar_nonblocking(at_commands[i][j]); // send character
|
||||
}
|
||||
bt_putchar_nonblocking('\r'); // send end of AT command
|
||||
bt_putchar_nonblocking('\n'); // send end of AT command
|
||||
uint8_t ok_i = 0; // how much of the ok sequence has been detected
|
||||
while (ok_i<strlen(ok)) { // print until OK has been received
|
||||
char c = bt_getchar(); // received character
|
||||
printf("%c",c); // print received character
|
||||
if (ok_i<strlen(ok) && c==ok[ok_i]) {
|
||||
ok_i++;
|
||||
} else {
|
||||
ok_i = 0;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
gpio_clear(AT_PORT, AT_PIN); // disable AT mode
|
||||
}
|
||||
|
||||
/* setup communication to bluetooth module */
|
||||
void bt_setup(void)
|
||||
{
|
||||
rcc_periph_clock_enable(USART_RCC); // enable USART clock
|
||||
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 part */
|
||||
rcc_periph_clock_enable(USART_RCC); // enable clock for USART block
|
||||
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
|
||||
usart_set_baudrate(USART, 9600); // set baudrate
|
||||
usart_set_databits(USART, 8); // set data width (most common: 8 bits)
|
||||
usart_set_stopbits(USART, USART_STOPBITS_1); // set stop bit (most common: 1 bit)
|
||||
usart_set_parity(USART, USART_PARITY_NONE); // set parity (most common: none)
|
||||
usart_set_mode(USART, USART_MODE_TX_RX); // enable USART to receive and transmit
|
||||
usart_set_flow_control(USART, USART_FLOWCONTROL_NONE); // no hardware flow control
|
||||
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;
|
||||
bt_received = 0;
|
||||
|
||||
/* configure AT mode pin */
|
||||
rcc_periph_clock_enable(AT_RCC); // enable clock for GPIO block
|
||||
gpio_set_mode(AT_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, AT_PIN); // set pin to control AT mode
|
||||
|
||||
/* configure HC-05 bluetooth module */
|
||||
gpio_set(AT_PORT, AT_PIN); // enable AT mode
|
||||
bool responded = false; // did the mode respond to AT command
|
||||
uint32_t baudrates[] = {115200, 38400, 9600, 57600, 19200}; // possible baudrate (order by preference)
|
||||
uint8_t baudrate_i = 0; // the detected baudrate
|
||||
for (baudrate_i = 0; baudrate_i<LENGTH(baudrates) && !responded; baudrate_i++) { // find module baudrate
|
||||
usart_set_baudrate(USART, baudrates[baudrate_i]); // set baudrate to test
|
||||
usart_send_blocking(USART, 'A'); // send AT command to test if it responded
|
||||
usart_send_blocking(USART, 'T'); // send AT command to test if it responded
|
||||
usart_send_blocking(USART, '\r'); // send AT command to test if it responded
|
||||
usart_send_blocking(USART, '\n'); // send AT command to test if it responded
|
||||
for (uint32_t i = 0; i<0xc0000; i++) { // wait 30ms for response (empiric value)
|
||||
__asm__("nop");
|
||||
}
|
||||
if ((rx_used==4 && bt_getchar()=='O' && bt_getchar()=='K' && bt_getchar()=='\r' && bt_getchar()=='\n') || (rx_used==11 && bt_getchar()=='E' && bt_getchar()=='R' && bt_getchar()=='R' && bt_getchar()=='O' && bt_getchar()=='R' && bt_getchar()==':' && bt_getchar()=='(' && bt_getchar()=='0' && bt_getchar()==')' && bt_getchar()=='\r' && bt_getchar()=='\n')) {
|
||||
responded = true; // seems we found the right baudrate since it responded
|
||||
}
|
||||
// reset buffer states
|
||||
rx_i = 0;
|
||||
rx_used = 0;
|
||||
}
|
||||
gpio_clear(AT_PORT, AT_PIN); // disable AT mode
|
||||
if (responded) {
|
||||
printf("baudrate: %lubps\n",baudrates[--baudrate_i]);
|
||||
gpio_clear(AT_PORT, AT_PIN);
|
||||
} else {
|
||||
printf("couldn't find baudrate\n");
|
||||
}
|
||||
//usart_set_baudrate(USART, USART_BAUDRATE); // set final baudrate
|
||||
|
||||
bt_info();
|
||||
|
||||
}
|
||||
|
||||
/* send character over bluetooth (blocking) */
|
||||
void bt_putchar_blocking(char c)
|
||||
{
|
||||
bt_flush(); // empty buffer first
|
||||
usart_send_blocking(USART, c); // send character
|
||||
}
|
||||
|
||||
/* ensure all data has been transmitted (blocking) */
|
||||
void bt_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 received over bluetooth (blocking) */
|
||||
char bt_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
|
||||
bt_received = rx_used; // update available data
|
||||
return to_return;
|
||||
}
|
||||
|
||||
/* send character over bluetooth (non-blocking until buffer is full) */
|
||||
void bt_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
|
||||
bt_received = rx_used; // update available data
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
|
||||
/* 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);
|
||||
175
lib/usart_ir.c
175
lib/usart_ir.c
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
|
||||
/* this library handles USART communication over pulse coded InfraRed transmission */
|
||||
/* peripherals used: USART, timer (check source for details) */
|
||||
|
||||
/* standard libraries */
|
||||
#include <stdint.h> // standard integer types
|
||||
#include <stdio.h> // standard I/O facilities
|
||||
#include <stdlib.h> // general utilities
|
||||
|
||||
/* STM32 (including CM3) libraries */
|
||||
#include <libopencm3/stm32/rcc.h> // real-time control clock library
|
||||
#include <libopencm3/stm32/gpio.h> // general purpose input output library
|
||||
#include <libopencm3/stm32/usart.h> // universal synchronous asynchronous receiver transmitter library
|
||||
#include <libopencm3/stm32/timer.h> // timer library
|
||||
#include <libopencm3/cm3/nvic.h> // interrupt handler
|
||||
#include <libopencmsis/core_cm3.h> // 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
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
|
||||
/* 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);
|
||||
152
lib/usart_irda.c
152
lib/usart_irda.c
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
|
||||
/* this library handles IrDA SIR (USART based) communication */
|
||||
/* this library handles IrDA communication */
|
||||
|
||||
/* standard libraries */
|
||||
#include <stdint.h> // standard integer types
|
||||
#include <stdio.h> // standard I/O facilities
|
||||
#include <stdlib.h> // general utilities
|
||||
|
||||
/* STM32 (including CM3) libraries */
|
||||
#include <libopencm3/stm32/rcc.h> // real-time control clock library
|
||||
#include <libopencm3/stm32/gpio.h> // general purpose input output library
|
||||
#include <libopencm3/stm32/usart.h> // universal synchronous asynchronous receiver transmitter library
|
||||
#include <libopencm3/cm3/nvic.h> // interrupt handler
|
||||
#include <libopencmsis/core_cm3.h> // 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
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
|
||||
/* 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);
|
||||
Loading…
Reference in New Issue
Block a user