wp/Marlin-2-0-x-Anycubic-i3-MEGA-S
1
0
Fork 0
Code Issues 28 Pull Requests 2 Actions Packages Projects Releases 30 Wiki Activity

Merge pull request #400 from stklcode/feature/lcd-serial

Browse Source 
use LCD_SERIAL for Anycubic touchscreen communication
This commit is contained in:
Oliver Köster
2022-12-21 21:40:05 +01:00
committed by GitHub
parent bd0f3a9aa5 fd58245bd2
commit 4fc8948e0b
4 changed files with 264 additions and 839 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Marlin/Configuration.h
View File

@@ -45,6 +45,8 @@
// #define ANYCUBIC_TFT_DEBUG
// #define POWER_OUTAGE_TEST
#define LCD_SERIAL_PORT 3
#define EXT_LEVEL_HIGH 0.1
/*

279
Marlin/src/lcd/HardwareSerial.cpp
View File

@@ -1,279 +0,0 @@
/*
HardwareSerial.cpp - Hardware serial library for Wiring
Copyright (c) 2006 Nicholas Zambetti. 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
Modified 23 November 2006 by David A. Mellis
Modified 28 September 2010 by Mark Sproul
Modified 14 August 2012 by Alarus
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "Arduino.h"
#include "wiring_private.h"
#include "../inc/MarlinConfig.h"
#ifdef ANYCUBIC_TOUCHSCREEN
// this next line disables the entire HardwareSerial.cpp,
// this is so I can support Attiny series and any other chip without a uart
#if defined(UBRR3H)
#include "HardwareSerial.h"
millis_t previous_cmd_ms = 0;
// 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.
#if (RAMEND < 1000)
#define SERIAL_BUFFER_SIZE 16
#else
#define SERIAL_BUFFER_SIZE 64
#endif
struct ring_buffer {
unsigned char buffer[SERIAL_BUFFER_SIZE];
volatile unsigned int head;
volatile unsigned int tail;
};
#if defined(UBRR3H)
ring_buffer rx_buffer_ajg = {{0}, 0, 0};
ring_buffer tx_buffer_ajg = {{0}, 0, 0};
#endif
inline void store_char(unsigned char c, ring_buffer *buffer) {
unsigned int i = ((unsigned int)(buffer->head + 1)) % SERIAL_BUFFER_SIZE;
// if we should be storing the received character into the location
// just before the tail (meaning that the head would advance to the
// current location of the tail), we're about to overflow the buffer
// and so we don't write the character or advance the head.
if (i != buffer->tail) {
buffer->buffer[buffer->head] = c;
buffer->head = i;
}
}
#if defined(USART3_RX_vect) && defined(UDR3)
void serialEvent3() __attribute__((weak));
void serialEvent3() {}
#define serialEvent3_implemented
ISR(USART3_RX_vect)
{
if (bit_is_clear(UCSR3A, UPE3)) {
unsigned char c = UDR3;
store_char(c, &rx_buffer_ajg);
}
}
#endif
#ifdef USART3_UDRE_vect
ISR(USART3_UDRE_vect)
{
if (tx_buffer_ajg.head == tx_buffer_ajg.tail) {
cbi(UCSR3B, UDRIE3);
}
else {
// There is more data in the output buffer. Send the next byte
unsigned char c = tx_buffer_ajg.buffer[tx_buffer_ajg.tail];
tx_buffer_ajg.tail = (tx_buffer_ajg.tail + 1) % SERIAL_BUFFER_SIZE;
UDR3 = c;
}
}
#endif
HardwareSerialClass::HardwareSerialClass(ring_buffer *rx_buffer, ring_buffer *tx_buffer,
volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
volatile uint8_t *ucsrc, volatile uint8_t *udr,
uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udrie, uint8_t u2x) {
_rx_buffer = rx_buffer;
_tx_buffer = tx_buffer;
_ubrrh = ubrrh;
_ubrrl = ubrrl;
_ucsra = ucsra;
_ucsrb = ucsrb;
_ucsrc = ucsrc;
_udr = udr;
_rxen = rxen;
_txen = txen;
_rxcie = rxcie;
_udrie = udrie;
_u2x = u2x;
}
// Public Methods //////////////////////////////////////////////////////////////
void HardwareSerialClass::begin(unsigned long baud) {
uint16_t baud_setting;
bool use_u2x = true;
#if F_CPU == 16000000UL
if (baud == 57600)
use_u2x = false;
#endif
try_again:
if (use_u2x) {
*_ucsra = 1 << _u2x;
baud_setting = (F_CPU / 4 / baud - 1) / 2;
}
else {
*_ucsra = 0;
baud_setting = (F_CPU / 8 / baud - 1) / 2;
}
if ((baud_setting > 4095) && use_u2x) {
use_u2x = false;
goto try_again;
}
// assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
*_ubrrh = baud_setting >> 8;
*_ubrrl = baud_setting;
transmitting = false;
sbi(*_ucsrb, _rxen);
sbi(*_ucsrb, _txen);
sbi(*_ucsrb, _rxcie);
cbi(*_ucsrb, _udrie);
}
void HardwareSerialClass::begin(unsigned long baud, byte config) {
uint16_t baud_setting;
bool use_u2x = true;
#if F_CPU == 16000000UL
if (baud == 57600)
use_u2x = false;
#endif
try_again:
if (use_u2x) {
*_ucsra = 1 << _u2x;
baud_setting = (F_CPU / 4 / baud - 1) / 2;
}
else {
*_ucsra = 0;
baud_setting = (F_CPU / 8 / baud - 1) / 2;
}
if ((baud_setting > 4095) && use_u2x) {
use_u2x = false;
goto try_again;
}
// assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
*_ubrrh = baud_setting >> 8;
*_ubrrl = baud_setting;
// set the data bits, parity, and stop bits
#if defined(__AVR_ATmega8__)
config |= 0x80; // select UCSRC register (shared with UBRRH)
#endif
*_ucsrc = config;
sbi(*_ucsrb, _rxen);
sbi(*_ucsrb, _txen);
sbi(*_ucsrb, _rxcie);
cbi(*_ucsrb, _udrie);
}
void HardwareSerialClass::end() {
// wait for transmission of outgoing data
while (_tx_buffer->head != _tx_buffer->tail);
cbi(*_ucsrb, _rxen);
cbi(*_ucsrb, _txen);
cbi(*_ucsrb, _rxcie);
cbi(*_ucsrb, _udrie);
// clear any received data
_rx_buffer->head = _rx_buffer->tail;
}
int HardwareSerialClass::available(void) {
return (int)(SERIAL_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % SERIAL_BUFFER_SIZE;
}
int HardwareSerialClass::peek(void) {
if (_rx_buffer->head == _rx_buffer->tail)
return -1;
else
return _rx_buffer->buffer[_rx_buffer->tail];
}
int HardwareSerialClass::read(void) {
// if the head isn't ahead of the tail, we don't have any characters
if (_rx_buffer->head == _rx_buffer->tail) {
return -1;
}
else {
unsigned char c = _rx_buffer->buffer[_rx_buffer->tail];
_rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE;
return c;
}
}
void HardwareSerialClass::flush() {
// UDR is kept full while the buffer is not empty, so TXC triggers when EMPTY && SENT
while (transmitting && !(*_ucsra & _BV(TXC0)));
transmitting = false;
}
size_t HardwareSerialClass::write(uint8_t c) {
unsigned int i = (_tx_buffer->head + 1) % SERIAL_BUFFER_SIZE;
// If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit
// ???: return 0 here instead?
while (i == _tx_buffer->tail);
_tx_buffer->buffer[_tx_buffer->head] = c;
_tx_buffer->head = i;
sbi(*_ucsrb, _udrie);
// clear the TXC bit -- "can be cleared by writing a one to its bit location"
transmitting = true;
sbi(*_ucsra, TXC0);
return 1;
}
HardwareSerialClass::operator bool() {
return true;
}
#if defined(UBRR3H)
HardwareSerialClass HardwareSerial(&rx_buffer_ajg, &tx_buffer_ajg, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UCSR3C, &UDR3, RXEN3, TXEN3, RXCIE3, UDRIE3, U2X3);
#endif
#endif // if defined(UBRR3H)
#endif // whole file

143
Marlin/src/lcd/HardwareSerial.h
View File

@@ -1,143 +0,0 @@
/*
HardwareSerial.h - Hardware serial library for Wiring
Copyright (c) 2006 Nicholas Zambetti. 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
Modified 28 September 2010 by Mark Sproul
Modified 14 August 2012 by Alarus
*/
#ifndef hardwareserial_h
#define hardwareserial_h
#include <inttypes.h>
#include <avr/pgmspace.h>
#include "Stream.h"
#define FORCE_INLINE __attribute__((always_inline)) inline
struct ring_buffer;
class HardwareSerialClass : public Stream
{
private:
ring_buffer *_rx_buffer;
ring_buffer *_tx_buffer;
volatile uint8_t *_ubrrh;
volatile uint8_t *_ubrrl;
volatile uint8_t *_ucsra;
volatile uint8_t *_ucsrb;
volatile uint8_t *_ucsrc;
volatile uint8_t *_udr;
uint8_t _rxen;
uint8_t _txen;
uint8_t _rxcie;
uint8_t _udrie;
uint8_t _u2x;
bool transmitting;
public:
HardwareSerialClass(ring_buffer *rx_buffer, ring_buffer *tx_buffer,
volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
volatile uint8_t *ucsrc, volatile uint8_t *udr,
uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udrie, uint8_t u2x);
void begin(unsigned long);
void begin(unsigned long, uint8_t);
void end();
virtual int available(void);
virtual int peek(void);
virtual int read(void);
virtual void flush(void);
virtual size_t write(uint8_t);
inline size_t write(unsigned long n) { return write((uint8_t)n); }
inline size_t write(long n) { return write((uint8_t)n); }
inline size_t write(unsigned int n) { return write((uint8_t)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
operator bool();
};
// Define config for Serial.begin(baud, config);
#define SERIAL_5N1 0x00
#define SERIAL_6N1 0x02
#define SERIAL_7N1 0x04
#define SERIAL_8N1 0x06
#define SERIAL_5N2 0x08
#define SERIAL_6N2 0x0A
#define SERIAL_7N2 0x0C
#define SERIAL_8N2 0x0E
#define SERIAL_5E1 0x20
#define SERIAL_6E1 0x22
#define SERIAL_7E1 0x24
#define SERIAL_8E1 0x26
#define SERIAL_5E2 0x28
#define SERIAL_6E2 0x2A
#define SERIAL_7E2 0x2C
#define SERIAL_8E2 0x2E
#define SERIAL_5O1 0x30
#define SERIAL_6O1 0x32
#define SERIAL_7O1 0x34
#define SERIAL_8O1 0x36
#define SERIAL_5O2 0x38
#define SERIAL_6O2 0x3A
#define SERIAL_7O2 0x3C
#define SERIAL_8O2 0x3E
#if defined(UBRR3H)
extern HardwareSerialClass HardwareSerial;
#endif
extern void serialEventRun(void) __attribute__((weak));
#define HARDWARE_SERIAL_PROTOCOL(x) (HardwareSerial.print(x))
#define HARDWARE_SERIAL_PROTOCOL_F(x, y) (HardwareSerial.print(x, y))
#define HARDWARE_SERIAL_PROTOCOLPGM(x) (HardwareSerialprintPGM(PSTR(x)))
#define HARDWARE_SERIAL_(x) (HardwareSerial.print(x), HardwareSerial.write('\n'))
#define HARDWARE_SERIAL_PROTOCOLLN(x) (HardwareSerial.print(x), HardwareSerial.write('\r'), HardwareSerial.write('\n'))
#define HARDWARE_SERIAL_PROTOCOLLNPGM(x) (HardwareSerialprintPGM(PSTR(x)), HardwareSerial.write('\r'), HardwareSerial.write('\n'))
#define HARDWARE_SERIAL_START() (HardwareSerial.write('\r'), HardwareSerial.write('\n'))
#define HARDWARE_SERIAL_CMD_SEND(x) (HardwareSerialprintPGM(PSTR(x)), HardwareSerial.write('\r'), HardwareSerial.write('\n'))
#define HARDWARE_SERIAL_ENTER() (HardwareSerial.write('\r'), HardwareSerial.write('\n'))
#define HARDWARE_SERIAL_SPACE() (HardwareSerial.write(' '))
const char newErr[] PROGMEM = "ERR ";
const char newSucc[] PROGMEM = "OK";
#define HARDWARE_SERIAL_ERROR_START (HardwareSerialprintPGM(newErr))
#define HARDWARE_SERIAL_ERROR(x) HARDWARE_SERIAL_PROTOCOL(x)
#define HARDWARE_SERIAL_ERRORPGM(x) HARDWARE_SERIAL_PROTOCOLPGM(x)
#define HARDWARE_SERIAL_ERRORLN(x) HARDWARE_SERIAL_PROTOCOLLN(x)
#define HARDWARE_SERIAL_ERRORLNPGM(x) HARDWARE_SERIAL_PROTOCOLLNPGM(x)
#define HARDWARE_SERIAL_ECHOLN(x) HARDWARE_SERIAL_PROTOCOLLN(x)
#define HARDWARE_SERIAL_SUCC_START (HardwareSerialprintPGM(newSucc))
#define HARDWARE_SERIAL_ECHOPAIR(name, value) (serial_echopair_P(PSTR(name), (value)))
#define HARDWARE_SERIAL_ECHOPGM(x) HARDWARE_SERIAL_PROTOCOLPGM(x)
#define HARDWARE_SERIAL_ECHO(x) HARDWARE_SERIAL_PROTOCOL(x)
FORCE_INLINE void HardwareSerialprintPGM(const char *str) {
char ch = pgm_read_byte(str);
while (ch)
{
HardwareSerial.write(ch);
ch = pgm_read_byte(++str);
}
}
#endif // ifndef hardwareserial_h

679
Marlin/src/lcd/anycubic_touchscreen.cpp
View File

File diff suppressed because it is too large Load Diff