So I decided to tackle one problem at a time and looked at the big JSON object issue first. If you want to parse big documents you can either build a representation of the object in memory (DOM) or you can write a event based parser. This means that your parser is processing the document as it comes in as a stream, character by character and that it will notify you with different event types once portions of the document were parsed successfully. This is very helpful since you don’t have to keep the whole  document in memory and you can even start parsing the stream almost immediately. You might be familiar with the SAX parser for XML which also follows this concept.

This concept is very useful on devices with little memory as the ESP8266. Looking for a start I found such a stream based JSON parser written in PHP and decided to port it to C++.

The result looks very promising: I wrote a little example program for the ESP8266 which downloads a sample JSON object of 1MB size. In the sketch I’m only interested in one of the 5000 sub-objects and print it out as soon as I see it. During processing I print out the heap size with ESP.getFreeHeap() and the available heap size remains stable at around 32KB!

If you like to try it out you can find the library here: https://github.com/squix78/json-streaming-parser. In theory it should work for any Arduino target device but I only tested it with the ESP8266.

Happy hacking!

Low-Level: EEPROM

Up until now and currently your best bet for data persistence in the stable release you could use the EEPROM interface to write and read your data so it would be available between reboots of the device. This persistence interface is pretty low-level: you have to define the range of the memory you want to use and then it’s all on you how to organize this stream of bytes. Of course, you could write yourself some code to write and read the data in a more accessible way but this is cumbersome and error-prone. Especially if the stored data has different formats, lets say one part is a JSON object and the next is HTML you have to create a table of content (TOC) and keep track of the sizes and start points of these blocks.

New: SPIFFS

But why re-invent the wheel? This organization of all the single blocks in a TOC is generally called a file system and the team around the ESP8266/Arduino environment is currently integrating the SPIFFS into their development branch. SPIFFS stands for SPI flash file system and is especially targeted for embedded devices such as the ESP8266. According to the Github page of the SPIFFS project the file system has the following features:

•  Specifically designed for low ram usage
•  Uses statically sized ram buffers, independent of number of files
•  Posix-like api: open, close, read, write, seek, stat, etc
•  Implements static wear leveling
•  Built in file system consistency checks

There are also a few limitations but hey, what do you expect from anything especially targeted for small and embedded devices?

Hands-on

#include "FS.h"

void setup() {
  Serial.begin(115200);

  // always use this to "mount" the filesystem
  bool result = SPIFFS.begin();
  Serial.println("SPIFFS opened: " + result);

  // this opens the file "f.txt" in read-mode
  File f = SPIFFS.open("/f.txt", "r");
  
  if (!f) {
    Serial.println("File doesn't exist yet. Creating it");

    // open the file in write mode
    File f = SPIFFS.open("/f.txt", "w");
    if (!f) {
      Serial.println("file creation failed");
    }
    // now write two lines in key/value style with  end-of-line characters
    f.println("ssid=abc");
    f.println("password=123455secret");
  } else {
    // we could open the file
    while(f.available()) {
      //Lets read line by line from the file
      String line = f.readStringUntil('n');
      Serial.println(line);
    }

  }
  file.close();
}

void loop() {
  // nothing to do for now, this is just a simple test

}

Documentation

Connect the Modules like this:

Here you’ll find the library:
https://github.com/squix78/MAX7219LedMatrix

Please note:

• this library is made for the ESP8266 and might or might not work for “normal” Arduino boards.
• I had to patch the Mac OS X release with the SPI folder from Github. In other words there wasn’t an up-to-date release for Mac OS X (and maybe for the other platforms as well) and the SPI.h/SPI.cpp wouldn’t compile

]]> https://blog.squix.org/2015/02/esp8266-arduino-raspberry-pi.html/feed 0 65 https://blog.squix.org/2014/12/esp8266-using-seeeduino-to-talk-to.html https://blog.squix.org/2014/12/esp8266-using-seeeduino-to-talk-to.html#respond Sat, 06 Dec 2014 13:00:00 +0000 http://blog.squix.org/2014/12/06/esp8266-using-seeeduino-to-talk-to/ Read More

• which Arduino are you using?
• how good is the documentation of the DevDuino?
• what wires do you have available?
• Do you have a ISP programmer for the DevDuino?

Programming the DevDuino

Source: Freetronics

So now you can send sketches to your DevDuino! If you want to save battery lifetime you can (and possibly should) adapt the settings for your target board. The DevDuino Wiki suggests to add the following lines to your boards.txt (on Mac OS X this might be here: 

s328o1.name=Sensor328p (int1MHz, 1.8V)

s328o1.upload.protocol=arduino
s328o1.upload.maximum_size=30720
s328o1.upload.speed=19200

s328o1.bootloader.low_fuses=0x62
s328o1.bootloader.high_fuses=0xda
s328o1.bootloader.extended_fuses=0x06
s328o1.bootloader.path=atmega

s328o1.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex

#s328o8.bootloader.file=ATmegaBOOT_168_atmega328.hex

s328o1.bootloader.unlock_bits=0x3F
s328o1.bootloader.lock_bits=0x0F

s328o1.build.mcu=atmega328p
s328o1.build.f_cpu=1000000L
s328o1.build.core=arduino
s328o1.build.variant=standard

Then close the IDE and re-open it. Under Tools > Boards you can find now a board called “Sensor328p (int1MHz, 1.8V)”. Select it. I believe you have to update the bootloader on the DevDuino

Now lets test the DevDuino with a minimal sketch:

int led = 9;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

which will make the built-in LED blink on the DevDuino. To upload this sketch to the DevDuino make sure it is attached correctly to be programmed as shown above. Switch to the correct programmer on Tools > Programmer > Arduino as ISP (or similar, if you use a special board like Leonardo). Then select File > Upload using Programmer or hold the Shift key while pressing the Upload button of your sketch. After the status turns to “Done Uploading..” the LED on the DevDuino should start blinking…

This was part 1 of the DevDuino tutorial. Part 2 will go into more details…

Links:

• How to use Arduino as ISP
• How to send dataobjects over the air and this
• DevDuino Wiki Page
• How to link Leonardo with nrf24l01
• How to use Leonardo as ISP programmer
• RF24 examples
• RF24 based sensor network
• Grove Humidity Sensor

#!/bin/sh
echo 0 > /sys/class/gpio/gpio8/value
echo 1 > /sys/class/gpio/gpio8/value
echo "$(date)" >> /tmp/restart.log

]]> https://blog.squix.org/2013/09/turn-onoff-usb-power-on-tl-mr3020.html/feed 0 86