ESP32 TTGO dev board with OLED Display Tutorial

IMG_20180302_131259020.jpg

Hello! Right now, there is more snow in Newport than I have ever seen in the UK! The campus I work at is shut so I have had an extra long weekend – perfect for some hacking! I’ve put together a little tutorial based on what I have been tinkering with…

Many ESP32 dev boards have an onboard OLED display included – at first glance these are hideously undocumented in every way, many are clones of clones coming from the techno world of the East with little to no information about use or origin, and often from sellers who may not speak much English as their first language, or understand the hardware they are selling!

In actual fact this sorta works in our favour – most of these boards are clones which don’t come with any special requirements or gotchas, so you can program them just like an official Espressif ESP32 dev board. If you pick something up with a clear silkscreen guide then you are already in a good place. There is not a lot of work involved to get them displaying something once you know how – I’ve already been through the pain so now I would like to share my experience with you 🙂

board

I recently bought a “TTGO” brand ESP32 dev board (pictured) – it has an onboard monochrome 128*64 OLED and has a holder and circuitry for a 18650 lithium battery, like the ones used in laptop batteries and Power Banks – pretty neat! This is a pretty average serving from the sea of ESP32 dev boards in terms of the information provided – there is very little! But at very least, there is a pin IO map which covers most stuff (pictured below).

A couple of sources of this board:

Amazon (UK)

Ebay (UK)

Banggood (CN)

 

pinOut

In this tutorial, I will show you how to display a couple of basic things on the screen using an external 3rd party library from ThingPulse. I wanted to use the Adafruit OLED libraries, but I was struggling to get them talking to the screen at all, maybe I can fix this still but ThingPulse’s library is pretty good anyway. I am going to use the Atom text editor with the PlatformIO plugin in this tutorial because I think it is much easier to get started with ESP32 this way if you have a basic understanding of Arduino – I also think it is superb and multipurpose dev environment. However if you already have your Arduino IDE set up for ESP32 work then everything here is transferable (I’m not going to cover Arduino setup).

In the near future I think it would be good to do something a little more interesting with this board – as the ESP32 is an IoT ready device with onboard WiFi and Bluetooth, we want that screen displaying something more interesting like a feed from ThingSpeak. That’s for another time though 🙂

Quick Overview:

I have put together a simple sketch that does the following things in a short sequence:

  • Prints to the Serial Monitor
  • Blinks the onboard LED
  • Plays a upwards scrolling message on the OLED
  • Plays a horizontal scrolling message on the OLED
  • Displays how many seconds the sketch has run on the OLED
  • Displays how many program loops have occured on the OLED

There’s nothing too complicated in the sketch but there may be some commands you haven’t seen before if you are newer to C programming. I will walk you through them.

Step 1: Installation – Drivers, Libraries and PlatformIO

To begin with, if you haven’t worked with the ESP32 before, it is very likely that you need to install USB drivers for whatever USB to UART or FTDI chip is on the dev board. In our case, and in most cases the CP2102 is used. You can download a package to install the driver from here.

If you haven’t already setup PlatformIO – this isn’t bad as a first project. I am not going to go through this process in detail because I already know an excellent video tutorial and I am pretty new to the IDE myself. First, navigate to the PlatformIO project website and follow the instructions to install the package with Atom: https://platformio.org/platformio-ide

This video is a pretty good start if you have the time to watch it:

Once you have PlatformIO basically set up, we can get started, but first let’s install the library needed for the OLED.

Let’s download the OLED library now so it is ready to use later. Navigate to ThingPulse’s ESP8266-OLED-SSD1306 repository and choose “Clone or Download”. Save the folder somewhere sensible on your harddrive – as the repository is effectively an Arduino library, a good place to put it would be your Arduino libraries directory, usually found under Arduino in your Documents. If you don’t use Arduino then maybe you should create a Libraries folder in your PlatformIO directory.

Start up Atom now and open the PlatformIO home page if you haven’t already done so.

PlatformIOStart

On the home page, create a new project – I want to point out my one frustration with PlatformIO here – file management :/

When you create a new project, make sure you save it in a new folder it is frustratingly easy to not do this.

  • Click “+ New Project”
  • In the Board field, type in ESP32 to narrow the search and choose the Espressif ESP32 Dev Module
  • In the Framework field, ensure that Arduino is selected
  • Uncheck “Location” – this will bring up a file browser – be careful
  • First, click on “Projects” – this will navigate to the PlatformIO folder in your user Documents directory
  • Click on the New folder button, and name your folder something like “TTGO OLED Test” – press Return or Enter.
  • Ensure that the browser is now pointing at your new folder, and press Finish

ProjectWizardA

ProjectWizardB

ProjectWizardC

Whew! That was stressful but we got there.

Step 2: Basic Hardware Test

Now we can get started. PlatformIO should have opened your new project folder – if you are new to the IDE, notice that you deal with a couple more files than you do normally with the Arduino IDE – to get started, click on the src folder and then click on main.cpp – this is where you will build your sketch.

main

Let’s try something basic to get started and to know that your computer can communicate with the ESP32. Let’s write a simple blink sketch, and include a Serial Monitor prompt. It’s not documented on the pin map provided by the manufacturer, but the board has a built in LED on #GPIO16.

Start by plugging in the TTGO board with a micro USB data cable to your computer. make sure the board is also switched on with the micro switch on the side. You should see a short OLED demo play if it is the first time you have powered the dev board on.

IMG_20180303_133820942.jpg

// TTGO Test. This is a test script for a "TTGO" ESP32 Dev Board
// including an LCD module and a 18650 battery pack.
// 
// There is an integrated LED on digital pin 16 - woohoo!!
// 
// The built in OLED is a 128*64 mono pixel display
// i2c address = 0x3c
// SDA = 5
// SCL = 4
// 
// I use the ThingPulse ESP8266 OLED library, found here:
// https://github.com/ThingPulse/esp8266-oled-ssd1306
// 
// Please see the library for more detail on OLED commands
// 
// Aidan Taylor
// March 2018
// Electric Noodle Box

#include 

uint8_t ledPin = 16; // Onboard LED reference

void setup() {
    pinMode(ledPin, OUTPUT);
    
    Serial.begin(115200);
}

void loop() {
    Serial.println("Hello, Noodles!");

    digitalWrite(ledPin, LOW);
    delay(1000);
    digitalWrite(ledPin, HIGH);
    delay(1000);
}
  • Type out or copy and paste the code above
  • Then click on the large tick icon in the task menu on the left. This will save and verify your sketch
  • If you were able to verify without any errors, click on the large arrow icon below the tick icon, this will flash the ESP32 with your sketch. PlatformIO is smart and can usually interpret which port your device is connected to. It can take a little longer than uploading to a standard Arduino, but shouldn’t take more than 30 seconds.
  • Now the blue onboard LED should blink and if you click the plug icon near the bottom of the left task bar, you will open up the Serial Monitor, make sure the baud rate is 115200 and you are connected via a USB port – this is usually automatic for me.

If you get the “Hello, Noodles!” prompt then everything is looking good! If not, maybe you installed the wrong USB to UART driver or maybe you need to restart your computer in order to use the new driver. On my board, the LED is actually lit when #GPIO16 is LOW, this must mean the anode is connected to +V and is not likely a mistake, but is a little unusual – it’s no matter of course. Let’s move on to the OLED display…

Step 3: Basic OLED Display Test

First, we need to install a library for the OLED display – the display has an SSD1306 driver behind it, so we want a library that can talk to that. I tried setting up the Adafruit OLED library but couldn’t get it to work, but another one worked fine. Installing libraries for PlatformIO is easy, but I missed it at first. There is a tab on the PlatformIO home screen in Atom that contains all the library management you need.

  • Navigate to the PlatformIO home screen in Atom (you can open it from the PlatformIO menu at the top of the screen if you closed it)
  • Click on the Libraries tab on the left
  • Locate the ESP8266_SSD1306 library by Daniel Eichhorn, click on it and install it
  • That’s it!

newLibrary

Now let’s see if we can get the screen to do something. Let’s display a message on the screen…

// TTGO Test. This is a test script for a "TTGO" ESP32 Dev Board
// including an LCD module and a 18650 battery pack.
//
// There is an integrated LED on digital pin 16 - woohoo!!
//
// The built in OLED is a 128*64 mono pixel display
// i2c address = 0x3c
// SDA = 5
// SCL = 4
//
// I use the ThingPulse ESP8266 OLED library, found here:
// https://github.com/ThingPulse/esp8266-oled-ssd1306
//
// Please see the library for more detail on OLED commands
//
// Aidan Taylor
// March 2018
// Electric Noodle Box

#include 
#include 
#include "SSD1306.h"

uint8_t ledPin = 16; // Onboard LED reference

SSD1306 display(0x3c, 5, 4); // instance for the OLED. Addr, SDA, SCL


void setup() {
    pinMode(ledPin, OUTPUT);

    Serial.begin(115200);

    display.init(); // initialise the OLED
    display.flipScreenVertically(); // does what is says
    display.setFont(ArialMT_Plain_24); // does what is says
    // Set the origin of text to top left
    display.setTextAlignment(TEXT_ALIGN_LEFT);
}

void loop() {
    Serial.println("Hello, Noodles!");

    digitalWrite(ledPin, LOW);
    delay(1000);
    digitalWrite(ledPin, HIGH);
    delay(1000);

    display.clear(); // clear the display
    // prep a string in the screen buffer
    display.drawString(0, 0, "**noodles**");
    display.display(); // display whatever is in the buffer
}
  • Type out or copy and paste the new code into main.cpp
  • There are two new libraries added with #include, the standard wire.h library and ThingPulse’s SSD1306.h library
  • The SSD1306.h library instance includes the address and pins used for i2c communication with the OLED. On the TTGO board, the SDA pin is #GPIO5 and the SCK pin is #GPIO4. The i2c address of the OLED is 0x3c – I suspect that the pins are not easily configurable in the Adafruit OLED library which is why I couldn’t get it to work.
  • In void setup() or anywhere else for that matter, optionally use display.flipScreenVertically(); to flip the screen orientation according to your taste.
  • The library just has the ArialMT font but you can add custom fonts. You can change the size between 10, 16, and 24. Use the command display.setFont() as shown
  • display.setTextAlignment() has a couple of options detailed in the library readme – TEXT_ALIGN_LEFT means the origin of any text will be from the top left.
IMG_20180303_131946902.jpg
That power LED! My eyessssss
  • In void loop() we have three commands. display.clear() flushes whatever is currently on the display – if you don’t clear the display before you want to add something new, you will just end up with a mess on the screen!
  • display.drawString() will prepare a string in the display buffer. You have 3 variables, the x origin, the y origin and the string itself. The origin of 0, 0 with the alignment we have set will print our message in the top left of the screen.
  • Finally, display.display() will actually print the contents of the buffer on the screen.

Did it work? Great! Now is a good opportunity to try the different font sizes and alignments – and try printing with different x, y origins. You can prepare multiple display.drawString() commands before you use display.display() – this is useful if you want to print a couple of lines of text. Also, try adding a delay(1000); after display.clear() to see the effect.

Step 4: Some OLED Font Fun

Ok so let’s use some simple code to do some more interesting stuff. Try the adding the code below to main.cpp:

// TTGO Test. This is a test script for a "TTGO" ESP32 Dev Board
// including an LCD module and a 18650 battery pack.
//
// There is an integrated LED on digital pin 16 - woohoo!!
//
// The built in OLED is a 128*64 mono pixel display
// i2c address = 0x3c
// SDA = 5
// SCL = 4
//
// I use the ThingPulse ESP8266 OLED library, found here:
// https://github.com/ThingPulse/esp8266-oled-ssd1306
//
// Please see the library for more detail on OLED commands
//
// Aidan Taylor
// March 2018
// Electric Noodle Box

#include 
#include 
#include "SSD1306.h"

uint8_t ledPin = 16; // Onboard LED reference

SSD1306 display(0x3c, 5, 4); // instance for the OLED. Addr, SDA, SCL

// for fun:

uint16_t loopCount = 0; // Use to print how many times the program has looped
uint32_t progTime = 0;

void setup() {
    pinMode(ledPin, OUTPUT);

    Serial.begin(115200);

    display.init(); // initialise the OLED
    display.flipScreenVertically(); // does what is says
    display.setFont(ArialMT_Plain_24); // does what is says
    // Set the origin of text to top left
    display.setTextAlignment(TEXT_ALIGN_CENTER_BOTH);
}

void loop() {
  // prints to the Serial Monitor - good to test for successful flash
  Serial.println("Hello World");

  // blink the LED a few times - LED is lit when LOW for me
  for(uint8_t n = 0; n < 5; n++) {
    digitalWrite(ledPin, LOW);
    delay(30);
    digitalWrite(ledPin, HIGH);
    delay(30);
  }

  // Upwards scroll OLED text
  for(uint8_t i = 0; i < 3; i++) {     for(int8_t n = 112; n > -72; n--) {
      display.drawString(63, n, "Electric");
      display.drawString(63, n+24, "Noodle");
      display.drawString(63, n+48, "Box");
      display.display();
      delay(10);
      display.clear();
    }
  }

  // Horizontal scroll OLED text, with pause in center
  for(uint8_t i = 0; i < 3; i++) {
    for(int16_t n = -127; n < 191; n++) {
      if(n == 63){
        display.drawString(n, 31, "Why, Hello!!");
        display.display();
        delay(2000);
        display.clear();
      }
      else {
        display.drawString(n, 31, "Why, Hello!!");
        display.display();
        delay(10);
        display.clear();
      }
    }
  }

  // Print progTime:
  progTime = millis()/1000;

  display.setFont(ArialMT_Plain_16); // make the font smaller
  display.drawString(63, 14, "Run time(S) =");
  display.setFont(ArialMT_Plain_24); // and bigger again
  display.drawString(63, 38, String(progTime));
  display.display();
  delay(2000);
  display.clear();
  display.display();

  // Print loopCount:
  display.setFont(ArialMT_Plain_16); // make the font smaller
  display.drawString(63, 14, "Loops =");
  display.setFont(ArialMT_Plain_24); // and bigger again
  display.drawString(63, 38, String(loopCount));
  display.display();
  delay(2000);
  display.clear();
  display.display();

  loopCount++; // iterate loopCount
}

You should see something like this:

Let’s go through some of this code…

  • this time I used display.setTextAlignment(TEXT_ALIGN_CENTER_BOTH); to set the font origin to be centred on both the horizontal and vertical axis – this is much easier than fiddling around with the origin x/y in left alignment for the scrolling messages
  • I use a couple of for() loops in this sketch – a for loop means “for this many times, do this” – and they are super useful because you can use the loop criteria to iterate commands within the for() loop. For example:
for(uint8_t i = 0; i < 3; i++) { 
  for(int8_t n = 112; n > -72; n--) { 
    display.drawString(63, n, "Electric");
    display.drawString(63, n+24, "Noodle"); 
    display.drawString(63, n+48, "Box"); 
    display.display(); 
    delay(10); 
    display.clear(); 
    } 
  }

In this example, I’ve used a for() loop within a for() loop. The outer for() loop just repeats the inner loop 3 times, the inner for() loop repeats 184 times. Why? Because i starts at 0 and loops until it reaches 3 by adding 1 to i every loop, and n starts at 112 and loops until it reaches -72 by subtracting 1 from n every loop. See the Arduino reference for a good explanation of for(). 112 and -72 are odd numbers to use, but they are relevant because they are used to plot Y coordinates of the message. The Y axis of the screen is only 64 pixels, but the message is large, so we need some extra room, luckily we can use negative coordinates so long as our integer is a signed number.

  • Notice that 3 lines of display.drawString() are used before display.display() – you can buffer multiple things before you write them to the screen.
  • display.clear() refreshes the display for the next iteration of the message – without it, the last message isn’t cleared from the screen and things get messy fast! Note that display.clear() won’t do anything without a following display.display() message

Let’s look a little lower in the sketch:

// Print progTime: 
progTime = millis()/1000; 

display.setFont(ArialMT_Plain_16); // make the font smaller 
display.drawString(63, 14, "Run time(S) ="); 
display.setFont(ArialMT_Plain_24); // and bigger again 
display.drawString(63, 38, String(progTime)); 
display.display(); 
delay(2000); 
display.clear(); 
display.display();
  • First, progTime is a big unsigned integer, 32 bits. It is used to store a number which represents an internal milliseconds counter that runs in the background. The counter is accessed with the millis() function – millis() is a very useful function that I use a lot in my embedded programming as you can use it to make it seem like many things are happening at once. Blink Without Delay from the Arduino Built-In Examples describes this basic concept. This is beyond what we are doing here – we are just using millis() to generate a number to tell us how long the program has been running. millis()/1000 will give us a time in seconds.
  • display.drawString() cannot directly display an integer, so the integer needs to be converted to a string. This is easily accomplished with the String() command. String() is also worth looking up in the Arduino Reference.

That is all for this tutorial – I hope there is some useful information in here for you, please leave a comment below if you have any questions.

I will work on a true IoT application with this dev board and display very soon – and we can’t ignore that battery pack either! Ciao for now.

Resources:

USB to UART driver for CP2102 – https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers

PlatformIO – https://platformio.org/platformio-ide

ThingPulse’s OLED Library Repository – https://github.com/ThingPulse/esp8266-oled-ssd1306

Andy Reischle’s page gave me some helpful pointers to get started: http://www.areresearch.net/2018/01/how-to-use-ttgo-esp32-module-with-oled.html

25 Comments

    1. Yes it is, one word of warning is that I haven’t had good experiences with the 18650 charging. I think the circuitry on a couple of TTGO boards can over charge the battery, and then the chip breaks – the newer boards might be better but something has happened to a number of the TTGO boards that I have owned

      Like

      1. I confirm that I also have troubles with charging the 18650 with this type of TTGO board. On one the charging chip “exploded”, on another board the charging seem not the end, so it’s very likely that the battery is overcharged.

        Like

      2. Yes I’ve had pretty much the same problem – I wonder if they are using standard LiPo circuitry without any protection – flat cells tend to have protective circuitry built in, whereas 18650 cells tend to not

        Like

      3. Just signed in to say that I also had an issue with overcharging 😦 Good thing I checked on the device; the chips were too hot to handle and could have caused a fire had I checked on it later.

        Like

  1. dear Aidan,
    thanks for your great tutorial. after quite losing my mind (and a lot of hair) trying out numerous things I found yours and it really helped me a lot.

    what I don’t understand is that your code did not compile at first on my (constantly updating and somewhat daily changing … this is a story for itself) atom/platformio setup.
    fooling around, i found that changing your

    “#include ” … (nothing included here?)
    to
    “#include “Arduino.h”” … (including the standard arduino library)

    convinced this great – but scary – but great … editor/IDE/nearly-an-OS-monstrosity to compile, and upload stuff to the ESP32.
    so now that this is solved, I wonder if it’s only me that does not understand how the others (and you, primarily) could compile your code with an “empty” include – I mean obviously you did … or is this somehow implicitly included and I just did not know that?
    or is it that that worked on older versions, and the newer one is more strict?

    really curious! 🙂
    thanks again!
    auch1

    Like

    1. Hi auch1, thanks for the kind comments! I’m glad you managed to figure it out!

      You do indeed need to include the Arduino core libraries with

      #include “Arduino.h”

      The problem mostly stems from there not being a nice way to import code into the free version of WordPress! It is just fiddly to import code without the WordPress editor reformatting it – I will update it to save anyone else confusion.

      By the way, if you prefer to use the Arduino IDE, you can now install a properly maintained ESP32 firmware with the boards manager – this should mean that you get notified when there is a firmware update to install!

      Many thanks,

      Aidan

      Like

  2. Thanks a lot for the excellent tutorial. You’ve definitely saved a lot of people the time to dig out all that info, pinout etc. It all worked flawlessly (except for the minor missing include). Appreciate your time once again. Cheers

    Like

  3. Hi Aidan, i reply your script and all its ok. Now i try to monitor the carge of battery on pin 32 but not work well. You know if there is way to make this happen?

    Like

    1. You will need a voltage divider to measure the battery, a full charge of 4.2V is higher than the ADC can measure – I haven’t done a lot of work with the ESP32 ADC in all honesty but that is the first step

      Like

  4. Thanks, Aidan!

    I spotted one of these on Banggood, and it was missing crucial details like the OLED specs (and had a link to the wrong webpage for “more details”, to add insult to injury). You gave me the info I needed.

    And thanks to the other folks who posted warnings about the charger problem. That may have saved me from a really nasty surprise.

    I don’t see anything in the webpage illustrations that looks like a LiPo charge control chip. Is it possible that they’ve done something silly like try to control it with firmware or a crude voltage comparator? Or am I just not seeing the circuitry?

    Has anyone tried it with a protected 18650? Maybe they’re expecting that.

    Thanks again,

    Ran

    Like

    1. Hello,
      It is using the TP5400 charge control chip., located close to the micro usb connector.
      Having a look at the datasheet, it seems that – at least on my boards – the charging current has been programmed out of spec (using a 680 Ohm resistor on pin 3), leading to a charging current of about 2A, whereas the TP5400 is only capable of a charging current up to 1A!

      Like

  5. Great writeup. I figured out how to get the adafruit graphics library working on this board. Here’s the trick for the TTGO nonstandard I2C mappings:

    Wire.begin(OLED_SDA, OLED_SCL);
    // datasheet says max clock rate of 2.5us per pulse
    Wire.setClock(400000);

    // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
    // we set periphBegin because we already did a custom i2c init
    if(!disp.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR, true, false)) { // Address 0x3D for 128×64
    Serial.println(“SSD1306 allocation failed”);
    }

    // disp.display(); // show boot screen

    Like

  6. Hi.
    I confirm they soldered a 680Ohm resistor between pin3 of TP5400 and GND. This leads to unpredictable behaior of the charge circuit.
    So I do recommend to desolder the 681 and put a 1.1kOhm.

    Another bug is this board’s design: If the USB port does not deliver enough current for charging the battery and running the circuit, the input voltage of the AMS1117 drops below 4V, resulting in 3.3V rail brownout.
    So for programming the ESP32 or using UART0 for host communication via the CP2102, it will be necessary to take out the battery, or to charge it to full first.
    Another solution could be to put a 5k resistor between pin3 of TP5400 and GND, keeping the current draw within USB specs, but increasing the charge time to about 12 hours…
    The chips inner design does not allow to control the PROG pin3 from the ESP32, because the pin references via current. Maybe a DAC controlled NSL-32SR2 in line with 1.1kOhm to pin3 and voltage monitoring on the 5V and 3.3V rails via firmware could do the job to automatically adjust the charge current to the USB supply capabilities, but i really don’t want to mess around with this half-rare TTGO-circuit any more.
    Another bug: the shutdown-features of the CP2102 are not used, so even if USB is disconnected, the CP2102 keeps running and draws about 20mA from the battery for nothing (maybe intended to heat the board?).

    Also, via the SS54 and the inductor, the battery will deep-discharge, if the board is switched on.
    So it is absolute mandatory to use a protected cell! Mandatory!
    If the booard is switched off, the TP5400 itself will discharge the battery with about 0.02mA, also no limits, but this will take a longer time to kill an unprotected battery.

    Overall it looks like this board has been made by someone who has absolutely no idea of proper circuit design.

    Like

  7. Thanks for the work on this. I still can not figure out the platformIO, so ran in arduino IDE. Don’t use the battery in my project. But good info posted above, thanks.
    David Hanson

    Like

    1. Thanks David – I have moved over to Visual Studio Code for PlatformIO and other projects, it seems to be a bit less resource heavy than Atom. Nothing wrong with Arduino and the ESP32 core has come leaps and bounds since I made this tutorial!

      Like

  8. My TP5400 suddenly became very hot, and the current went from 100mA to 200mA. It seems to me that by looking at the components, that this PCB was designed for the TP5410: indeed, the self is 4.7μH, and the PROG resistor is at 680 ohm. Which corresponds to the scheme proposed by the TP5410. On the web, I found the same PCBs equipped with the TP5410. With TP5410, 680 ohm corresponds to 1A of charge. I think the manufacturer put the TP5400 because cheaper, or the TP5410 was out of stock. And he did not verify that TP54x0 equivalence requires passive components of different values. I ordered 1 TP5410 to replace the TP5400, will do a test and will update you.

    Like

  9. Hi! for using adafruit with this ttgo model, take adafruit 128×64 i2c example and replace:

    Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, 16);

    In setup, add:
    Wire.begin(5,4);

    and replace:
    display.begin(SSD1306_SWITCHCAPVCC, 0x3c)

    Like

  10. Muchas gracias por el tutorial, realmente bueno lleva mucho tiempo dándole vueltas y no había forma de hacerlo funcional.
    He implementado los ejemplos directamente en el IDE de Arduino y han funcionado dando algunas advertencias, pero funcionando perfectamente, lo probare más por si acaso.

    Agradezco los avisos de consumos, llevo bastante tiempo (casi un año) con el circuito y he cargado y descargado la batería varias veces sin problemas pero estaré al tanto.

    Muchas gracias de nuevo y les animo a continuar es una gran ayuda.

    Like

  11. Hi Aidan,
    Absolutely great tuturial and i wish there were more people like you sharing experiences and saving others the pain.
    Quick question, How much current does the board normally consume. Did you ever try a very low power mode with this ESP32 Kit and in your experience which ESP32 kit gives you the lowest power consumption for making a battery last over an year.

    Regards,
    Nouman

    Like

    1. Hi Nouman – I don’t think I ever measured the current consumption of this Dev board as the battery handling circuit died so it became useless as a portable device. I have been working with the ATTiny chip family a lot more lately which doesn’t have radio capabilities but they are very easy to integrate into a design and have sleep that works well. The Teensy family also has good sleep function if you want a dev board to work with. ESP32 has a dedicated low power core for sleep and wake function, but a lot of the available Dev boards are not well set up for sleep as they have wasteful regulators or serial USB convertors – I’m not sure of one to recommend to be honest – maybe try to source the chip itself and make your own Dev board?

      Like

  12. Hi Aidan,
    you saved my day !
    It’s really difficult to found resources to program this little board !
    Thanks to you, I can now display a message on the screen !

    Like

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s