TinyPICO – tiny fully-featured ESP32 board

Folks would be more likely to do so if there were a visible way to do so.

I suspect they'll lose many people that way, since it's not clear the thing is even for sale unless you stumble upon it somehow. Is this an open source make-your-own-board thing where I get a BoM and CAD files? A buyable product? It's not clear at all from the site design.

Disclaimer: The design is responsive. It disappears at lower screen widths. There's a subtle menu in the top-right, and the bottom of the menu hides the "buy" button. It's fine if you're running a full-screen browser window on a desktop.

It is a fantastic board. If it was cheaper (and had 16MB variants), I'd use it exlcusively. But regular ESP32 boards are 3-4€ on Aliexpress, so I can't justify it.

his livestreams have taught me more about board design than anything else. also, this is an incredibly well documented board, as he livestreamed much of it and opensourced everything

Awesome project !

Thanks for adjusting the main topic name. The OP isn't the creator of the project, I am, but it's super cool he posted about it. Cheers :)

In addition to the regular ESP32 benefits (BT, BTLE, dual core, etc), the TinyPICO is REALLY small and has really good power consumption in deep sleep mode. A lot of the random Aliexpress boards have power consumption on the order of 10-100 milliamps in deep sleep. The TinyPico is more like 20 microamps. Part of that is through higher quality parts (presumably better voltage regulator, battery controller, etc.). Part of that is through a more thoughtful design (instead of having to desolder an annoying always-on LED to reduce power consumption, you can just turn it off in code).

The ESP32 is vastly more powerful than the ESP8266. Dual core, each core is more powerful, it has BLE, more RAM, flash, GPIO - as well as a handful of other useful peripherals (RMT, PWM etc).

Now, the TinyPICO is more expensive than some ESP32 boards but that's because it's been engineered well and is manufactured in Australia by a maker that goes out of his way to support his products.

Dual core is nice for example when you need a little bit more processing power say for something like https://github.com/atomic14/esp32_audio

> Besides the size

It doesn’t look that much smaller I don’t think?

Edit: The ones I’m using are about 28x58mm. This one is 18x32mm. My standard one is about 2.8x larger.

You could go with something like the Adafruit FunHouse: https://www.adafruit.com/product/4985

WiFi, lots of built in hardware (temp + humidity, light, microphone, buzzer, buttons, LEDs, etc), and CircuitPython means you can program it with a USB cable and a plain old text editor.

More bucks than the "smallest ESP-whatever" dev board, but handy for learning.

Can you help me understand this comment a bit better?

Here is what I see, a board that one solders header pins into that can then be plugged into a solderless breadboard where jumper wires are used to attach it to other interesting peripherals.

To me, this seems like the new preferred way of doing "Arduino" which no longer refers to a hardware standard so much as it is an integrated development environment connected to the device of through USB and programmed in a somewhat C++'ish dialect of a computer language.

Typical curriculum for learning is to use pre-existing "sketches" (programs) with pre-existing board or processor specific "libraries" to implement behaviors from the simple (blink an LED) to the complex.

An alternative curriculum/universe are the mBed boards which are supported by ARM (and are pretty much all ARM based boards rather than a variety of architectures like Arduino currently supports).

So my questions would be what are you trying to learn, and what constitutes "fully featured" in your mind?

In my experience some people use these kinds of setups to learn programming and some use them to learn embedded systems. The the programming aspect typically links together one or more assembled "break out" boards with a perihperal of interest and the programming learning is how to code something that combines that breakout boards library with some behavioral code to achieve some goal. Leaning embedded systems often involves actually building one's own "break out" board and writing the libraries that provide a programming API that can drive that board.

EDIT: As it turns out, the third method that these things are used is with a variant of Python which is nominally "Micropython" (official project), "CircuitPython", the Adafruit variant, or "Ardupy", the Seeed Studio variant.

That makes programming things even simpler. You don't even need any software on your computer (just a terminal program to talk to the board).

So getting this from CrowdSupply with the 'triple shield' and you're good to go.

So knowing what you want to learn, and what your level of investment is, helps give a better answer to the question.

This is my current favorite dev/project board. It has so much stuff. WiFi, Bluetooth, LoRa, and LTE! It also has pins for analog/digital I/O. This thing is incredible.

https://pycom.io/product/fipy/

Pycom also has various extension boards that plug right in with things like NFC/RFID, GPS, light/pressure/humidity sensors, etc.

Oh, and how could I forget to mention that it can run python directly on the microcontroller (micropython) so you don't need to know C to mess with it. And it does that thing where it mounts as a filesystem and you can just drag python files over to it and it'll automatically reboot into running them.

Highly recommend this little device.

See a sibling comment from @yoursunny about "hats." Microcontroller boards tend towards being general purpose, meaning you have to add sensors and actuators to realize any kind of useful application. For some of the more mature boards, there are aftermarket "hats," which are pin compatible boards that contain functionality to suit your interests, such as controlling relays, small to large numbers of LEDs, various physical and environmental sensors, etc. Many of these "hats" are accompanied by code libraries, so you don't have to delve too deep into the guts right away.

It wouldn't hurt to look for a completed project where someone has posted a tutorial on how they did it, and duplicate it. Then you can take small steps towards adapting it in a creative way, e.g., by writing new code for it, or adding more hardware goodies.

Like programming itself, you have to let hardware hacking grow on you. Maybe it will and maybe it won't. If it does, then it can be a fascinating rabbit hole to go down.

You might like a board that has a qwiic or other similar style of connectors (https://www.sparkfun.com/qwiic). The idea is to standardize microcontroller peripherals like sensors, actuators, lights, etc. onto simple buses with shared connectors so you don't have to learn or worry about routing and wiring things up yourself. There are tradeoffs or course but it's a great way to get going and prototype stuff.

The ones that come up from searching "esp32 dev board" on amazon are the most common ones for about $10, lots of guides will reference it as well.

The ESP32 platform is pretty damn powerful and is something of a "kitchen sink" approach to embedded IoT. You won't find too much more capability without going to an SoC.

Here's what I'd recommend - pick up a cheap dev board! Shouldn't cost you more than $10 and a USB cable, and you can get to hacking straight away. It's easier than you think, I promise!

You can use it for sure. With Arduino, ESPHome or probably others. They are surprisingly accessible - I have very few skills and have a few basic automations and sensors going nicely.

I’m only using a fraction of their power though.

You can get just a regular Arduino variant, but really this is not that much different. Feature rich, for sure - but still at its core something you can just use like a basic little Arduino for basic stuff.

There is plenty of software for the esp32, knowing a bit of C has never hurt

I find the M5StickC is good for this

Raspberry Pi Zeros are cheap, easy to find, featureful, and user friendly :)

Seconded. Also check out the FeatherS2, designed by the same dude: https://feathers2.io/

I actually like the FeatherS2 for one reason, which is that it presents itself as a USB storage device and you can just drop Python files into it. Easier than the `ampy` stuff you have to do with the TinyPICO, and it comes with a "Stemma" port that you can wire up most Adafruit/Sparkfun sensors to. And it has mounting holes, which are a godsend if you want to make a proper 3D printed case for your project.

The only downside is FeatherS2 is CircuitPython and TinyPICO is MicroPython, and you don't get threading on CircuitPython.

MQTT is very good for this. I had a hairball of a raspberry pi setup driving a distillation process. I bought a ten pack of NodeMCUs (esp8266 but same basically) and moved all of the hardware off of the pi and distributed it across 4-5 of the little dudes. All comms were MQTT over WiFi and it worked great. (NodeRED was fantastic driving all of that, and i used Tasmota on the NodeMCUs, theres an ESP32 build for that.)

For low power you can obv turn off radio when youre not using it. Probably some simple way to sleep/shut it off completely as well.

Most efficient & easy would probably be a nrf52840 (you can get the nrf52840dongle for $9, it has a wide voltage range and low power sleep modes and USB).

You can communicate over the 802.15.4 radio which is very low power compared to WiFi.

I'd use RIOT-OS, Zephyr has official support from Nordic, but that's what I'm familiar with: You can create a 6loWPAN network where each node gets an IPv6 address, they can communicate to the IPv6 world through a border router which would be another nRF52 Dongle where the USB serves as an USB-Ethernet Uplink that you plug into your router.

You could then use CoAP to send the data to a server somewhere (or just plain UDP) and sleep most of the time.

I followed a project named parasite https://github.com/rbaron/w-parasite

I made a small MPPT solar harvester with a 0.47F supercap. This system reports soil moisture without using battery. It works even when weather is cloudy.

Hope this gives you some insight.

The easiest way to go would probably be getting an ESP8266/ESP32 board and using ESPhome with it.

For low power communications I'd consider a 433 MHz module. Many places sell them. Here's one from Sparkfun [1].

To receive, you can buy corresponding modules but I wouldn't bother with that. Get an RTL-SDR dongle for whatever computer you want to process the data on (an RPi is great for this if you don't want to keep your desktop on all the time to do it), and use the program rtl_433.

The 433 MHz transmitter module simply sends a 433ish MHz continuous signal when its data input pin is high and does not send when the input pin is low. You encode your message into a series of pulses of the transmitter.

For example, for a project I'm doing using one of these transmitter modules I've currently got it on an Arduino for testing. Here's the Arduino code to send a message.

    #define CYCLE       1000
    #define W_0         600
    #define W_1         400

    #define INTRO_1     1500
    #define INTRO_0     1500

    void send_message(char * bp, int n)
    {
        digitalWrite(RADIO, HIGH);
        delayMicroseconds(INTRO_1);
        digitalWrite(RADIO, LOW);
        delayMicroseconds(INTRO_0);

        while (n-- > 0) {
            int b = *bp++ & 0xff;
            int m = 0x80;
            while (m != 0) {
                int w = (b & m) ? W_1 : W_0;
                digitalWrite(RADIO, HIGH);
                delayMicroseconds(w);
                digitalWrite(RADIO, LOW);
                delayMicroseconds(CYCLE-w);
                m >>= 1;
            }
        }
    }

That sends a message starting with a 1.5 ms pulse and a 1.5 ms gap, and then n bytes of data where a 1 is a 400 usec pulse followed by a 600 usec gap, and a 0 is a 600 usec pulse followed by a 400 usec gap, so 1000 bits per second after the 3 ms prefix. (The actual timing is a little longer, because of overhead).

My current test messages all start with "TZS", are 12 bytes long, and the last 2 bytes are a counter that simply increments every time I press a button. Adding this to an rtl_433 config file makes rtl_433 recognize those messages and print the count:

  decoder {
    name        = TEST,
    modulation  = OOK_PWM,
    short       = 424,
    long        = 624,
    reset       = 1500,
    sync        = 1528,
    bits        = 96,
    match       = {24}0x849083,
    get         = count:@80:{16},
  }
 

rtl_433 can then do a variety of things with the message, including saving to a file, sending to an MQTT server, sending to syslog, and sending to an Influx DB.

[1] https://www.sparkfun.com/products/10534

The Teensy is quite different, I don't think some of its famous audio/DSP applications could be ported to the ESP32. Hoping to be wrong though.

This synth for example is entirely built around a Teensy.

https://electrotechnique.cc/

Don't miss the demos!

Wait so 'nano' is the smaller version of the 'tiny' 'pico'?!

Get a pre certified board! Wroom32 are pre certified.

Thanks for your thoughts, but just to clarify - the 'LILYGO T-Micro32' is not a dev board with USB chopped off. It's just a PICO-D4 chip and antenna. It's got no Serial2UART, no USB, no LDO or any power management, no battery management - it's got nothing. It's just a D4 SiP on a PCB with an antenna and an RF shield. No different to a WROOM-32 module.

You can't do anything with it unless you put it on a carrier PCB and add all of the other stuff yourself.

Seems to be a lot of confusion about what the Micro32 is and what it's not.

This is a dev board with USB taken off: https://www.tinypico.com/tinypico-nano

There are downsides with the cheaper boards, in addition to size, such as idle power consumption which is typically hideous. Virtually all of the inexpensive boards are just warmed over (or exact copies of) reference designs. He actually is sweating the details to try to make his board the best version it can be for those wanting a better dev board but not wanting to go as far as designing their own. But sure, if cost dominates everything else, his stuff is more expensive.

The buy page is linked at the top [1]

It's worth click through to -- depending on where you live another vendor might be considerably cheaper for you.

I'm in the US and Adafruit worked out to be ~$10 cheaper than CrowdSupply for me with shipping and tax.

[1]: https://www.tinypico.com/buy

He has them!

https://www.tinypico.com/add-ons

The Lilygo TTGO Micro32 module with the ESP32-PICO-D4 chip:

https://www.amazon.com/dp/B07RLLY5WZ

https://www.aliexpress.com/item/32869180373.html

is smaller - just 19x13mm! Though it doesn't include USB connector, power supply, USB-serial IC, etc.

It's used in the Open Smartwatch project (https://open-smartwatch.github.io/).

You want the lilygo t-wristband

The white block at the end of the PCB is a 3D Antenna - much better performance over a PCB antenna or 2d chip antenna.