ATmega support

Author: JAndrassy

README.md

@@ -1,12 +1,17 @@
 
-# Arduino library to upload sketch over network to Arduino board (SAMD, nRF5)
+# Arduino library to upload sketch over network to supported Arduino board
 
 This library allows you to update sketches on your board over WiFi or Ethernet.
-It requires an Arduino SAMD board like Zero, M0 or MKR or a nRF5 board supported by nRF5 core.
 
 The library is a modification of the Arduino WiFi101OTA library. For more information about how to use this library please visit
 https://www.arduino.cc/en/Reference/WiFi101OTA
 
+## Supported microcontrollers
+
+* ATmega AVR with at least 64 kB of flash (Arduino Mega, [MegaCore](https://github.com/MCUdude/MegaCore) MCUs, MightyCore 1284p and 644)
+* Arduino SAMD boards like Zero, M0 or MKR 
+* nRF5 board supported by [nRF5 core](https://github.com/sandeepmistry/arduino-nRF5).
+
 ## Supported libraries
 
 * Ethernet library - shields and modules with Wiznet 5100, 5200 and 5500 chips
@@ -21,6 +26,36 @@ UIPEthernet, WiFiSpi and WiFi library don't support UDP multicast for MDNS, so A
 
 WiFiEsp library for esp8266 with AT firmware failed tests and there is no easy fix. 
 
+## ATmega support
+
+The size of networking library and SD library limit the use of ArduinoOTA library to ATmega MCUs with at least 64 kB flash memory. There are other network upload options for here excluded ATmega328p ([Ariadne bootloader](https://github.com/loathingKernel/ariadne-bootloader) for Wiznet chips, [WiFiLink firmware](https://github.com/jandrassy/arduino-firmware-wifilink) for the esp8266).
+
+The ArduinoOTA library ATmega support requires support in bootloader. For the SD storage the MCU must have a 'SD bootloader'. For the InternalStorage the bootloader must be [Optiboot with `copy_flash_pages` function](https://github.com/jandrassy/MegaCore/commit/473c6fcb0a13d2a1d0f5ba578a6ee8933086dc99).
+
+To use remote upload from IDE with SDStorage or InternalStorage, you must [add some lines to platform.txt file](https://github.com/jandrassy/MegaCore/commit/956be74efd5956fde41cae78bac90ff39e536606#diff-3fcd89411a125a3edb58066309f7357c) of your boards package. Packages are located in ~/.arduino15/packages/ on Linux and %userprofile%\AppData\Local\Arduino15\packages\ on Windows (AppData is a hidden folder).
+
+The upload over ArduinoOTA library requires upload of .bin file. To set Arduino IDE to create a .bin file add following lines after existing similar lines:
+
+```
+## Create output (bin file)
+recipe.objcopy.bin.pattern="{compiler.path}{compiler.elf2hex.cmd}" -O binary {compiler.elf2hex.extra_flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.bin"
+```
+
+To configure the network upload tool in IDE add following lines to platform.txt file at the end of section "AVR Uploader/Programmers tools".
+
+```
+tools.avrdude.network_cmd={runtime.tools.arduinoOTA.path}/bin/arduinoOTA
+tools.avrdude.upload.network_pattern="{network_cmd}" -address {serial.port} -port 65280 -username arduino -password "{network.password}" -sketch "{build.path}/{build.project_name}.bin" -upload /sketch -b
+```
+
+The Arduino AVR core has this lines but the tools.avrdude.upload.network_pattern is different (for Yun). Change it to this version. The upload tool is installed with Arduino AVR core package. At least version 1.2 of the arduinoOTA tool is required.
+
+For SDStorage a 'SD bootloader' is required to load the uploaded file from the SD card. There is no good SD bootloader. 2boots works only with not available old types of SD cards and zevero/avr_boot doesn't yet support USB upload of sketch. The SDStorage was tested with zevero/avr_boot. The ATmega_SD example shows how to use this ArduinoOTA library with SD bootloader.
+
+For upload over InternalStorage Optiboot bootloader with 'copy_flash_pages' function is required. Core packages by MCUdude have Optiboot bootloader for all ATmega boards. 
+
+Arduino AVR package doesn't use Optiboot for Arduino Mega. For Arduino Mega install [MegaCore package](https://github.com/MCUdude/MegaCore#boards-manager-installation) and flash the [updated Optiboot bootloader](https://github.com/jandrassy/MegaCore/raw/master/avr/bootloaders/optiboot_flash/atmega2560/optiboot_flash_atmega2560_UART0_115200_16000000L.hex) by replacing the original hex in MegaCore and [using Burn Bootloader in Tools menu in IDE](https://arduino.stackexchange.com/questions/473/how-do-i-burn-the-bootloader). Use MegaCore to upload sketches to Arduino Mega with Optiboot. 
+
 ## nRF5 support
 
 Note: Only nRF51 was tested for now
@@ -36,7 +71,7 @@ tools.openocd.network_cmd={runtime.tools.arduinoOTA.path}/bin/arduinoOTA
 tools.openocd.upload.network_pattern="{network_cmd}" -address {serial.port} -port 65280 -username arduino -password "{network.password}" -sketch "{build.path}/{build.project_name}.bin" -upload /sketch -b
 ```
 
-If you use SoftDevice, stop BLE before applying update. Use `OTEthernet.beforeApply` to register a callbak function. For example in setup `OTEthernet.beforeApply(shutdown);` and add the function to to sketch:
+If you use SoftDevice, stop BLE before applying update. Use `OTEthernet.beforeApply` to register a callback function. For example in setup `ArduinoOTA.beforeApply(shutdown);` and add the function to to sketch:
 
 ```
 void shutdown() {

examples/ATmega_SD/ATmega_SD.ino

@@ -0,0 +1,64 @@
+/*
+
+ This example polls for sketch updates over Ethernet, sketches
+ can be updated by selecting a network port from within
+ the Arduino IDE: Tools -> Port -> Network Ports ...
+
+ Circuit:
+ * W5100, W5200 or W5500 Ethernet shield with SD card attached
+
+ created 13 July 2010
+ by dlf (Metodo2 srl)
+ modified 31 May 2012
+ by Tom Igoe
+ modified 16 January 2017
+ by Sandeep Mistry
+ ArduinoOTA version Dec 2018
+ by Juraj Andrassy
+ */
+ 
+#include <SPI.h>
+#include <SD.h>
+#include <Ethernet.h>
+#include <ArduinoOTA.h>
+
+// Enter a MAC address for your controller below.
+// Newer Ethernet shields have a MAC address printed on a sticker on the shield
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+
+void setup() {
+  //Initialize serial:
+  Serial.begin(9600);
+  while (!Serial);
+
+  // setup SD card
+  Serial.print("Initializing SD card...");
+  if (!SD.begin(SDCARD_SS_PIN)) {
+    Serial.println("initialization failed!");
+    // don't continue:
+    while (true);
+  }
+  Serial.println("initialization done.");
+
+  // start the Ethernet connection:
+  Serial.println("Initialize Ethernet with DHCP:");
+  if (Ethernet.begin(mac) == 0) {
+    Serial.println("Failed to configure Ethernet using DHCP");
+  } else {
+    Serial.print("  DHCP assigned IP ");
+    Serial.println(Ethernet.localIP());
+  }
+
+  // start the OTEthernet library with SD based storage
+  SDStorage.setUpdateFileName("FIRMWARE.BIN"); // for https://github.com/zevero/avr_boot/
+  SDStorage.clear(); // AVR SD bootloaders don't delete the update file
+  ArduinoOTA.begin(Ethernet.localIP(), "Arduino", "password", SDStorage);
+
+}
+
+void loop() {
+  // check for updates
+  ArduinoOTA.poll();
+
+  // add your normal loop code below ...
+}

library.properties

@@ -2,8 +2,9 @@ name=ArduinoOTA
 version=1.0.0
 author=Arduino,Juraj Andrassy
 maintainer=Juraj Andrassy <[email protected]>
-sentence=Update sketches on your SAMD or nRF5 board over WiFi or Ethernet 
+sentence=Update sketches over WiFi or Ethernet 
 paragraph=Based on WiFi101OTA library. http://www.arduino.cc/en/Reference/WiFi101OTA
 category=Other
 url=https://github.com/jandrassy/ArduinoOTA
-architectures=samd,nRF5
+architectures=*
+includes=ArduinoOTA.h

src/ArduinoOTA.h

@@ -20,7 +20,13 @@
 #define _ARDUINOOTA_H_
 
 #include "WiFiOTA.h"
+#ifdef __AVR__
+#if FLASHEND >= 0xFFFF
+#include "InternalStorageAVR.h"
+#endif
+#else
 #include "InternalStorage.h"
+#endif
 #ifdef __SD_H__
 #include "SDStorage.h"
 SDStorageClass SDStorage;
@@ -73,7 +79,7 @@ class ArduinoOTAMdnsClass : public ArduinoOTAClass<NetServer, NetClient> {
 
 };
 
-#if defined(ethernet_h_) // Ethernet library
+#if defined(ethernet_h_) || defined(ethernet_h) // Ethernet library
 ArduinoOTAMdnsClass  <EthernetServer, EthernetClient, EthernetUDP>   ArduinoOTA;
 
 #elif defined(WiFiNINA_h) || defined(WIFI_H) // NINA and WiFi101

src/InternalStorage.cpp

@@ -21,6 +21,8 @@
  by Juraj Andrassy
 */
 
+#ifndef __AVR__
+
 #include <Arduino.h>
 
 #include "InternalStorage.h"
@@ -153,3 +155,5 @@ long InternalStorageClass::maxSize()
 }
 
 InternalStorageClass InternalStorage;
+
+#endif

src/InternalStorageAVR.cpp

@@ -0,0 +1,77 @@
+/*
+ Copyright (c) 2018 Juraj Andrassy
+
+ 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 <Arduino.h>
+
+#if defined(__AVR__) && FLASHEND >= 0xFFFF
+
+#include "InternalStorageAVR.h"
+#include "utility/optiboot.h"
+
+InternalStorageAVRClass::InternalStorageAVRClass() {
+  maxSketchSize = (MAX_FLASH - bootloaderSize) / 2;
+  maxSketchSize = (maxSketchSize / SPM_PAGESIZE) * SPM_PAGESIZE; // align to page
+  pageAddress = maxSketchSize;
+  pageIndex = 0;
+}
+
+int InternalStorageAVRClass::open(int length) {
+  (void)length;
+  pageAddress = maxSketchSize;
+  pageIndex = 0;
+  return 1;
+}
+
+size_t InternalStorageAVRClass::write(uint8_t b) {
+  if (pageIndex == 0) {
+    optiboot_page_erase(pageAddress);
+  }
+  dataWord.u8[pageIndex % 2] = b;
+  if (pageIndex % 2) {
+    optiboot_page_fill(pageAddress + pageIndex, dataWord.u16);
+  }
+  pageIndex++;
+  if (pageIndex == SPM_PAGESIZE) {
+    optiboot_page_write(pageAddress);
+    pageIndex = 0;
+    pageAddress += SPM_PAGESIZE;
+  }
+  return 1;
+}
+
+void InternalStorageAVRClass::close() {
+  if (pageIndex) {
+    optiboot_page_write(pageAddress);
+  }
+  pageIndex = 0;
+}
+
+void InternalStorageAVRClass::clear() {
+}
+
+void InternalStorageAVRClass::apply() {
+  copy_flash_pages_cli(SKETCH_START_ADDRESS, maxSketchSize, (pageAddress - maxSketchSize) / SPM_PAGESIZE + 1, true);
+}
+
+long InternalStorageAVRClass::maxSize() {
+  return maxSketchSize;
+}
+
+InternalStorageAVRClass InternalStorage;
+
+#endif

src/InternalStorageAVR.h

@@ -0,0 +1,50 @@
+/*
+  Copyright (c) 2018 Juraj Andrassy
+
+  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 _INTERNAL_STORAGE_AVR_H_INCLUDED
+#define _INTERNAL_STORAGE_AVR_H_INCLUDED
+
+#include "OTAStorage.h"
+
+class InternalStorageAVRClass : public OTAStorage {
+public:
+
+  InternalStorageAVRClass();
+
+  virtual int open(int length);
+  virtual size_t write(uint8_t);
+  virtual void close();
+  virtual void clear();
+  virtual void apply();
+  virtual long maxSize();
+
+private:
+  uint32_t maxSketchSize;
+  uint32_t pageAddress;
+  uint16_t pageIndex;
+
+  union {
+    uint16_t u16;
+    uint8_t u8[2];
+  } dataWord;
+};
+
+extern InternalStorageAVRClass InternalStorage;
+
+#endif

src/OTAStorage.cpp

@@ -11,23 +11,44 @@ static const uint32_t pageSizes[] = { 8, 16, 32, 64, 128, 256, 512, 1024 };
 extern "C" {
 char * __isr_vector();
 }
+#elif defined(__AVR__)
+#include <avr/wdt.h>
+#include <avr/boot.h>
+#define MIN_BOOTSZ (4 * SPM_PAGESIZE)
 #endif
 
-
 OTAStorage::OTAStorage() :
 #if defined(ARDUINO_ARCH_SAMD)
         SKETCH_START_ADDRESS(BOOTLOADER_SIZE),
         PAGE_SIZE(pageSizes[NVMCTRL->PARAM.bit.PSZ]),
-        PAGES(NVMCTRL->PARAM.bit.NVMP),
+        MAX_FLASH(PAGE_SIZE * NVMCTRL->PARAM.bit.NVMP)
 #elif defined(ARDUINO_ARCH_NRF5)
         SKETCH_START_ADDRESS((uint32_t) __isr_vector),
         PAGE_SIZE((size_t) NRF_FICR->CODEPAGESIZE),
-        PAGES((uint32_t) NRF_FICR->CODESIZE),
+        MAX_FLASH(PAGE_SIZE * (uint32_t) NRF_FICR->CODESIZE)
+#elif defined(__AVR__)
+        SKETCH_START_ADDRESS(0),
+        PAGE_SIZE(SPM_PAGESIZE),
+        MAX_FLASH((uint32_t) FLASHEND + 1)
 #endif
-        MAX_FLASH(PAGE_SIZE * PAGES)
 {
-
+  bootloaderSize = 0;
+#ifdef __AVR__
+  cli();
+  uint8_t highBits = boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS);
+  sei();
+  if (!(highBits & bit(FUSE_BOOTRST))) {
+    byte v = (highBits & ((~FUSE_BOOTSZ1 ) + (~FUSE_BOOTSZ0 )));
+    bootloaderSize = MIN_BOOTSZ << ((v >> 1) ^ 3);
+  }
+#endif
 }
+
 void ExternalOTAStorage::apply() {
+#ifdef __AVR__
+  wdt_enable(WDTO_15MS);
+  while (true);
+#else
   NVIC_SystemReset();
+#endif
 }

src/OTAStorage.h

@@ -38,12 +38,14 @@ class OTAStorage {
   virtual void apply() = 0;
 
   virtual long maxSize() {
-    return (MAX_FLASH - SKETCH_START_ADDRESS);
+    return (MAX_FLASH - SKETCH_START_ADDRESS - bootloaderSize);
   }
 
 protected:
   const uint32_t SKETCH_START_ADDRESS;
-  const uint32_t PAGE_SIZE, PAGES, MAX_FLASH;
+  const uint32_t PAGE_SIZE;
+  const uint32_t MAX_FLASH;
+  uint32_t bootloaderSize;
 
 };
 

src/SDStorage.h

@@ -31,7 +31,7 @@ class SDStorageClass : public ExternalOTAStorage {
 public:
 
   virtual int open(int length) {
-    _file = SD.open(updateFileName, FILE_WRITE);
+    _file = SD.open(updateFileName, O_CREAT | O_WRITE);
     if (!_file)
       return 0;
     return 1;