From 2b1bebc58107876c18378c894dd5b473a9edcf4f Mon Sep 17 00:00:00 2001 From: techpaul Date: Mon, 18 Jan 2016 01:09:55 +0000 Subject: [PATCH 1/6] Compiler Warning UARTClass.cpp and RingBuffer.h correction --- hardware/arduino/sam/cores/arduino/RingBuffer.h | 2 +- hardware/arduino/sam/cores/arduino/UARTClass.cpp | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/hardware/arduino/sam/cores/arduino/RingBuffer.h b/hardware/arduino/sam/cores/arduino/RingBuffer.h index 1a5861b0b4c..6041430ea47 100644 --- a/hardware/arduino/sam/cores/arduino/RingBuffer.h +++ b/hardware/arduino/sam/cores/arduino/RingBuffer.h @@ -22,7 +22,7 @@ #include // Define constants and variables for buffering incoming serial data. We're -// using a ring buffer (I think), in which head is the index of the location +// using a ring buffer, in which head is the index of the location // to which to write the next incoming character and tail is the index of the // location from which to read. #define SERIAL_BUFFER_SIZE 128 diff --git a/hardware/arduino/sam/cores/arduino/UARTClass.cpp b/hardware/arduino/sam/cores/arduino/UARTClass.cpp index ed1cb26870b..36de13586ce 100644 --- a/hardware/arduino/sam/cores/arduino/UARTClass.cpp +++ b/hardware/arduino/sam/cores/arduino/UARTClass.cpp @@ -149,12 +149,12 @@ size_t UARTClass::write( const uint8_t uc_data ) (_tx_buffer->_iTail != _tx_buffer->_iHead)) { // If busy we buffer - unsigned int l = (_tx_buffer->_iHead + 1) % SERIAL_BUFFER_SIZE; - while (_tx_buffer->_iTail == l) + int nextWrite = (_tx_buffer->_iHead + 1) % SERIAL_BUFFER_SIZE; + while (_tx_buffer->_iTail == nextWrite) ; // Spin locks if we're about to overwrite the buffer. This continues once the data is sent _tx_buffer->_aucBuffer[_tx_buffer->_iHead] = uc_data; - _tx_buffer->_iHead = l; + _tx_buffer->_iHead = nextWrite; // Make sure TX interrupt is enabled _pUart->UART_IER = UART_IER_TXRDY; } From e831ce9f13d7dda685c4aa88349d0346dfc5ff3e Mon Sep 17 00:00:00 2001 From: techpaul Date: Mon, 18 Jan 2016 01:17:44 +0000 Subject: [PATCH 2/6] Correct Compiler Warning UARTClass.cpp and Comment in RingBuffer.h --- .../arduino/sam/cores/arduino/RingBuffer.h~ | 42 ++++ .../arduino/sam/cores/arduino/UARTClass.cpp~ | 198 ++++++++++++++++++ 2 files changed, 240 insertions(+) create mode 100644 hardware/arduino/sam/cores/arduino/RingBuffer.h~ create mode 100644 hardware/arduino/sam/cores/arduino/UARTClass.cpp~ diff --git a/hardware/arduino/sam/cores/arduino/RingBuffer.h~ b/hardware/arduino/sam/cores/arduino/RingBuffer.h~ new file mode 100644 index 00000000000..1a5861b0b4c --- /dev/null +++ b/hardware/arduino/sam/cores/arduino/RingBuffer.h~ @@ -0,0 +1,42 @@ +/* + Copyright (c) 2011 Arduino. All right reserved. + + 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 _RING_BUFFER_ +#define _RING_BUFFER_ + +#include + +// Define constants and variables for buffering incoming serial data. We're +// using a ring buffer (I think), in which head is the index of the location +// to which to write the next incoming character and tail is the index of the +// location from which to read. +#define SERIAL_BUFFER_SIZE 128 + +class RingBuffer +{ + public: + volatile uint8_t _aucBuffer[SERIAL_BUFFER_SIZE] ; + volatile int _iHead ; + volatile int _iTail ; + + public: + RingBuffer( void ) ; + void store_char( uint8_t c ) ; +} ; + +#endif /* _RING_BUFFER_ */ diff --git a/hardware/arduino/sam/cores/arduino/UARTClass.cpp~ b/hardware/arduino/sam/cores/arduino/UARTClass.cpp~ new file mode 100644 index 00000000000..ed1cb26870b --- /dev/null +++ b/hardware/arduino/sam/cores/arduino/UARTClass.cpp~ @@ -0,0 +1,198 @@ +/* + Copyright (c) 2011 Arduino. All right reserved. + + 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 +*/ + +#include +#include +#include +#include "UARTClass.h" + +// Constructors //////////////////////////////////////////////////////////////// + +UARTClass::UARTClass( Uart *pUart, IRQn_Type dwIrq, uint32_t dwId, RingBuffer *pRx_buffer, RingBuffer *pTx_buffer ) +{ + _rx_buffer = pRx_buffer; + _tx_buffer = pTx_buffer; + + _pUart=pUart; + _dwIrq=dwIrq; + _dwId=dwId; +} + +// Public Methods ////////////////////////////////////////////////////////////// + +void UARTClass::begin(const uint32_t dwBaudRate) +{ + begin(dwBaudRate, Mode_8N1); +} + +void UARTClass::begin(const uint32_t dwBaudRate, const UARTModes config) +{ + uint32_t modeReg = static_cast(config) & 0x00000E00; + init(dwBaudRate, modeReg | UART_MR_CHMODE_NORMAL); +} + +void UARTClass::init(const uint32_t dwBaudRate, const uint32_t modeReg) +{ + // Configure PMC + pmc_enable_periph_clk( _dwId ); + + // Disable PDC channel + _pUart->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS; + + // Reset and disable receiver and transmitter + _pUart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS; + + // Configure mode + _pUart->UART_MR = modeReg; + + // Configure baudrate (asynchronous, no oversampling) + _pUart->UART_BRGR = (SystemCoreClock / dwBaudRate) >> 4; + + // Configure interrupts + _pUart->UART_IDR = 0xFFFFFFFF; + _pUart->UART_IER = UART_IER_RXRDY | UART_IER_OVRE | UART_IER_FRAME; + + // Enable UART interrupt in NVIC + NVIC_EnableIRQ(_dwIrq); + + // Make sure both ring buffers are initialized back to empty. + _rx_buffer->_iHead = _rx_buffer->_iTail = 0; + _tx_buffer->_iHead = _tx_buffer->_iTail = 0; + + // Enable receiver and transmitter + _pUart->UART_CR = UART_CR_RXEN | UART_CR_TXEN; +} + +void UARTClass::end( void ) +{ + // Clear any received data + _rx_buffer->_iHead = _rx_buffer->_iTail; + + // Wait for any outstanding data to be sent + flush(); + + // Disable UART interrupt in NVIC + NVIC_DisableIRQ( _dwIrq ); + + pmc_disable_periph_clk( _dwId ); +} + +void UARTClass::setInterruptPriority(uint32_t priority) +{ + NVIC_SetPriority(_dwIrq, priority & 0x0F); +} + +uint32_t UARTClass::getInterruptPriority() +{ + return NVIC_GetPriority(_dwIrq); +} + +int UARTClass::available( void ) +{ + return (uint32_t)(SERIAL_BUFFER_SIZE + _rx_buffer->_iHead - _rx_buffer->_iTail) % SERIAL_BUFFER_SIZE; +} + +int UARTClass::availableForWrite(void) +{ + int head = _tx_buffer->_iHead; + int tail = _tx_buffer->_iTail; + if (head >= tail) return SERIAL_BUFFER_SIZE - 1 - head + tail; + return tail - head - 1; +} + +int UARTClass::peek( void ) +{ + if ( _rx_buffer->_iHead == _rx_buffer->_iTail ) + return -1; + + return _rx_buffer->_aucBuffer[_rx_buffer->_iTail]; +} + +int UARTClass::read( void ) +{ + // if the head isn't ahead of the tail, we don't have any characters + if ( _rx_buffer->_iHead == _rx_buffer->_iTail ) + return -1; + + uint8_t uc = _rx_buffer->_aucBuffer[_rx_buffer->_iTail]; + _rx_buffer->_iTail = (unsigned int)(_rx_buffer->_iTail + 1) % SERIAL_BUFFER_SIZE; + return uc; +} + +void UARTClass::flush( void ) +{ + while (_tx_buffer->_iHead != _tx_buffer->_iTail); //wait for transmit data to be sent + // Wait for transmission to complete + while ((_pUart->UART_SR & UART_SR_TXEMPTY) != UART_SR_TXEMPTY) + ; +} + +size_t UARTClass::write( const uint8_t uc_data ) +{ + // Is the hardware currently busy? + if (((_pUart->UART_SR & UART_SR_TXRDY) != UART_SR_TXRDY) | + (_tx_buffer->_iTail != _tx_buffer->_iHead)) + { + // If busy we buffer + unsigned int l = (_tx_buffer->_iHead + 1) % SERIAL_BUFFER_SIZE; + while (_tx_buffer->_iTail == l) + ; // Spin locks if we're about to overwrite the buffer. This continues once the data is sent + + _tx_buffer->_aucBuffer[_tx_buffer->_iHead] = uc_data; + _tx_buffer->_iHead = l; + // Make sure TX interrupt is enabled + _pUart->UART_IER = UART_IER_TXRDY; + } + else + { + // Bypass buffering and send character directly + _pUart->UART_THR = uc_data; + } + return 1; +} + +void UARTClass::IrqHandler( void ) +{ + uint32_t status = _pUart->UART_SR; + + // Did we receive data? + if ((status & UART_SR_RXRDY) == UART_SR_RXRDY) + _rx_buffer->store_char(_pUart->UART_RHR); + + // Do we need to keep sending data? + if ((status & UART_SR_TXRDY) == UART_SR_TXRDY) + { + if (_tx_buffer->_iTail != _tx_buffer->_iHead) { + _pUart->UART_THR = _tx_buffer->_aucBuffer[_tx_buffer->_iTail]; + _tx_buffer->_iTail = (unsigned int)(_tx_buffer->_iTail + 1) % SERIAL_BUFFER_SIZE; + } + else + { + // Mask off transmit interrupt so we don't get it anymore + _pUart->UART_IDR = UART_IDR_TXRDY; + } + } + + // Acknowledge errors + if ((status & UART_SR_OVRE) == UART_SR_OVRE || (status & UART_SR_FRAME) == UART_SR_FRAME) + { + // TODO: error reporting outside ISR + _pUart->UART_CR |= UART_CR_RSTSTA; + } +} + From 660d38d0c8424b88a752c405a8cf9618e27d6d25 Mon Sep 17 00:00:00 2001 From: techpaul Date: Mon, 18 Jan 2016 14:26:20 +0000 Subject: [PATCH 3/6] Delete erroneous temporary files --- .../arduino/sam/cores/arduino/RingBuffer.h~ | 42 ---- .../arduino/sam/cores/arduino/UARTClass.cpp~ | 198 ------------------ 2 files changed, 240 deletions(-) delete mode 100644 hardware/arduino/sam/cores/arduino/RingBuffer.h~ delete mode 100644 hardware/arduino/sam/cores/arduino/UARTClass.cpp~ diff --git a/hardware/arduino/sam/cores/arduino/RingBuffer.h~ b/hardware/arduino/sam/cores/arduino/RingBuffer.h~ deleted file mode 100644 index 1a5861b0b4c..00000000000 --- a/hardware/arduino/sam/cores/arduino/RingBuffer.h~ +++ /dev/null @@ -1,42 +0,0 @@ -/* - Copyright (c) 2011 Arduino. All right reserved. - - 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 _RING_BUFFER_ -#define _RING_BUFFER_ - -#include - -// Define constants and variables for buffering incoming serial data. We're -// using a ring buffer (I think), in which head is the index of the location -// to which to write the next incoming character and tail is the index of the -// location from which to read. -#define SERIAL_BUFFER_SIZE 128 - -class RingBuffer -{ - public: - volatile uint8_t _aucBuffer[SERIAL_BUFFER_SIZE] ; - volatile int _iHead ; - volatile int _iTail ; - - public: - RingBuffer( void ) ; - void store_char( uint8_t c ) ; -} ; - -#endif /* _RING_BUFFER_ */ diff --git a/hardware/arduino/sam/cores/arduino/UARTClass.cpp~ b/hardware/arduino/sam/cores/arduino/UARTClass.cpp~ deleted file mode 100644 index ed1cb26870b..00000000000 --- a/hardware/arduino/sam/cores/arduino/UARTClass.cpp~ +++ /dev/null @@ -1,198 +0,0 @@ -/* - Copyright (c) 2011 Arduino. All right reserved. - - 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 -*/ - -#include -#include -#include -#include "UARTClass.h" - -// Constructors //////////////////////////////////////////////////////////////// - -UARTClass::UARTClass( Uart *pUart, IRQn_Type dwIrq, uint32_t dwId, RingBuffer *pRx_buffer, RingBuffer *pTx_buffer ) -{ - _rx_buffer = pRx_buffer; - _tx_buffer = pTx_buffer; - - _pUart=pUart; - _dwIrq=dwIrq; - _dwId=dwId; -} - -// Public Methods ////////////////////////////////////////////////////////////// - -void UARTClass::begin(const uint32_t dwBaudRate) -{ - begin(dwBaudRate, Mode_8N1); -} - -void UARTClass::begin(const uint32_t dwBaudRate, const UARTModes config) -{ - uint32_t modeReg = static_cast(config) & 0x00000E00; - init(dwBaudRate, modeReg | UART_MR_CHMODE_NORMAL); -} - -void UARTClass::init(const uint32_t dwBaudRate, const uint32_t modeReg) -{ - // Configure PMC - pmc_enable_periph_clk( _dwId ); - - // Disable PDC channel - _pUart->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS; - - // Reset and disable receiver and transmitter - _pUart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS; - - // Configure mode - _pUart->UART_MR = modeReg; - - // Configure baudrate (asynchronous, no oversampling) - _pUart->UART_BRGR = (SystemCoreClock / dwBaudRate) >> 4; - - // Configure interrupts - _pUart->UART_IDR = 0xFFFFFFFF; - _pUart->UART_IER = UART_IER_RXRDY | UART_IER_OVRE | UART_IER_FRAME; - - // Enable UART interrupt in NVIC - NVIC_EnableIRQ(_dwIrq); - - // Make sure both ring buffers are initialized back to empty. - _rx_buffer->_iHead = _rx_buffer->_iTail = 0; - _tx_buffer->_iHead = _tx_buffer->_iTail = 0; - - // Enable receiver and transmitter - _pUart->UART_CR = UART_CR_RXEN | UART_CR_TXEN; -} - -void UARTClass::end( void ) -{ - // Clear any received data - _rx_buffer->_iHead = _rx_buffer->_iTail; - - // Wait for any outstanding data to be sent - flush(); - - // Disable UART interrupt in NVIC - NVIC_DisableIRQ( _dwIrq ); - - pmc_disable_periph_clk( _dwId ); -} - -void UARTClass::setInterruptPriority(uint32_t priority) -{ - NVIC_SetPriority(_dwIrq, priority & 0x0F); -} - -uint32_t UARTClass::getInterruptPriority() -{ - return NVIC_GetPriority(_dwIrq); -} - -int UARTClass::available( void ) -{ - return (uint32_t)(SERIAL_BUFFER_SIZE + _rx_buffer->_iHead - _rx_buffer->_iTail) % SERIAL_BUFFER_SIZE; -} - -int UARTClass::availableForWrite(void) -{ - int head = _tx_buffer->_iHead; - int tail = _tx_buffer->_iTail; - if (head >= tail) return SERIAL_BUFFER_SIZE - 1 - head + tail; - return tail - head - 1; -} - -int UARTClass::peek( void ) -{ - if ( _rx_buffer->_iHead == _rx_buffer->_iTail ) - return -1; - - return _rx_buffer->_aucBuffer[_rx_buffer->_iTail]; -} - -int UARTClass::read( void ) -{ - // if the head isn't ahead of the tail, we don't have any characters - if ( _rx_buffer->_iHead == _rx_buffer->_iTail ) - return -1; - - uint8_t uc = _rx_buffer->_aucBuffer[_rx_buffer->_iTail]; - _rx_buffer->_iTail = (unsigned int)(_rx_buffer->_iTail + 1) % SERIAL_BUFFER_SIZE; - return uc; -} - -void UARTClass::flush( void ) -{ - while (_tx_buffer->_iHead != _tx_buffer->_iTail); //wait for transmit data to be sent - // Wait for transmission to complete - while ((_pUart->UART_SR & UART_SR_TXEMPTY) != UART_SR_TXEMPTY) - ; -} - -size_t UARTClass::write( const uint8_t uc_data ) -{ - // Is the hardware currently busy? - if (((_pUart->UART_SR & UART_SR_TXRDY) != UART_SR_TXRDY) | - (_tx_buffer->_iTail != _tx_buffer->_iHead)) - { - // If busy we buffer - unsigned int l = (_tx_buffer->_iHead + 1) % SERIAL_BUFFER_SIZE; - while (_tx_buffer->_iTail == l) - ; // Spin locks if we're about to overwrite the buffer. This continues once the data is sent - - _tx_buffer->_aucBuffer[_tx_buffer->_iHead] = uc_data; - _tx_buffer->_iHead = l; - // Make sure TX interrupt is enabled - _pUart->UART_IER = UART_IER_TXRDY; - } - else - { - // Bypass buffering and send character directly - _pUart->UART_THR = uc_data; - } - return 1; -} - -void UARTClass::IrqHandler( void ) -{ - uint32_t status = _pUart->UART_SR; - - // Did we receive data? - if ((status & UART_SR_RXRDY) == UART_SR_RXRDY) - _rx_buffer->store_char(_pUart->UART_RHR); - - // Do we need to keep sending data? - if ((status & UART_SR_TXRDY) == UART_SR_TXRDY) - { - if (_tx_buffer->_iTail != _tx_buffer->_iHead) { - _pUart->UART_THR = _tx_buffer->_aucBuffer[_tx_buffer->_iTail]; - _tx_buffer->_iTail = (unsigned int)(_tx_buffer->_iTail + 1) % SERIAL_BUFFER_SIZE; - } - else - { - // Mask off transmit interrupt so we don't get it anymore - _pUart->UART_IDR = UART_IDR_TXRDY; - } - } - - // Acknowledge errors - if ((status & UART_SR_OVRE) == UART_SR_OVRE || (status & UART_SR_FRAME) == UART_SR_FRAME) - { - // TODO: error reporting outside ISR - _pUart->UART_CR |= UART_CR_RSTSTA; - } -} - From d4a44990d31e1db861d3a697e6bffd146c792507 Mon Sep 17 00:00:00 2001 From: techpaul Date: Tue, 9 Feb 2016 11:26:46 +0000 Subject: [PATCH 4/6] Improve LCD library to become less blocking --- libraries/LiquidCrystal/src/LiquidCrystal.cpp | 15 +++++++++++---- libraries/LiquidCrystal/src/LiquidCrystal.h | 1 + 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/libraries/LiquidCrystal/src/LiquidCrystal.cpp b/libraries/LiquidCrystal/src/LiquidCrystal.cpp index 8c6cdf0a6f7..b3768340099 100644 --- a/libraries/LiquidCrystal/src/LiquidCrystal.cpp +++ b/libraries/LiquidCrystal/src/LiquidCrystal.cpp @@ -5,6 +5,9 @@ #include #include "Arduino.h" +// Minimum time between falling edges of E (enable pin to do writes) +#define _MIN_WRITE_DELAY 80 + // When the display powers up, it is configured as follows: // // 1. Display clear @@ -301,12 +304,16 @@ void LiquidCrystal::send(uint8_t value, uint8_t mode) { } void LiquidCrystal::pulseEnable(void) { - digitalWrite(_enable_pin, LOW); - delayMicroseconds(1); + unsigned long _delaymicros; + digitalWrite(_enable_pin, HIGH); - delayMicroseconds(1); // enable pulse must be >450ns + _delaymicros = micros( ) - _oldmicros; // PREVIOUS commands need > 37us to settle + if( _delaymicros < _MIN_WRITE_DELAY ) + delayMicroseconds( _MIN_WRITE_DELAY - _delaymicros ); // wait time for delay + else + delayMicroseconds(1); // enable pulse HIGH must be >450ns digitalWrite(_enable_pin, LOW); - delayMicroseconds(100); // commands need > 37us to settle + _oldmicros = micros( ); // save time to check next time } void LiquidCrystal::write4bits(uint8_t value) { diff --git a/libraries/LiquidCrystal/src/LiquidCrystal.h b/libraries/LiquidCrystal/src/LiquidCrystal.h index da950ce5815..44c239529f2 100644 --- a/libraries/LiquidCrystal/src/LiquidCrystal.h +++ b/libraries/LiquidCrystal/src/LiquidCrystal.h @@ -103,6 +103,7 @@ class LiquidCrystal : public Print { uint8_t _numlines; uint8_t _row_offsets[4]; + unsigned long _oldmicros; }; #endif From 0fa8ab84ee6c6a4513f761badbb0b3092bf3d9b5 Mon Sep 17 00:00:00 2001 From: techpaul Date: Thu, 11 Feb 2016 13:44:50 +0000 Subject: [PATCH 5/6] LCD Library 4 bit improvements Reduce delay between nibbles as per Datasheet Long delays are for between COMPLETE commands NOT nibbles of a byte Tidy functions write8bits and write4bits become one function and pass in bit size. Original functions were copy/paste with one number change between them. Change constant define from _MIN_WRITE_DELAY to more meaningful _LCD_COMMAND_DELAY --- libraries/LiquidCrystal/src/LiquidCrystal.cpp | 56 ++++++++++++------- libraries/LiquidCrystal/src/LiquidCrystal.h | 5 +- 2 files changed, 37 insertions(+), 24 deletions(-) diff --git a/libraries/LiquidCrystal/src/LiquidCrystal.cpp b/libraries/LiquidCrystal/src/LiquidCrystal.cpp index b3768340099..28c8811d441 100644 --- a/libraries/LiquidCrystal/src/LiquidCrystal.cpp +++ b/libraries/LiquidCrystal/src/LiquidCrystal.cpp @@ -6,7 +6,7 @@ #include "Arduino.h" // Minimum time between falling edges of E (enable pin to do writes) -#define _MIN_WRITE_DELAY 80 +#define _LCD_COMMAND_DELAY 40 // When the display powers up, it is configured as follows: // @@ -121,19 +121,19 @@ void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { // figure 24, pg 46 // we start in 8bit mode, try to set 4 bit mode - write4bits(0x03); + writebits(0x03, 4, 1); delayMicroseconds(4500); // wait min 4.1ms // second try - write4bits(0x03); + writebits(0x03, 4, 1); delayMicroseconds(4500); // wait min 4.1ms // third go! - write4bits(0x03); + writebits(0x03, 4, 1); delayMicroseconds(150); // finally, set to 4-bit interface - write4bits(0x02); + writebits(0x02, 4, 1); } else { // this is according to the hitachi HD44780 datasheet // page 45 figure 23 @@ -263,6 +263,7 @@ void LiquidCrystal::noAutoscroll(void) { command(LCD_ENTRYMODESET | _displaymode); } + // Allows us to fill the first 8 CGRAM locations // with custom characters void LiquidCrystal::createChar(uint8_t location, uint8_t charmap[]) { @@ -296,38 +297,51 @@ void LiquidCrystal::send(uint8_t value, uint8_t mode) { } if (_displayfunction & LCD_8BITMODE) { - write8bits(value); + writebits(value, 8, 0); } else { - write4bits(value>>4); - write4bits(value); + writebits(value>>4, 4, 0); + writebits(value, 4, 1); } } -void LiquidCrystal::pulseEnable(void) { + +/* pulseEnable once data and RS set pulse enable line to send data in 4/8 bit mode + + Checks when last falling edge of enable was and if sending a NEW command + delays for time to get to _LCD_COMMAND_DELAY to ensure controller ready + + When in 4 bit mode 2nd nibble can be sent at minimum delay forEnable high + time delay 1us + + Parameter type - 0 = new command start + 1 = 2nd nibble for 4 bit mode (needs 1us delay + NOT _LCD_COMMAND_DELAY) +*/ +void LiquidCrystal::pulseEnable(uint8_t type) { unsigned long _delaymicros; digitalWrite(_enable_pin, HIGH); _delaymicros = micros( ) - _oldmicros; // PREVIOUS commands need > 37us to settle - if( _delaymicros < _MIN_WRITE_DELAY ) - delayMicroseconds( _MIN_WRITE_DELAY - _delaymicros ); // wait time for delay + if( _delaymicros < _LCD_COMMAND_DELAY && type == 0 ) + delayMicroseconds( _LCD_COMMAND_DELAY - _delaymicros ); // wait time for delay else delayMicroseconds(1); // enable pulse HIGH must be >450ns digitalWrite(_enable_pin, LOW); _oldmicros = micros( ); // save time to check next time } -void LiquidCrystal::write4bits(uint8_t value) { - for (int i = 0; i < 4; i++) { - digitalWrite(_data_pins[i], (value >> i) & 0x01); - } - pulseEnable(); -} +/* writebits transfer correct number of bits to output and then call pulse enable -void LiquidCrystal::write8bits(uint8_t value) { - for (int i = 0; i < 8; i++) { + Parameters value - 4 or 8 bits to send + in 4 bit mode shift top 4 bits right before calling + bits - value 4 or 8 for bits to send + type - 0 = new command start + 1 = 2nd nibble for 4 bit mode (needs 1us delay NOT _MIN_WRITE_DELAY +*/ +void LiquidCrystal::writebits(uint8_t value, uint8_t bits, uint8_t type) { + for (int i = 0; i < bits; i++) { digitalWrite(_data_pins[i], (value >> i) & 0x01); } - - pulseEnable(); + pulseEnable( type ); } diff --git a/libraries/LiquidCrystal/src/LiquidCrystal.h b/libraries/LiquidCrystal/src/LiquidCrystal.h index 44c239529f2..ca00e89ef6f 100644 --- a/libraries/LiquidCrystal/src/LiquidCrystal.h +++ b/libraries/LiquidCrystal/src/LiquidCrystal.h @@ -86,9 +86,8 @@ class LiquidCrystal : public Print { using Print::write; private: void send(uint8_t, uint8_t); - void write4bits(uint8_t); - void write8bits(uint8_t); - void pulseEnable(); + void writebits(uint8_t, uint8_t, uint8_t); + void pulseEnable( uint8_t ); uint8_t _rs_pin; // LOW: command. HIGH: character. uint8_t _rw_pin; // LOW: write to LCD. HIGH: read from LCD. From 037e6f6642c463fe3a1cd7bc499aeeda48b0141c Mon Sep 17 00:00:00 2001 From: techpaul Date: Thu, 11 Feb 2016 20:52:38 +0000 Subject: [PATCH 6/6] Add method to extend Command Delay beyond default 40us to max of 200us tested on Due and Mega --- libraries/LiquidCrystal/src/LiquidCrystal.cpp | 101 +++++++++++------- libraries/LiquidCrystal/src/LiquidCrystal.h | 8 +- 2 files changed, 65 insertions(+), 44 deletions(-) diff --git a/libraries/LiquidCrystal/src/LiquidCrystal.cpp b/libraries/LiquidCrystal/src/LiquidCrystal.cpp index 28c8811d441..276d0d56d8b 100644 --- a/libraries/LiquidCrystal/src/LiquidCrystal.cpp +++ b/libraries/LiquidCrystal/src/LiquidCrystal.cpp @@ -6,22 +6,23 @@ #include "Arduino.h" // Minimum time between falling edges of E (enable pin to do writes) -#define _LCD_COMMAND_DELAY 40 +#define _LCD_COMMAND_DELAY 40 +#define _MAX_COMMAND_DELAY 200 // When the display powers up, it is configured as follows: // // 1. Display clear -// 2. Function set: -// DL = 1; 8-bit interface data -// N = 0; 1-line display -// F = 0; 5x8 dot character font -// 3. Display on/off control: -// D = 0; Display off -// C = 0; Cursor off -// B = 0; Blinking off -// 4. Entry mode set: -// I/D = 1; Increment by 1 -// S = 0; No shift +// 2. Function set: +// DL = 1; 8-bit interface data +// N = 0; 1-line display +// F = 0; 5x8 dot character font +// 3. Display on/off control: +// D = 0; Display off +// C = 0; Cursor off +// B = 0; Blinking off +// 4. Entry mode set: +// I/D = 1; Increment by 1 +// S = 0; No shift // // Note, however, that resetting the Arduino doesn't reset the LCD, so we // can't assume that its in that state when a sketch starts (and the @@ -60,22 +61,22 @@ void LiquidCrystal::init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t en _rs_pin = rs; _rw_pin = rw; _enable_pin = enable; - + _data_pins[0] = d0; _data_pins[1] = d1; _data_pins[2] = d2; - _data_pins[3] = d3; + _data_pins[3] = d3; _data_pins[4] = d4; _data_pins[5] = d5; _data_pins[6] = d6; - _data_pins[7] = d7; + _data_pins[7] = d7; if (fourbitmode) _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS; - else + else _displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS; - - begin(16, 1); + _comm_delay = _LCD_COMMAND_DELAY; // Default command delay + begin(16, 1); } void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { @@ -84,7 +85,7 @@ void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { } _numlines = lines; - setRowOffsets(0x00, 0x40, 0x00 + cols, 0x40 + cols); + setRowOffsets(0x00, 0x40, 0x00 + cols, 0x40 + cols); // for some 1 line displays you can select a 10 pixel high font if ((dotsize != LCD_5x8DOTS) && (lines == 1)) { @@ -93,28 +94,28 @@ void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { pinMode(_rs_pin, OUTPUT); // we can save 1 pin by not using RW. Indicate by passing 255 instead of pin# - if (_rw_pin != 255) { + if (_rw_pin != 255) { pinMode(_rw_pin, OUTPUT); } pinMode(_enable_pin, OUTPUT); - + // Do these once, instead of every time a character is drawn for speed reasons. for (int i=0; i<((_displayfunction & LCD_8BITMODE) ? 8 : 4); ++i) { pinMode(_data_pins[i], OUTPUT); - } + } // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION! // according to datasheet, we need at least 40ms after power rises above 2.7V // before sending commands. Arduino can turn on way before 4.5V so we'll wait 50 - delayMicroseconds(50000); + delayMicroseconds(50000); // Now we pull both RS and R/W low to begin commands digitalWrite(_rs_pin, LOW); digitalWrite(_enable_pin, LOW); - if (_rw_pin != 255) { + if (_rw_pin != 255) { digitalWrite(_rw_pin, LOW); } - + //put the LCD into 4 bit or 8 bit mode if (! (_displayfunction & LCD_8BITMODE)) { // this is according to the hitachi HD44780 datasheet @@ -127,7 +128,7 @@ void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { // second try writebits(0x03, 4, 1); delayMicroseconds(4500); // wait min 4.1ms - + // third go! writebits(0x03, 4, 1); delayMicroseconds(150); @@ -151,10 +152,10 @@ void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { } // finally, set # lines, font size, etc. - command(LCD_FUNCTIONSET | _displayfunction); + command(LCD_FUNCTIONSET | _displayfunction); // turn the display on with no cursor or blinking default - _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF; + _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF; display(); // clear it off @@ -197,7 +198,7 @@ void LiquidCrystal::setCursor(uint8_t col, uint8_t row) if ( row >= _numlines ) { row = _numlines - 1; // we count rows starting w/0 } - + command(LCD_SETDDRAMADDR | (col + _row_offsets[row])); } @@ -274,6 +275,24 @@ void LiquidCrystal::createChar(uint8_t location, uint8_t charmap[]) { } } + +/* New method that if default command delay is not long enough + to set a new value between + _LCD_COMMAND_DELAY (default 40 us) + _MAX_COMMAND_DELAY (default 200 us) + + Should be called before you call begin method + + returns 0 for success + -1 for error (invalid parameter) +*/ +int LiquidCrystal::setCommandDelay( uint8_t delay ) { + if( delay >= _LCD_COMMAND_DELAY && delay <= _MAX_COMMAND_DELAY ) { + _comm_delay = delay; + return 0; + } +return -1; +} /*********** mid level commands, for sending data/cmds */ inline void LiquidCrystal::command(uint8_t value) { @@ -292,12 +311,12 @@ void LiquidCrystal::send(uint8_t value, uint8_t mode) { digitalWrite(_rs_pin, mode); // if there is a RW pin indicated, set it low to Write - if (_rw_pin != 255) { + if (_rw_pin != 255) { digitalWrite(_rw_pin, LOW); } - + if (_displayfunction & LCD_8BITMODE) { - writebits(value, 8, 0); + writebits(value, 8, 0); } else { writebits(value>>4, 4, 0); writebits(value, 4, 1); @@ -308,22 +327,22 @@ void LiquidCrystal::send(uint8_t value, uint8_t mode) { /* pulseEnable once data and RS set pulse enable line to send data in 4/8 bit mode Checks when last falling edge of enable was and if sending a NEW command - delays for time to get to _LCD_COMMAND_DELAY to ensure controller ready - - When in 4 bit mode 2nd nibble can be sent at minimum delay forEnable high + delays for time to get up to _comm_delay to ensure controller ready + + When in 4 bit mode 2nd nibble can be sent at minimum delay for Enable high time delay 1us Parameter type - 0 = new command start - 1 = 2nd nibble for 4 bit mode (needs 1us delay - NOT _LCD_COMMAND_DELAY) + 1 = 2nd nibble for 4 bit mode (needs 1us delay + NOT _comm_delay) */ void LiquidCrystal::pulseEnable(uint8_t type) { - unsigned long _delaymicros; - + unsigned long _delaymicros; + digitalWrite(_enable_pin, HIGH); _delaymicros = micros( ) - _oldmicros; // PREVIOUS commands need > 37us to settle - if( _delaymicros < _LCD_COMMAND_DELAY && type == 0 ) - delayMicroseconds( _LCD_COMMAND_DELAY - _delaymicros ); // wait time for delay + if( _delaymicros < _comm_delay && type == 0 ) + delayMicroseconds( _comm_delay - _delaymicros ); // wait time for delay else delayMicroseconds(1); // enable pulse HIGH must be >450ns digitalWrite(_enable_pin, LOW); diff --git a/libraries/LiquidCrystal/src/LiquidCrystal.h b/libraries/LiquidCrystal/src/LiquidCrystal.h index ca00e89ef6f..a0f728095f9 100644 --- a/libraries/LiquidCrystal/src/LiquidCrystal.h +++ b/libraries/LiquidCrystal/src/LiquidCrystal.h @@ -58,7 +58,7 @@ class LiquidCrystal : public Print { void init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7); - + void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS); void clear(); @@ -76,13 +76,14 @@ class LiquidCrystal : public Print { void rightToLeft(); void autoscroll(); void noAutoscroll(); + int setCommandDelay( uint8_t ); void setRowOffsets(int row1, int row2, int row3, int row4); void createChar(uint8_t, uint8_t[]); - void setCursor(uint8_t, uint8_t); + void setCursor(uint8_t, uint8_t); virtual size_t write(uint8_t); void command(uint8_t); - + using Print::write; private: void send(uint8_t, uint8_t); @@ -93,6 +94,7 @@ class LiquidCrystal : public Print { uint8_t _rw_pin; // LOW: write to LCD. HIGH: read from LCD. uint8_t _enable_pin; // activated by a HIGH pulse. uint8_t _data_pins[8]; + uint8_t _comm_delay; // Delay between commands by default _LCD_COMMAND_DELAY uint8_t _displayfunction; uint8_t _displaycontrol;