mirror of
https://github.com/esp8266/Arduino.git
synced 2025-07-11 15:22:13 +03:00
Move UART HAL into separate file, clean up code
This commit is contained in:
Ivan Grokhotkov
@ -28,390 +28,71 @@
|
||||
#include <string.h>
|
||||
#include <inttypes.h>
|
||||
#include "Arduino.h"
|
||||
#include "cbuf.h"
|
||||
#include "interrupts.h"
|
||||
|
||||
extern "C" {
|
||||
#include "osapi.h"
|
||||
#include "ets_sys.h"
|
||||
#include "mem.h"
|
||||
#include "user_interface.h"
|
||||
}
|
||||
|
||||
#include "HardwareSerial.h"
|
||||
|
||||
#define UART_TX_FIFO_SIZE 0x80
|
||||
|
||||
struct uart_ {
|
||||
int uart_nr;
|
||||
int baud_rate;
|
||||
bool rxEnabled;
|
||||
bool txEnabled;
|
||||
uint8_t rxPin;
|
||||
uint8_t txPin;
|
||||
};
|
||||
|
||||
static const int UART0 = 0;
|
||||
static const int UART1 = 1;
|
||||
static const int UART_NO = -1;
|
||||
|
||||
|
||||
/**
|
||||
* UART GPIOs
|
||||
*
|
||||
* UART0 TX: 1 or 2
|
||||
* UART0 RX: 3
|
||||
*
|
||||
* UART0 SWAP TX: 15
|
||||
* UART0 SWAP RX: 13
|
||||
*
|
||||
*
|
||||
* UART1 TX: 7 (NC) or 2
|
||||
* UART1 RX: 8 (NC)
|
||||
*
|
||||
* UART1 SWAP TX: 11 (NC)
|
||||
* UART1 SWAP RX: 6 (NC)
|
||||
*
|
||||
* NC = Not Connected to Module Pads --> No Access
|
||||
*
|
||||
*/
|
||||
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
HardwareSerial Serial(UART0);
|
||||
HardwareSerial Serial1(UART1);
|
||||
|
||||
|
||||
void uart_write_char(uart_t* uart, char c) {
|
||||
if(uart == 0 || !uart->txEnabled)
|
||||
return;
|
||||
while((USS(uart->uart_nr) >> USTXC) >= 0x7f);
|
||||
USF(uart->uart_nr) = c;
|
||||
}
|
||||
|
||||
void uart_write(uart_t* uart, const char* buf, size_t size) {
|
||||
if(uart == 0 || !uart->txEnabled)
|
||||
return;
|
||||
while(size--)
|
||||
uart_write_char(uart, *buf++);
|
||||
}
|
||||
|
||||
uint8_t uart_read_char(uart_t* uart){
|
||||
if(uart == 0 || !uart->rxEnabled)
|
||||
return 0;
|
||||
return USF(uart->uart_nr) & 0xff;
|
||||
}
|
||||
|
||||
uint8_t uart_rx_available(uart_t* uart){
|
||||
if(uart == 0 || !uart->rxEnabled)
|
||||
return 0;
|
||||
return (USS(uart->uart_nr) >> USRXC) & 0xff;
|
||||
}
|
||||
|
||||
uint8_t uart_tx_free(uart_t* uart){
|
||||
if(uart == 0 || !uart->txEnabled)
|
||||
return 0;
|
||||
return UART_TX_FIFO_SIZE - ((USS(uart->uart_nr) >> USTXC) & 0xff);
|
||||
}
|
||||
|
||||
void uart_wait_tx_empty(uart_t* uart){
|
||||
if(uart == 0 || !uart->txEnabled)
|
||||
return;
|
||||
while(((USS(uart->uart_nr) >> USTXC) & 0xff) > 0) delay(0);
|
||||
}
|
||||
|
||||
void uart_flush(uart_t* uart) {
|
||||
if(uart == 0)
|
||||
return;
|
||||
|
||||
uint32_t tmp = 0x00000000;
|
||||
if(uart->rxEnabled) {
|
||||
tmp |= (1 << UCRXRST);
|
||||
}
|
||||
|
||||
if(uart->txEnabled) {
|
||||
tmp |= (1 << UCTXRST);
|
||||
}
|
||||
|
||||
USC0(uart->uart_nr) |= (tmp);
|
||||
USC0(uart->uart_nr) &= ~(tmp);
|
||||
}
|
||||
|
||||
void uart_set_baudrate(uart_t* uart, int baud_rate) {
|
||||
if(uart == 0)
|
||||
return;
|
||||
uart->baud_rate = baud_rate;
|
||||
USD(uart->uart_nr) = (ESP8266_CLOCK / uart->baud_rate);
|
||||
}
|
||||
|
||||
int uart_get_baudrate(uart_t* uart) {
|
||||
if(uart == 0)
|
||||
return 0;
|
||||
return uart->baud_rate;
|
||||
}
|
||||
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
|
||||
uart_t* uart_init(int uart_nr, int baudrate, byte config, byte mode, uint8_t use_tx) {
|
||||
|
||||
uart_t* uart = (uart_t*) os_malloc(sizeof(uart_t));
|
||||
|
||||
if(uart == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uart->uart_nr = uart_nr;
|
||||
|
||||
switch(uart->uart_nr) {
|
||||
case UART0:
|
||||
uart->rxEnabled = (mode != SERIAL_TX_ONLY);
|
||||
uart->txEnabled = (mode != SERIAL_RX_ONLY);
|
||||
uart->rxPin = (uart->rxEnabled)?3:255;
|
||||
if(uart->rxEnabled) {
|
||||
if (use_tx == 2) {
|
||||
uart->txPin = 2;
|
||||
pinMode(uart->rxPin, FUNCTION_4);
|
||||
} else {
|
||||
uart->txPin = 1;
|
||||
pinMode(uart->rxPin, SPECIAL);
|
||||
}
|
||||
} else uart->txPin = 255;
|
||||
if(uart->txEnabled) pinMode(uart->txPin, SPECIAL);
|
||||
IOSWAP &= ~(1 << IOSWAPU0);
|
||||
break;
|
||||
case UART1:
|
||||
// Note: uart_interrupt_handler does not support RX on UART 1.
|
||||
uart->rxEnabled = false;
|
||||
uart->txEnabled = (mode != SERIAL_RX_ONLY);
|
||||
uart->rxPin = 255;
|
||||
uart->txPin = (uart->txEnabled)?2:255; // GPIO7 as TX not possible! See GPIO pins used by UART
|
||||
if(uart->txEnabled) pinMode(uart->txPin, SPECIAL);
|
||||
break;
|
||||
case UART_NO:
|
||||
default:
|
||||
// big fail!
|
||||
os_free(uart);
|
||||
return 0;
|
||||
}
|
||||
|
||||
uart_set_baudrate(uart, baudrate);
|
||||
USC0(uart->uart_nr) = config;
|
||||
uart_flush(uart);
|
||||
USC1(uart->uart_nr) = 0;
|
||||
|
||||
return uart;
|
||||
}
|
||||
|
||||
void uart_uninit(uart_t* uart) {
|
||||
if(uart == 0)
|
||||
return;
|
||||
|
||||
switch(uart->rxPin) {
|
||||
case 3:
|
||||
pinMode(3, INPUT);
|
||||
break;
|
||||
case 13:
|
||||
pinMode(13, INPUT);
|
||||
break;
|
||||
}
|
||||
|
||||
switch(uart->txPin) {
|
||||
case 1:
|
||||
pinMode(1, INPUT);
|
||||
break;
|
||||
case 2:
|
||||
pinMode(2, INPUT);
|
||||
break;
|
||||
case 15:
|
||||
pinMode(15, INPUT);
|
||||
break;
|
||||
}
|
||||
|
||||
os_free(uart);
|
||||
}
|
||||
|
||||
void uart_swap(uart_t* uart, uint8_t use_tx) {
|
||||
if(uart == 0)
|
||||
return;
|
||||
switch(uart->uart_nr) {
|
||||
case UART0:
|
||||
if(((uart->txPin == 1 || uart->txPin == 2) && uart->txEnabled) || (uart->rxPin == 3 && uart->rxEnabled)) {
|
||||
if(uart->txEnabled){ //TX
|
||||
pinMode(uart->txPin, INPUT);
|
||||
uart->txPin = 15;
|
||||
}
|
||||
if(uart->rxEnabled){ //RX
|
||||
pinMode(uart->rxPin, INPUT);
|
||||
uart->rxPin = 13;
|
||||
}
|
||||
if(uart->txEnabled) pinMode(uart->txPin, FUNCTION_4); //TX
|
||||
if(uart->rxEnabled) pinMode(uart->rxPin, FUNCTION_4); //RX
|
||||
IOSWAP |= (1 << IOSWAPU0);
|
||||
} else {
|
||||
if(uart->txEnabled){ //TX
|
||||
pinMode(uart->txPin, INPUT);
|
||||
uart->txPin = (use_tx == 2)?2:1;
|
||||
}
|
||||
if(uart->rxEnabled){ //RX
|
||||
pinMode(uart->rxPin, INPUT);
|
||||
uart->rxPin = 3;
|
||||
}
|
||||
if(uart->txEnabled) pinMode(uart->txPin, (use_tx == 2)?FUNCTION_4:SPECIAL); //TX
|
||||
if(uart->rxEnabled) pinMode(3, SPECIAL); //RX
|
||||
IOSWAP &= ~(1 << IOSWAPU0);
|
||||
}
|
||||
|
||||
break;
|
||||
case UART1:
|
||||
// Currently no swap possible! See GPIO pins used by UART
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void uart_set_tx(uart_t* uart, uint8_t use_tx) {
|
||||
if(uart == 0)
|
||||
return;
|
||||
switch(uart->uart_nr) {
|
||||
case UART0:
|
||||
if(uart->txEnabled) {
|
||||
if (uart->txPin == 1 && use_tx == 2) {
|
||||
pinMode(uart->txPin, INPUT);
|
||||
uart->txPin = 2;
|
||||
pinMode(uart->txPin, FUNCTION_4);
|
||||
} else if (uart->txPin == 2 && use_tx != 2) {
|
||||
pinMode(uart->txPin, INPUT);
|
||||
uart->txPin = 1;
|
||||
pinMode(uart->txPin, SPECIAL);
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
case UART1:
|
||||
// GPIO7 as TX not possible! See GPIO pins used by UART
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void uart_set_pins(uart_t* uart, uint8_t tx, uint8_t rx) {
|
||||
if(uart == 0)
|
||||
return;
|
||||
|
||||
if(uart->uart_nr == UART0) { // Only UART0 allows pin changes
|
||||
if(uart->txEnabled && uart->txPin != tx) {
|
||||
if( rx == 13 && tx == 15) {
|
||||
uart_swap(uart, 15);
|
||||
} else if (rx == 3 && (tx == 1 || tx == 2)) {
|
||||
if (uart->rxPin != rx) uart_swap(uart, tx);
|
||||
else uart_set_tx(uart, tx);
|
||||
}
|
||||
}
|
||||
if(uart->rxEnabled && uart->rxPin != rx && rx == 13 && tx == 15) {
|
||||
uart_swap(uart, 15);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
|
||||
void uart_ignore_char(char c) {}
|
||||
|
||||
void uart0_write_char(char c) {
|
||||
while(((USS(0) >> USTXC) & 0xff) >= 0x7F) delay(0);
|
||||
USF(0) = c;
|
||||
}
|
||||
|
||||
void uart1_write_char(char c) {
|
||||
while(((USS(1) >> USTXC) & 0xff) >= 0x7F) delay(0);
|
||||
USF(1) = c;
|
||||
}
|
||||
|
||||
static int s_uart_debug_nr = UART0;
|
||||
|
||||
void uart_set_debug(int uart_nr) {
|
||||
s_uart_debug_nr = uart_nr;
|
||||
switch(s_uart_debug_nr) {
|
||||
case UART0:
|
||||
system_set_os_print(1);
|
||||
ets_install_putc1((void *) &uart0_write_char);
|
||||
break;
|
||||
case UART1:
|
||||
system_set_os_print(1);
|
||||
ets_install_putc1((void *) &uart1_write_char);
|
||||
break;
|
||||
case UART_NO:
|
||||
default:
|
||||
system_set_os_print(0);
|
||||
ets_install_putc1((void *) &uart_ignore_char);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int uart_get_debug() {
|
||||
return s_uart_debug_nr;
|
||||
}
|
||||
|
||||
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
// ####################################################################################################
|
||||
|
||||
HardwareSerial::HardwareSerial(int uart_nr)
|
||||
: _uart_nr(uart_nr)
|
||||
, _uart(0)
|
||||
{}
|
||||
|
||||
void HardwareSerial::begin(unsigned long baud, byte config, byte mode, uint8_t use_tx) {
|
||||
if(uart_get_debug() == _uart_nr)
|
||||
void HardwareSerial::begin(unsigned long baud, SerialConfig config, SerialMode mode, uint8_t tx_pin)
|
||||
{
|
||||
if(uart_get_debug() == _uart_nr) {
|
||||
uart_set_debug(UART_NO);
|
||||
}
|
||||
|
||||
if (_uart)
|
||||
os_free(_uart);
|
||||
if (_uart) {
|
||||
free(_uart);
|
||||
}
|
||||
|
||||
_uart = uart_init(_uart_nr, baud, config, mode, use_tx);
|
||||
_uart = uart_init(_uart_nr, baud, (int) config, (int) mode, tx_pin);
|
||||
}
|
||||
|
||||
void HardwareSerial::end() {
|
||||
if(uart_get_debug() == _uart_nr)
|
||||
void HardwareSerial::end()
|
||||
{
|
||||
if(uart_get_debug() == _uart_nr) {
|
||||
uart_set_debug(UART_NO);
|
||||
}
|
||||
|
||||
uart_uninit(_uart);
|
||||
}
|
||||
|
||||
void HardwareSerial::swap(uint8_t use_tx) {
|
||||
if(_uart == 0)
|
||||
void HardwareSerial::swap(uint8_t tx_pin)
|
||||
{
|
||||
if(!_uart) {
|
||||
return;
|
||||
uart_swap(_uart, use_tx);
|
||||
}
|
||||
uart_swap(_uart, tx_pin);
|
||||
}
|
||||
|
||||
void HardwareSerial::set_tx(uint8_t use_tx) {
|
||||
if(_uart == 0)
|
||||
void HardwareSerial::set_tx(uint8_t tx_pin)
|
||||
{
|
||||
if(!_uart) {
|
||||
return;
|
||||
uart_set_tx(_uart, use_tx);
|
||||
}
|
||||
uart_set_tx(_uart, tx_pin);
|
||||
}
|
||||
|
||||
void HardwareSerial::pins(uint8_t tx, uint8_t rx) {
|
||||
if(_uart == 0)
|
||||
void HardwareSerial::pins(uint8_t tx, uint8_t rx)
|
||||
{
|
||||
if(!_uart) {
|
||||
return;
|
||||
}
|
||||
uart_set_pins(_uart, tx, rx);
|
||||
}
|
||||
|
||||
void HardwareSerial::setDebugOutput(bool en) {
|
||||
if(_uart == 0)
|
||||
void HardwareSerial::setDebugOutput(bool en)
|
||||
{
|
||||
if(!_uart) {
|
||||
return;
|
||||
}
|
||||
if(en) {
|
||||
if(_uart->txEnabled)
|
||||
uart_set_debug(_uart->uart_nr);
|
||||
else
|
||||
if(uart_tx_enabled(_uart)) {
|
||||
uart_set_debug(_uart_nr);
|
||||
} else {
|
||||
uart_set_debug(UART_NO);
|
||||
}
|
||||
} else {
|
||||
// disable debug for this interface
|
||||
if(uart_get_debug() == _uart_nr) {
|
||||
@ -420,58 +101,76 @@ void HardwareSerial::setDebugOutput(bool en) {
|
||||
}
|
||||
}
|
||||
|
||||
bool ICACHE_RAM_ATTR HardwareSerial::isTxEnabled(void) {
|
||||
return _uart != 0 && _uart->txEnabled;
|
||||
bool HardwareSerial::isTxEnabled(void)
|
||||
{
|
||||
return _uart && uart_tx_enabled(_uart);
|
||||
}
|
||||
|
||||
bool ICACHE_RAM_ATTR HardwareSerial::isRxEnabled(void) {
|
||||
return _uart != 0 && _uart->rxEnabled;
|
||||
bool HardwareSerial::isRxEnabled(void)
|
||||
{
|
||||
return _uart && uart_rx_enabled(_uart);
|
||||
}
|
||||
|
||||
int HardwareSerial::available(void) {
|
||||
if(_uart == 0 || !_uart->rxEnabled)
|
||||
int HardwareSerial::available(void)
|
||||
{
|
||||
if(!_uart || !uart_rx_enabled(_uart)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int result = static_cast<int>(uart_rx_available(_uart));
|
||||
if (!result) {
|
||||
optimistic_yield(USD(_uart->uart_nr) / 128);
|
||||
optimistic_yield(USD(_uart_nr) / 128);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int HardwareSerial::peek(void) {
|
||||
int HardwareSerial::peek(void)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
int HardwareSerial::read(void) {
|
||||
if(_uart == 0 || !_uart->rxEnabled)
|
||||
int HardwareSerial::read(void)
|
||||
{
|
||||
if(!_uart || !uart_rx_enabled(_uart)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return static_cast<int>(uart_read_char(_uart));
|
||||
return uart_read_char(_uart);
|
||||
}
|
||||
|
||||
int HardwareSerial::availableForWrite(void) {
|
||||
if(_uart == 0 || !_uart->txEnabled)
|
||||
int HardwareSerial::availableForWrite(void)
|
||||
{
|
||||
if(!_uart || !uart_tx_enabled(_uart)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return static_cast<int>(uart_tx_free(_uart));
|
||||
}
|
||||
|
||||
void HardwareSerial::flush() {
|
||||
if(_uart == 0 || !_uart->txEnabled)
|
||||
void HardwareSerial::flush()
|
||||
{
|
||||
if(!_uart || !uart_tx_enabled(_uart)) {
|
||||
return;
|
||||
}
|
||||
|
||||
uart_wait_tx_empty(_uart);
|
||||
}
|
||||
|
||||
size_t HardwareSerial::write(uint8_t c) {
|
||||
if(_uart == 0 || !_uart->txEnabled)
|
||||
size_t HardwareSerial::write(uint8_t c)
|
||||
{
|
||||
if(!_uart || !uart_tx_enabled(_uart)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uart_write_char(_uart, c);
|
||||
return 1;
|
||||
}
|
||||
|
||||
HardwareSerial::operator bool() const {
|
||||
HardwareSerial::operator bool() const
|
||||
{
|
||||
return _uart != 0;
|
||||
}
|
||||
|
||||
|
||||
HardwareSerial Serial(UART0);
|
||||
HardwareSerial Serial1(UART1);
|
||||
|
||||
@ -28,71 +28,76 @@
|
||||
#define HardwareSerial_h
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
#include "Stream.h"
|
||||
#include "uart.h"
|
||||
|
||||
#define SERIAL_TX_BUFFER_SIZE 256
|
||||
#define SERIAL_RX_BUFFER_SIZE 256
|
||||
enum SerialConfig {
|
||||
SERIAL_5N1 = UART_5N1,
|
||||
SERIAL_6N1 = UART_6N1,
|
||||
SERIAL_7N1 = UART_7N1,
|
||||
SERIAL_8N1 = UART_8N1,
|
||||
SERIAL_5N2 = UART_5N2,
|
||||
SERIAL_6N2 = UART_6N2,
|
||||
SERIAL_7N2 = UART_7N2,
|
||||
SERIAL_8N2 = UART_8N2,
|
||||
SERIAL_5E1 = UART_5E1,
|
||||
SERIAL_6E1 = UART_6E1,
|
||||
SERIAL_7E1 = UART_7E1,
|
||||
SERIAL_8E1 = UART_8E1,
|
||||
SERIAL_5E2 = UART_5E2,
|
||||
SERIAL_6E2 = UART_6E2,
|
||||
SERIAL_7E2 = UART_7E2,
|
||||
SERIAL_8E2 = UART_8E2,
|
||||
SERIAL_5O1 = UART_5O1,
|
||||
SERIAL_6O1 = UART_6O1,
|
||||
SERIAL_7O1 = UART_7O1,
|
||||
SERIAL_8O1 = UART_8O1,
|
||||
SERIAL_5O2 = UART_5O2,
|
||||
SERIAL_6O2 = UART_6O2,
|
||||
SERIAL_7O2 = UART_7O2,
|
||||
SERIAL_8O2 = UART_8O2,
|
||||
};
|
||||
|
||||
// Define config for Serial.begin(baud, config);
|
||||
#define SERIAL_5N1 0x10
|
||||
#define SERIAL_6N1 0x14
|
||||
#define SERIAL_7N1 0x18
|
||||
#define SERIAL_8N1 0x1c
|
||||
#define SERIAL_5N2 0x30
|
||||
#define SERIAL_6N2 0x34
|
||||
#define SERIAL_7N2 0x38
|
||||
#define SERIAL_8N2 0x3c
|
||||
#define SERIAL_5E1 0x12
|
||||
#define SERIAL_6E1 0x16
|
||||
#define SERIAL_7E1 0x1a
|
||||
#define SERIAL_8E1 0x1e
|
||||
#define SERIAL_5E2 0x32
|
||||
#define SERIAL_6E2 0x36
|
||||
#define SERIAL_7E2 0x3a
|
||||
#define SERIAL_8E2 0x3e
|
||||
#define SERIAL_5O1 0x13
|
||||
#define SERIAL_6O1 0x17
|
||||
#define SERIAL_7O1 0x1b
|
||||
#define SERIAL_8O1 0x1f
|
||||
#define SERIAL_5O2 0x33
|
||||
#define SERIAL_6O2 0x37
|
||||
#define SERIAL_7O2 0x3b
|
||||
#define SERIAL_8O2 0x3f
|
||||
enum SerialMode {
|
||||
SERIAL_FULL = UART_FULL,
|
||||
SERIAL_RX_ONLY = UART_RX_ONLY,
|
||||
SERIAL_TX_ONLY = UART_TX_ONLY
|
||||
};
|
||||
|
||||
#define SERIAL_FULL 0
|
||||
#define SERIAL_RX_ONLY 1
|
||||
#define SERIAL_TX_ONLY 2
|
||||
|
||||
struct uart_;
|
||||
typedef struct uart_ uart_t;
|
||||
|
||||
class HardwareSerial: public Stream {
|
||||
public:
|
||||
class HardwareSerial: public Stream
|
||||
{
|
||||
public:
|
||||
HardwareSerial(int uart_nr);
|
||||
virtual ~HardwareSerial(){}
|
||||
virtual ~HardwareSerial() {}
|
||||
|
||||
void begin(unsigned long baud) {
|
||||
void begin(unsigned long baud)
|
||||
{
|
||||
begin(baud, SERIAL_8N1, SERIAL_FULL, 1);
|
||||
}
|
||||
void begin(unsigned long baud, uint8_t config) {
|
||||
void begin(unsigned long baud, SerialConfig config)
|
||||
{
|
||||
begin(baud, config, SERIAL_FULL, 1);
|
||||
}
|
||||
void begin(unsigned long baud, uint8_t config, uint8_t mode) {
|
||||
void begin(unsigned long baud, SerialConfig config, SerialMode mode)
|
||||
{
|
||||
begin(baud, config, mode, 1);
|
||||
}
|
||||
void begin(unsigned long, uint8_t, uint8_t, uint8_t);
|
||||
|
||||
void begin(unsigned long baud, SerialConfig config, SerialMode mode, uint8_t tx_pin);
|
||||
|
||||
void end();
|
||||
void swap() {
|
||||
|
||||
void swap()
|
||||
{
|
||||
swap(1);
|
||||
}
|
||||
void swap(uint8_t use_tx); //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
|
||||
void swap(uint8_t tx_pin); //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
|
||||
|
||||
/*
|
||||
* Toggle between use of GPIO1 and GPIO2 as TX on UART 0.
|
||||
* Note: UART 1 can't be used if GPIO2 is used with UART 0!
|
||||
*/
|
||||
void set_tx(uint8_t use_tx);
|
||||
void set_tx(uint8_t tx_pin);
|
||||
|
||||
/*
|
||||
* UART 0 possible options are (1, 3), (2, 3) or (15, 13)
|
||||
@ -106,16 +111,20 @@ class HardwareSerial: public Stream {
|
||||
int availableForWrite(void);
|
||||
void flush(void) override;
|
||||
size_t write(uint8_t) override;
|
||||
inline size_t write(unsigned long n) {
|
||||
inline size_t write(unsigned long n)
|
||||
{
|
||||
return write((uint8_t) n);
|
||||
}
|
||||
inline size_t write(long n) {
|
||||
inline size_t write(long n)
|
||||
{
|
||||
return write((uint8_t) n);
|
||||
}
|
||||
inline size_t write(unsigned int n) {
|
||||
inline size_t write(unsigned int n)
|
||||
{
|
||||
return write((uint8_t) n);
|
||||
}
|
||||
inline size_t write(int n) {
|
||||
inline size_t write(int n)
|
||||
{
|
||||
return write((uint8_t) n);
|
||||
}
|
||||
using Print::write; // pull in write(str) and write(buf, size) from Print
|
||||
@ -125,9 +134,7 @@ class HardwareSerial: public Stream {
|
||||
bool isTxEnabled(void);
|
||||
bool isRxEnabled(void);
|
||||
|
||||
protected:
|
||||
|
||||
protected:
|
||||
protected:
|
||||
int _uart_nr;
|
||||
uart_t* _uart;
|
||||
};
|
||||
|
||||
396
cores/esp8266/uart.c
Normal file
396
cores/esp8266/uart.c
Normal file
@ -0,0 +1,396 @@
|
||||
/*
|
||||
uart.cpp - esp8266 UART HAL
|
||||
|
||||
Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
|
||||
This file is part of the esp8266 core for Arduino environment.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* UART GPIOs
|
||||
*
|
||||
* UART0 TX: 1 or 2
|
||||
* UART0 RX: 3
|
||||
*
|
||||
* UART0 SWAP TX: 15
|
||||
* UART0 SWAP RX: 13
|
||||
*
|
||||
*
|
||||
* UART1 TX: 7 (NC) or 2
|
||||
* UART1 RX: 8 (NC)
|
||||
*
|
||||
* UART1 SWAP TX: 11 (NC)
|
||||
* UART1 SWAP RX: 6 (NC)
|
||||
*
|
||||
* NC = Not Connected to Module Pads --> No Access
|
||||
*
|
||||
*/
|
||||
#include "Arduino.h"
|
||||
#include "uart.h"
|
||||
#include "esp8266_peri.h"
|
||||
#include "user_interface.h"
|
||||
|
||||
static int s_uart_debug_nr = UART0;
|
||||
|
||||
struct uart_ {
|
||||
int uart_nr;
|
||||
int baud_rate;
|
||||
bool rx_enabled;
|
||||
bool tx_enabled;
|
||||
uint8_t rx_pin;
|
||||
uint8_t tx_pin;
|
||||
};
|
||||
|
||||
void uart_write_char(uart_t* uart, char c)
|
||||
{
|
||||
if(uart == NULL || !uart->tx_enabled) {
|
||||
return;
|
||||
}
|
||||
while((USS(uart->uart_nr) >> USTXC) >= 0x7f);
|
||||
USF(uart->uart_nr) = c;
|
||||
}
|
||||
|
||||
void uart_write(uart_t* uart, const char* buf, size_t size)
|
||||
{
|
||||
if(uart == NULL || !uart->tx_enabled) {
|
||||
return;
|
||||
}
|
||||
while(size--) {
|
||||
uart_write_char(uart, *buf++);
|
||||
}
|
||||
}
|
||||
|
||||
int uart_read_char(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL || !uart->rx_enabled) {
|
||||
return -1;
|
||||
}
|
||||
return USF(uart->uart_nr) & 0xff;
|
||||
}
|
||||
|
||||
size_t uart_rx_available(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL || !uart->rx_enabled) {
|
||||
return -1;
|
||||
}
|
||||
return (USS(uart->uart_nr) >> USRXC) & 0xff;
|
||||
}
|
||||
|
||||
size_t uart_tx_free(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL || !uart->tx_enabled) {
|
||||
return 0;
|
||||
}
|
||||
return UART_TX_FIFO_SIZE - ((USS(uart->uart_nr) >> USTXC) & 0xff);
|
||||
}
|
||||
|
||||
void uart_wait_tx_empty(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL || !uart->tx_enabled) {
|
||||
return;
|
||||
}
|
||||
while(((USS(uart->uart_nr) >> USTXC) & 0xff) > 0) {
|
||||
delay(0);
|
||||
}
|
||||
}
|
||||
|
||||
void uart_flush(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t tmp = 0x00000000;
|
||||
if(uart->rx_enabled) {
|
||||
tmp |= (1 << UCRXRST);
|
||||
}
|
||||
|
||||
if(uart->tx_enabled) {
|
||||
tmp |= (1 << UCTXRST);
|
||||
}
|
||||
|
||||
USC0(uart->uart_nr) |= (tmp);
|
||||
USC0(uart->uart_nr) &= ~(tmp);
|
||||
}
|
||||
|
||||
void uart_set_baudrate(uart_t* uart, int baud_rate)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return;
|
||||
}
|
||||
uart->baud_rate = baud_rate;
|
||||
USD(uart->uart_nr) = (ESP8266_CLOCK / uart->baud_rate);
|
||||
}
|
||||
|
||||
int uart_get_baudrate(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return 0;
|
||||
}
|
||||
return uart->baud_rate;
|
||||
}
|
||||
|
||||
uart_t* uart_init(int uart_nr, int baudrate, int config, int mode, int tx_pin)
|
||||
{
|
||||
uart_t* uart = (uart_t*) malloc(sizeof(uart_t));
|
||||
if(uart == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uart->uart_nr = uart_nr;
|
||||
|
||||
switch(uart->uart_nr) {
|
||||
case UART0:
|
||||
uart->rx_enabled = (mode != UART_TX_ONLY);
|
||||
uart->tx_enabled = (mode != UART_RX_ONLY);
|
||||
uart->rx_pin = (uart->rx_enabled)?3:255;
|
||||
if(uart->rx_enabled) {
|
||||
if (tx_pin == 2) {
|
||||
uart->tx_pin = 2;
|
||||
pinMode(uart->rx_pin, FUNCTION_4);
|
||||
} else {
|
||||
uart->tx_pin = 1;
|
||||
pinMode(uart->rx_pin, SPECIAL);
|
||||
}
|
||||
} else {
|
||||
uart->tx_pin = 255;
|
||||
}
|
||||
if(uart->tx_enabled) {
|
||||
pinMode(uart->tx_pin, SPECIAL);
|
||||
}
|
||||
IOSWAP &= ~(1 << IOSWAPU0);
|
||||
break;
|
||||
case UART1:
|
||||
// Note: uart_interrupt_handler does not support RX on UART 1.
|
||||
uart->rx_enabled = false;
|
||||
uart->tx_enabled = (mode != UART_RX_ONLY);
|
||||
uart->rx_pin = 255;
|
||||
uart->tx_pin = (uart->tx_enabled)?2:255; // GPIO7 as TX not possible! See GPIO pins used by UART
|
||||
if(uart->tx_enabled) {
|
||||
pinMode(uart->tx_pin, SPECIAL);
|
||||
}
|
||||
break;
|
||||
case UART_NO:
|
||||
default:
|
||||
// big fail!
|
||||
free(uart);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uart_set_baudrate(uart, baudrate);
|
||||
USC0(uart->uart_nr) = config;
|
||||
uart_flush(uart);
|
||||
USC1(uart->uart_nr) = 0;
|
||||
|
||||
return uart;
|
||||
}
|
||||
|
||||
void uart_uninit(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
switch(uart->rx_pin) {
|
||||
case 3:
|
||||
pinMode(3, INPUT);
|
||||
break;
|
||||
case 13:
|
||||
pinMode(13, INPUT);
|
||||
break;
|
||||
}
|
||||
|
||||
switch(uart->tx_pin) {
|
||||
case 1:
|
||||
pinMode(1, INPUT);
|
||||
break;
|
||||
case 2:
|
||||
pinMode(2, INPUT);
|
||||
break;
|
||||
case 15:
|
||||
pinMode(15, INPUT);
|
||||
break;
|
||||
}
|
||||
|
||||
os_free(uart);
|
||||
}
|
||||
|
||||
void uart_swap(uart_t* uart, int tx_pin)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return;
|
||||
}
|
||||
switch(uart->uart_nr) {
|
||||
case UART0:
|
||||
if(((uart->tx_pin == 1 || uart->tx_pin == 2) && uart->tx_enabled) || (uart->rx_pin == 3 && uart->rx_enabled)) {
|
||||
if(uart->tx_enabled) { //TX
|
||||
pinMode(uart->tx_pin, INPUT);
|
||||
uart->tx_pin = 15;
|
||||
}
|
||||
if(uart->rx_enabled) { //RX
|
||||
pinMode(uart->rx_pin, INPUT);
|
||||
uart->rx_pin = 13;
|
||||
}
|
||||
if(uart->tx_enabled) {
|
||||
pinMode(uart->tx_pin, FUNCTION_4); //TX
|
||||
}
|
||||
if(uart->rx_enabled) {
|
||||
pinMode(uart->rx_pin, FUNCTION_4); //RX
|
||||
}
|
||||
IOSWAP |= (1 << IOSWAPU0);
|
||||
} else {
|
||||
if(uart->tx_enabled) { //TX
|
||||
pinMode(uart->tx_pin, INPUT);
|
||||
uart->tx_pin = (tx_pin == 2)?2:1;
|
||||
}
|
||||
if(uart->rx_enabled) { //RX
|
||||
pinMode(uart->rx_pin, INPUT);
|
||||
uart->rx_pin = 3;
|
||||
}
|
||||
if(uart->tx_enabled) {
|
||||
pinMode(uart->tx_pin, (tx_pin == 2)?FUNCTION_4:SPECIAL); //TX
|
||||
}
|
||||
if(uart->rx_enabled) {
|
||||
pinMode(3, SPECIAL); //RX
|
||||
}
|
||||
IOSWAP &= ~(1 << IOSWAPU0);
|
||||
}
|
||||
|
||||
break;
|
||||
case UART1:
|
||||
// Currently no swap possible! See GPIO pins used by UART
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void uart_set_tx(uart_t* uart, int tx_pin)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return;
|
||||
}
|
||||
switch(uart->uart_nr) {
|
||||
case UART0:
|
||||
if(uart->tx_enabled) {
|
||||
if (uart->tx_pin == 1 && tx_pin == 2) {
|
||||
pinMode(uart->tx_pin, INPUT);
|
||||
uart->tx_pin = 2;
|
||||
pinMode(uart->tx_pin, FUNCTION_4);
|
||||
} else if (uart->tx_pin == 2 && tx_pin != 2) {
|
||||
pinMode(uart->tx_pin, INPUT);
|
||||
uart->tx_pin = 1;
|
||||
pinMode(uart->tx_pin, SPECIAL);
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
case UART1:
|
||||
// GPIO7 as TX not possible! See GPIO pins used by UART
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void uart_set_pins(uart_t* uart, int tx, int rx)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if(uart->uart_nr == UART0) { // Only UART0 allows pin changes
|
||||
if(uart->tx_enabled && uart->tx_pin != tx) {
|
||||
if( rx == 13 && tx == 15) {
|
||||
uart_swap(uart, 15);
|
||||
} else if (rx == 3 && (tx == 1 || tx == 2)) {
|
||||
if (uart->rx_pin != rx) {
|
||||
uart_swap(uart, tx);
|
||||
} else {
|
||||
uart_set_tx(uart, tx);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(uart->rx_enabled && uart->rx_pin != rx && rx == 13 && tx == 15) {
|
||||
uart_swap(uart, 15);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool uart_tx_enabled(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return false;
|
||||
}
|
||||
return uart->tx_enabled;
|
||||
}
|
||||
|
||||
bool uart_rx_enabled(uart_t* uart)
|
||||
{
|
||||
if(uart == NULL) {
|
||||
return false;
|
||||
}
|
||||
return uart->rx_enabled;
|
||||
}
|
||||
|
||||
|
||||
static void uart_ignore_char(char c)
|
||||
{
|
||||
}
|
||||
|
||||
static void uart0_write_char(char c)
|
||||
{
|
||||
while(((USS(0) >> USTXC) & 0xff) >= 0x7F) {
|
||||
delay(0);
|
||||
}
|
||||
USF(0) = c;
|
||||
}
|
||||
|
||||
static void uart1_write_char(char c)
|
||||
{
|
||||
while(((USS(1) >> USTXC) & 0xff) >= 0x7F) {
|
||||
delay(0);
|
||||
}
|
||||
USF(1) = c;
|
||||
}
|
||||
|
||||
void uart_set_debug(int uart_nr)
|
||||
{
|
||||
s_uart_debug_nr = uart_nr;
|
||||
switch(s_uart_debug_nr) {
|
||||
case UART0:
|
||||
system_set_os_print(1);
|
||||
ets_install_putc1((void *) &uart0_write_char);
|
||||
break;
|
||||
case UART1:
|
||||
system_set_os_print(1);
|
||||
ets_install_putc1((void *) &uart1_write_char);
|
||||
break;
|
||||
case UART_NO:
|
||||
default:
|
||||
system_set_os_print(0);
|
||||
ets_install_putc1((void *) &uart_ignore_char);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int uart_get_debug()
|
||||
{
|
||||
return s_uart_debug_nr;
|
||||
}
|
||||
100
cores/esp8266/uart.h
Normal file
100
cores/esp8266/uart.h
Normal file
@ -0,0 +1,100 @@
|
||||
/*
|
||||
uart.h - UART HAL
|
||||
|
||||
Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
|
||||
This file is part of the esp8266 core for Arduino environment.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library 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
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
*/
|
||||
#ifndef ESP_UART_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#if defined (__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define UART0 0
|
||||
#define UART1 1
|
||||
#define UART_NO -1
|
||||
|
||||
// Options for `config` argument of uart_init
|
||||
#define UART_5N1 0x10
|
||||
#define UART_6N1 0x14
|
||||
#define UART_7N1 0x18
|
||||
#define UART_8N1 0x1c
|
||||
#define UART_5N2 0x30
|
||||
#define UART_6N2 0x34
|
||||
#define UART_7N2 0x38
|
||||
#define UART_8N2 0x3c
|
||||
#define UART_5E1 0x12
|
||||
#define UART_6E1 0x16
|
||||
#define UART_7E1 0x1a
|
||||
#define UART_8E1 0x1e
|
||||
#define UART_5E2 0x32
|
||||
#define UART_6E2 0x36
|
||||
#define UART_7E2 0x3a
|
||||
#define UART_8E2 0x3e
|
||||
#define UART_5O1 0x13
|
||||
#define UART_6O1 0x17
|
||||
#define UART_7O1 0x1b
|
||||
#define UART_8O1 0x1f
|
||||
#define UART_5O2 0x33
|
||||
#define UART_6O2 0x37
|
||||
#define UART_7O2 0x3b
|
||||
#define UART_8O2 0x3f
|
||||
|
||||
// Options for `mode` argument of uart_init
|
||||
#define UART_FULL 0
|
||||
#define UART_RX_ONLY 1
|
||||
#define UART_TX_ONLY 2
|
||||
|
||||
#define UART_TX_FIFO_SIZE 0x80
|
||||
|
||||
struct uart_;
|
||||
typedef struct uart_ uart_t;
|
||||
|
||||
uart_t* uart_init(int uart_nr, int baudrate, int config, int mode, int tx_pin);
|
||||
void uart_uninit(uart_t* uart);
|
||||
|
||||
void uart_swap(uart_t* uart, int tx_pin);
|
||||
void uart_set_tx(uart_t* uart, int tx_pin);
|
||||
void uart_set_pins(uart_t* uart, int tx, int rx);
|
||||
bool uart_tx_enabled(uart_t* uart);
|
||||
bool uart_rx_enabled(uart_t* uart);
|
||||
|
||||
void uart_set_baudrate(uart_t* uart, int baud_rate);
|
||||
int uart_get_baudrate(uart_t* uart);
|
||||
|
||||
void uart_write_char(uart_t* uart, char c);
|
||||
void uart_write(uart_t* uart, const char* buf, size_t size);
|
||||
int uart_read_char(uart_t* uart);
|
||||
size_t uart_rx_available(uart_t* uart);
|
||||
size_t uart_tx_free(uart_t* uart);
|
||||
void uart_wait_tx_empty(uart_t* uart);
|
||||
void uart_flush(uart_t* uart);
|
||||
|
||||
void uart_set_debug(int uart_nr);
|
||||
int uart_get_debug();
|
||||
|
||||
|
||||
#if defined (__cplusplus)
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif // ESP_UART_H
|
||||
Reference in New Issue
Block a user