Add LZSS encoding/decoding for MKRNB 1500 SBU

libraries/SBU/examples/SBU_LoadLZSS/SBU_LoadLZSS.ino

@@ -0,0 +1,73 @@
+#include <MKRNB.h>
+#include <SBU.h>
+
+#include "lzssEncode.h"
+
+static char const BINARY[] =
+{
+#include "Binary.h"
+};
+
+static char const CHECK_FILE[] =
+{
+  "OK"
+};
+
+static constexpr char CHECK_FILE_NAME[] = "UPDATE.OK";
+const char * UPDATE_FILE_NAME_LZSS = "UPDATE.BIN.LZSS";
+
+NBFileUtils fileUtils;
+bool update_available = false;
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial) { }
+
+  unsigned long const start = millis();
+  for (unsigned long now = millis(); !Serial && ((now - start) < 5000); now = millis()) { };
+
+  Serial.print("Accessing SARA Filesystem... ");
+  if (!fileUtils.begin(false)) {
+    Serial.println("failed.");
+    return;
+
+  }
+  Serial.println("OK");
+
+  uint32_t bytes_to_write = sizeof(BINARY);
+  Serial.print("Size of BINARY.H: ");
+  Serial.println(bytes_to_write);
+
+  Serial.print("Encoding \"BINARY.H\" into \"UPDATE.BIN.LZSS\" and writing it into the Sara-R410M module ... ");
+
+  //Encode into .lzss and write to the Sara modem
+  int bytes_written = lzss_encode(BINARY, bytes_to_write);
+
+  if (bytes_written == 0) {
+    Serial.println("something went wrong!");
+  } else {
+    Serial.println("OK!");
+  }
+
+  Serial.print("Size of UPDATE.BIN.LZSS: ");
+  Serial.println(bytes_written);
+
+  auto status = 0;
+  while (status != 2) {
+    status = fileUtils.createFile(CHECK_FILE_NAME, CHECK_FILE, 2);
+    delay(100);
+  }
+
+  Serial.println("Please type \"restart\" to apply the update");
+  update_available = true;
+}
+
+
+void loop() {
+  if (update_available == true) {
+    String command = Serial.readStringUntil('\n');
+    if (command.indexOf("restart") >= 0) {
+      NVIC_SystemReset();
+    }
+  }
+}

libraries/SBU/examples/SBU_LoadLZSS/lzssEncode.cpp

@@ -0,0 +1,182 @@
+/**************************************************************************************
+   INCLUDE
+ **************************************************************************************/
+
+#include "lzssEncode.h"
+
+#include <stdlib.h>
+#include <stdint.h>
+
+#include <MKRNB.h>
+
+/**************************************************************************************
+   DEFINE
+ **************************************************************************************/
+
+#define EI 11             /* typically 10..13 */
+#define EJ  4             /* typically 4..5 */
+#define P   1             /* If match length <= P then output one character */
+#define N (1 << EI)       /* buffer size */
+#define F ((1 << EJ) + 1) /* lookahead buffer size */
+
+#define LZSS_EOF       (-1)
+
+#define FPUTC_BUF_SIZE (512)
+#define FGETC_BUF_SIZE (512)
+
+/**************************************************************************************
+   GLOBAL VARIABLES
+ **************************************************************************************/
+
+extern NBFileUtils fileUtils;
+extern const char * UPDATE_FILE_NAME_LZSS;
+
+int bit_buffer = 0, bit_mask = 128;
+unsigned long textcount = 0;
+unsigned char buffer[N * 2];
+
+static char write_buf[FPUTC_BUF_SIZE];
+static size_t write_buf_num_bytes = 0;
+static size_t bytes_written_fputc = 0;
+
+bool append = false;
+bool endOfFile = false;
+
+/**************************************************************************************
+   PUBLIC FUNCTIONS
+ **************************************************************************************/
+
+void lzss_flush()
+{
+  bytes_written_fputc += write_buf_num_bytes;
+
+  fileUtils.downloadFile(UPDATE_FILE_NAME_LZSS, write_buf, write_buf_num_bytes, append);        //UPDATE.BIN.LZSS
+  append = true;
+
+  write_buf_num_bytes = 0;
+}
+
+/**************************************************************************************
+   PRIVATE FUNCTIONS
+ **************************************************************************************/
+
+void lzss_fputc(int const c)
+{
+  /* Buffer the compressed data into a buffer so
+   * we can perform block writes and don't need to
+   * write every byte singly on the modem
+   */
+  write_buf[write_buf_num_bytes] = static_cast<char>(c);
+  write_buf_num_bytes++;
+
+  /* The write buffer is full of compressed
+   * data, write it to the modem now.
+   */
+  if (write_buf_num_bytes == FPUTC_BUF_SIZE || endOfFile)
+    lzss_flush();
+}
+
+/**************************************************************************************
+   LZSS FUNCTIONS
+ **************************************************************************************/
+
+void putbit1(void)
+{
+    bit_buffer |= bit_mask;
+    if ((bit_mask >>= 1) == 0) {
+        lzss_fputc(bit_buffer);
+        bit_buffer = 0;  bit_mask = 128;
+    }
+}
+
+void putbit0(void)
+{
+    if ((bit_mask >>= 1) == 0) {
+        lzss_fputc(bit_buffer);
+        bit_buffer = 0;  bit_mask = 128;
+    }
+}
+
+void flush_bit_buffer(void)
+{
+    if (bit_mask != 128) {
+        lzss_fputc(bit_buffer);
+    }
+}
+
+void output1(int c)
+{
+    int mask;
+
+    putbit1();
+    mask = 256;
+    while (mask >>= 1) {
+        if (c & mask) putbit1();
+        else putbit0();
+    }
+}
+
+void output2(int x, int y)
+{
+    int mask;
+
+    putbit0();
+    mask = N;
+    while (mask >>= 1) {
+        if (x & mask) putbit1();
+        else putbit0();
+    }
+    mask = (1 << EJ);
+    while (mask >>= 1) {
+        if (y & mask) putbit1();
+        else putbit0();
+    }
+}
+
+int lzss_encode(const char buf_in[], uint32_t size)
+{
+    int i, j, f1, x, y, r, s, bufferend, c;
+
+    for (i = 0; i < N - F; i++) buffer[i] = ' ';
+    for (i = N - F; i < N * 2; i++) {
+        if (textcount >= size) {
+            endOfFile = true;
+            break;
+        } else {
+            buffer[i] = buf_in[textcount];
+            textcount++;
+        }
+    }
+    bufferend = i;  r = N - F;  s = 0;
+    while (r < bufferend) {
+        f1 = (F <= bufferend - r) ? F : bufferend - r;
+        x = 0;  y = 1;  c = buffer[r];
+        for (i = r - 1; i >= s; i--)
+            if (buffer[i] == c) {
+                for (j = 1; j < f1; j++)
+                    if (buffer[i + j] != buffer[r + j]) break;
+                if (j > y) {
+                    x = i;  y = j;
+                }
+            }
+        if (y <= P) {  y = 1;  output1(c);  }
+        else output2(x & (N - 1), y - 2);
+        r += y;  s += y;
+        if (r >= N * 2 - F) {
+            for (i = 0; i < N; i++) buffer[i] = buffer[i + N];
+            bufferend -= N;  r -= N;  s -= N;
+            while (bufferend < N * 2) {
+                if (textcount >= size) {
+                    endOfFile = true;
+                    break;
+                } else {
+                    buffer[bufferend++] = buf_in[textcount];
+                    textcount++;
+                }
+            }
+        }
+    }
+    flush_bit_buffer();
+
+    return bytes_written_fputc;
+}

libraries/SBU/examples/SBU_LoadLZSS/lzssEncode.h

@@ -0,0 +1,17 @@
+#ifndef SBU_LZSS_H_
+#define SBU_LZSS_H_
+
+/**************************************************************************************
+   INCLUDE
+ **************************************************************************************/
+
+#include <stdint.h>
+
+/**************************************************************************************
+   FUNCTION DEFINITION
+ **************************************************************************************/
+
+void lzss_flush();
+int lzss_encode(const char buf_in[], uint32_t size);
+
+#endif /* SBU_LZSS_H_ */