mirrors
/
Tasmota
mirror of https://github.com/arendst/Tasmota.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor Arduino Slave

This commit is contained in:
Theo Arends 2019-10-21 12:25:22 +02:00
parent 4d21a47edb
commit aaf6f90507
3 changed files with 92 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
sonoff/my_user_config.h
View File

@ -542,9 +542,8 @@
//#define USE_A4988_STEPPER // Add support for A4988/DRV8825 stepper-motor-driver-circuit (+10k5 code)
//#define USE_ARDUINO_SLAVE // Add support for Arduino Uno/Pro Mini via serial interface including flashing (+2k3 code, 44 mem)
// #define USE_ARDUINO_FLASH_SPEED 57600 // Usually 57600 for 3.3V variants and 115200 for 5V variants
// #define USE_ARDUINO_SERIAL_SPEED 57600 // Depends on the sketch that is running on the Uno/Pro Mini
// #define USE_ARDUINO_INVERT_RESET
#define USE_ARDUINO_FLASH_SPEED 57600 // Usually 57600 for 3.3V variants and 115200 for 5V variants
#define USE_ARDUINO_SERIAL_SPEED 57600 // Depends on the sketch that is running on the Uno/Pro Mini
// -- End of general directives -------------------

8
sonoff/sonoff_template.h
View File

@ -210,7 +210,8 @@ enum UserSelectablePins {
GPIO_EXS_ENABLE, // EXS MCU Enable
GPIO_ARDUINO_TXD, // Arduino Slave TX
GPIO_ARDUINO_RXD, // Arduino Slave RX
GPIO_ARDUINO_RESET, // Arduino Reset Pin
GPIO_ARDUINO_RST, // Arduino Reset Pin
GPIO_ARDUINO_RST_INV, // Arduino Reset Pin inverted
GPIO_SENSOR_END };
// Programmer selectable GPIO functionality
@ -289,7 +290,7 @@ const char kSensorNames[] PROGMEM =
D_SENSOR_DDSU666_TX "|" D_SENSOR_DDSU666_RX "|"
D_SENSOR_SM2135_CLK "|" D_SENSOR_SM2135_DAT "|"
D_SENSOR_DEEPSLEEP "|" D_SENSOR_EXS_ENABLE "|"
D_SENSOR_ARDUINO_TX "|" D_SENSOR_ARDUINO_RX "|" D_SENSOR_ARDUINO_RESET "|"
D_SENSOR_ARDUINO_TX "|" D_SENSOR_ARDUINO_RX "|" D_SENSOR_ARDUINO_RESET "|" D_SENSOR_ARDUINO_RESET "i|"
;
const char kSensorNamesFixed[] PROGMEM =
@ -705,7 +706,8 @@ const uint8_t kGpioNiceList[] PROGMEM = {
#ifdef USE_ARDUINO_SLAVE
GPIO_ARDUINO_TXD, // Arduino Slave TX
GPIO_ARDUINO_RXD, // Arduino Slave RX
GPIO_ARDUINO_RESET, // Arduino Reset Pin
GPIO_ARDUINO_RST, // Arduino Reset Pin
GPIO_ARDUINO_RST_INV, // Arduino Reset Pin inverted
#endif
#ifdef USE_RDM6300
GPIO_RDM6300_RX,

150
sonoff/xdrv_31_arduino_slave.ino
View File

@ -18,9 +18,11 @@
*/
#ifdef USE_ARDUINO_SLAVE
/*********************************************************************************************\
* Arduino slave
\*********************************************************************************************/
#include <TasmotaSerial.h>
#include <ArduinoHexParse.h>
#define XDRV_31 31
#define CONST_STK_CRC_EOP 0x20
@ -32,48 +34,47 @@
#define CMND_STK_LOAD_ADDRESS 0x55
#define CMND_STK_PROG_PAGE 0x64
uint32_t as_spi_hex_size = 0;
uint8_t as_spi_sector_start = 0x96;
uint8_t as_spi_sector_counter = 0x96;
uint8_t as_spi_sector_cursor = 0;
bool as_flashing = false;
#include <TasmotaSerial.h>
#include <ArduinoHexParse.h>
uint8_t as_type = 0;
struct ASLAVE {
uint32_t spi_hex_size = 0;
uint32_t spi_sector_counter = 0;
uint8_t spi_sector_cursor = 0;
uint8_t inverted = LOW;
bool type = false;
bool flashing = false;
} ASlave;
TasmotaSerial *ArduinoSlave_Serial;
#define XDRV_31 31
uint32_t ArduinoSlaveFlashStart(void)
{
return (ESP.getSketchSize() / SPI_FLASH_SEC_SIZE) + 2; // Stay on the safe side
}
uint8_t ArduinoSlave_UpdateInit(void)
{
as_spi_hex_size = 0;
as_spi_sector_counter = as_spi_sector_start; // Reset the pre-defined write address where firmware will temporarily be stored
as_spi_sector_cursor = 0;
ASlave.spi_hex_size = 0;
ASlave.spi_sector_counter = ArduinoSlaveFlashStart(); // Reset the pre-defined write address where firmware will temporarily be stored
ASlave.spi_sector_cursor = 0;
return 0;
}
void ArduinoSlave_Reset(void)
{
if (as_type) {
#ifdef USE_ARDUINO_INVERT_RESET
digitalWrite(pin[GPIO_ARDUINO_RESET], LOW);
if (ASlave.type) {
digitalWrite(pin[GPIO_ARDUINO_RST], !ASlave.inverted);
delay(1);
digitalWrite(pin[GPIO_ARDUINO_RESET], HIGH);
digitalWrite(pin[GPIO_ARDUINO_RST], ASlave.inverted);
delay(1);
digitalWrite(pin[GPIO_ARDUINO_RESET], LOW);
digitalWrite(pin[GPIO_ARDUINO_RST], !ASlave.inverted);
delay(5);
#else
digitalWrite(pin[GPIO_ARDUINO_RESET], HIGH);
delay(1);
digitalWrite(pin[GPIO_ARDUINO_RESET], LOW);
delay(1);
digitalWrite(pin[GPIO_ARDUINO_RESET], HIGH);
delay(5);
#endif
}
}
uint8_t ArduinoSlave_waitForSerialData(int dataCount, int timeout) {
uint8_t ArduinoSlave_waitForSerialData(int dataCount, int timeout)
{
int timer = 0;
while (timer < timeout) {
if (ArduinoSlave_Serial->available() >= dataCount) {
@ -85,24 +86,27 @@ uint8_t ArduinoSlave_waitForSerialData(int dataCount, int timeout) {
return 0;
}
byte ArduinoSlave_sendBytes(byte* bytes, int count) {
uint8_t ArduinoSlave_sendBytes(uint8_t* bytes, int count)
{
ArduinoSlave_Serial->write(bytes, count);
ArduinoSlave_waitForSerialData(2, 1000);
byte sync = ArduinoSlave_Serial->read();
byte ok = ArduinoSlave_Serial->read();
uint8_t sync = ArduinoSlave_Serial->read();
uint8_t ok = ArduinoSlave_Serial->read();
if (sync == 0x14 && ok == 0x10) {
return 1;
}
return 0;
}
byte ArduinoSlave_execCmd(byte cmd) {
byte bytes[] = { cmd, CONST_STK_CRC_EOP };
uint8_t ArduinoSlave_execCmd(uint8_t cmd)
{
uint8_t bytes[] = { cmd, CONST_STK_CRC_EOP };
return ArduinoSlave_sendBytes(bytes, 2);
}
byte ArduinoSlave_execParam(byte cmd, byte* params, int count) {
byte bytes[32];
uint8_t ArduinoSlave_execParam(uint8_t cmd, uint8_t* params, int count)
{
uint8_t bytes[32];
bytes[0] = cmd;
int i = 0;
while (i < count) {
@ -120,8 +124,8 @@ uint8_t ArduinoSlave_exitProgMode(void)
void ArduinoSlave_SetupFlash(void)
{
byte ProgParams[] = {0x86,0x00,0x00,0x01,0x01,0x01,0x01,0x03,0xff,0xff,0xff,0xff,0x00,0x80,0x04,0x00,0x00,0x00,0x80,0x00};
byte ExtProgParams[] = {0x05,0x04,0xd7,0xc2,0x00};
uint8_t ProgParams[] = {0x86,0x00,0x00,0x01,0x01,0x01,0x01,0x03,0xff,0xff,0xff,0xff,0x00,0x80,0x04,0x00,0x00,0x00,0x80,0x00};
uint8_t ExtProgParams[] = {0x05,0x04,0xd7,0xc2,0x00};
ArduinoSlave_Serial->begin(USE_ARDUINO_FLASH_SPEED);
if (ArduinoSlave_Serial->hardwareSerial()) {
ClaimSerial();
@ -133,14 +137,15 @@ void ArduinoSlave_SetupFlash(void)
ArduinoSlave_execCmd(CMND_STK_ENTER_PROGMODE); // Enter programming mode
}
uint8_t ArduinoSlave_loadAddress(byte adrHi, byte adrLo) {
byte params[] = { adrHi, adrLo };
uint8_t ArduinoSlave_loadAddress(uint8_t adrHi, uint8_t adrLo)
{
uint8_t params[] = { adrHi, adrLo };
return ArduinoSlave_execParam(CMND_STK_LOAD_ADDRESS, params, sizeof(params));
}
void ArduinoSlave_FlashPage(byte* address, byte* data)
void ArduinoSlave_FlashPage(uint8_t* address, uint8_t* data)
{
byte Header[] = {CMND_STK_PROG_PAGE, 0x00, 0x80, 0x46};
uint8_t Header[] = {CMND_STK_PROG_PAGE, 0x00, 0x80, 0x46};
ArduinoSlave_loadAddress(address[1], address[0]);
ArduinoSlave_Serial->write(Header, 4);
for (int i = 0; i < 128; i++) {
@ -165,24 +170,25 @@ void ArduinoSlave_Flash(void)
ArduinoSlave_SetupFlash();
flash_buffer = new char[SPI_FLASH_SEC_SIZE];
uint32_t flash_start = ArduinoSlaveFlashStart() * SPI_FLASH_SEC_SIZE;
while (reading) {
ESP.flashRead(0x96000 + read, (uint32_t*)flash_buffer, FLASH_SECTOR_SIZE);
read = read + FLASH_SECTOR_SIZE;
if (read >= as_spi_hex_size) {
ESP.flashRead(flash_start + read, (uint32_t*)flash_buffer, SPI_FLASH_SEC_SIZE);
read = read + SPI_FLASH_SEC_SIZE;
if (read >= ASlave.spi_hex_size) {
reading = false;
}
for (uint16_t ca=0; ca<FLASH_SECTOR_SIZE; ca++) {
for (uint32_t ca = 0; ca < SPI_FLASH_SEC_SIZE; ca++) {
processed++;
if (processed <= as_spi_hex_size) {
if (processed <= ASlave.spi_hex_size) {
if (':' == flash_buffer[ca]) {
position = 0;
}
if (0x0D == flash_buffer[ca]) {
thishexline[position] = 0;
hexParse.ParseLine((byte*)thishexline);
hexParse.ParseLine((uint8_t*)thishexline);
if (hexParse.IsFlashPageReady()) {
byte* page = hexParse.GetFlashPage();
byte* address = hexParse.GetLoadAddress();
uint8_t* page = hexParse.GetFlashPage();
uint8_t* address = hexParse.GetLoadAddress();
ArduinoSlave_FlashPage(address, page);
}
} else {
@ -194,48 +200,54 @@ void ArduinoSlave_Flash(void)
}
}
}
as_flashing = false;
ASlave.flashing = false;
ArduinoSlave_exitProgMode();
restart_flag = 2;
}
void ArduinoSlave_SetFlagFlashing(bool value)
{
as_flashing = value;
ASlave.flashing = value;
}
bool ArduinoSlave_GetFlagFlashing(void)
{
return as_flashing;
return ASlave.flashing ;
}
void ArduinoSlave_WriteBuffer(uint8_t *buf, size_t size)
{
if (0 == as_spi_sector_cursor) { // Starting a new sector write so we need to erase it first
ESP.flashEraseSector(as_spi_sector_counter);
if (0 == ASlave.spi_sector_cursor) { // Starting a new sector write so we need to erase it first
ESP.flashEraseSector(ASlave.spi_sector_counter);
}
as_spi_sector_cursor++;
ESP.flashWrite((as_spi_sector_counter * 0x1000)+((as_spi_sector_cursor-1)*2048), (uint32_t*)buf, size);
as_spi_hex_size = as_spi_hex_size + size;
if (2 == as_spi_sector_cursor) { // The web upload sends 2048 bytes at a time so keep track of the cursor position to reset it for the next flash sector erase
as_spi_sector_cursor = 0;
as_spi_sector_counter++;
ASlave.spi_sector_cursor++;
ESP.flashWrite((ASlave.spi_sector_counter * SPI_FLASH_SEC_SIZE) + ((ASlave.spi_sector_cursor-1)*2048), (uint32_t*)buf, size);
ASlave.spi_hex_size = ASlave.spi_hex_size + size;
if (2 == ASlave.spi_sector_cursor) { // The web upload sends 2048 bytes at a time so keep track of the cursor position to reset it for the next flash sector erase
ASlave.spi_sector_cursor = 0;
ASlave.spi_sector_counter++;
}
}
void ArduinoSlave_Init(void)
{
if (as_type) {
if (ASlave.type) {
return;
}
if ((pin[GPIO_ARDUINO_RXD] < 99) && (pin[GPIO_ARDUINO_TXD] < 99) && (pin[GPIO_ARDUINO_RESET] < 99)) {
if ((pin[GPIO_ARDUINO_RXD] < 99) && (pin[GPIO_ARDUINO_TXD] < 99) &&
((pin[GPIO_ARDUINO_RST] < 99) || (pin[GPIO_ARDUINO_RST_INV] < 99))) {
ArduinoSlave_Serial = new TasmotaSerial(pin[GPIO_ARDUINO_RXD], pin[GPIO_ARDUINO_TXD], 1, 0, 200);
if (ArduinoSlave_Serial->begin(USE_ARDUINO_SERIAL_SPEED)) {
if (ArduinoSlave_Serial->hardwareSerial()) {
ClaimSerial();
}
pinMode(pin[GPIO_ARDUINO_RESET], OUTPUT);
as_type = 1;
if (pin[GPIO_ARDUINO_RST_INV] < 99) {
pin[GPIO_ARDUINO_RST] = pin[GPIO_ARDUINO_RST_INV];
pin[GPIO_ARDUINO_RST_INV] = 99;
ASlave.inverted = HIGH;
}
pinMode(pin[GPIO_ARDUINO_RST], OUTPUT);
ASlave.type = true;
ArduinoSlave_Reset();
AddLog_P2(LOG_LEVEL_INFO, PSTR("Arduino Slave Enabled"));
}
@ -244,11 +256,11 @@ void ArduinoSlave_Init(void)
void ArduinoSlave_Show(bool json)
{
if (as_type) {
char buffer[100];
if (ASlave.type) {
ArduinoSlave_Serial->flush();
ArduinoSlave_Serial->print("JSON");
ArduinoSlave_Serial->find(char(0xFE));
char buffer[100];
uint16_t haveread = ArduinoSlave_Serial->readBytesUntil(char(0xFF), buffer, sizeof(buffer)-1);
buffer[haveread] = '\0';
if (json) {
@ -257,9 +269,14 @@ void ArduinoSlave_Show(bool json)
}
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xdrv31(uint8_t function)
{
bool result = false;
switch (function) {
case FUNC_EVERY_SECOND:
ArduinoSlave_Init();
@ -267,11 +284,8 @@ bool Xdrv31(uint8_t function)
case FUNC_JSON_APPEND:
ArduinoSlave_Show(1);
break;
case FUNC_COMMAND_DRIVER:
break;
default:
break;
}
return result;
}
#endif // USE_ARDUINO_SLAVE