236 lines
10 KiB
C
236 lines
10 KiB
C
/* 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
|
|
}
|
|
}
|
|
}
|