Hacker News Reader

Comment by mysterydip | Hacker News Reader

While I love all these "how small can we make an IoT board," they're all outside my skillset to actually do something with. Is there a recommended more fully featured board to tinker/learn on?

View on HN

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.

And it's shaped like a house? Fantastic!

It may be more bucks, but it's still cheap for the amount of documentation you get. Plus, you only need one, and then you can graduate to the cheap ESP32 boards.

Thanks @adbachman, I’ve been looking at similar items like this for a home automation project that doesn’t rely on Google or Amazin

Have a look at Tasmota. I already run a boad with a BME280 sensor. The ESP32 port is even more featureful, it includes a Python like programing language called Berry.

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.

I'm interested in low level programming, not electrical engineering. While I understand the logical stacks, registers, pins in and out, I'm not great at soldering. I can stick components on a breadboard, I don't have the knowledge of what resistors I need with an LED, etc. Basically I want to test sensors and motors without needing to lay out the physical circuit correctly or adding to troubleshooting. So either a development board of some kind, or a modular plug-in system.

Most people will use some combination of breadboarding/GPIO-wizardry to achieve what you're describing. I don't think there's an "elegant" solution to something like that.

Is something like this [1] the kind of thing you are looking for?

[1] https://www.smart-prototyping.com/Qwiic.html

Disclaimer: I have never used these and don't know how good they are.

Cool! That is a great way to start.

If you look at the Crowdsupply page, for $32 + shipping you can get the Pico and a set of 'shields'. The interesting one for you would be the "Grove" shield.

"Grove" is a connector / pinout standard that was created and supported by Seeed Studio (see: https://www.mouser.com/new/seeed-studio/seeed-studio-grove/ for a video on the infrastructure and ideas behind Grove (also see the Seeed wiki here: https://www.mouser.com/new/seeed-studio/seeed-studio-grove/)

There are a LOT of different boards you can get with sensors and what not on Grove and programming them in Micropython is supported because that is what Seeed uses (calling it Ardupy).

You will have to solder the pins on the Pico and the Grove shield, but after that you can just plug them together with cables.

Grove typically uses either a GPIO (on/off), and analog I/O, or an I^2C per board. You will need to know enough about those to match up the boards with the right connector on the shield. And then its just programming.

One of the things I've used when I've helped people learn about this stuff is to use the Grove temperature and humidty sensor and the NodeD1 (this is an early ESP8266 design that also runs micro python). A Python program that reads the sensor and then does an http GET on a web server with a CGI that records temperature and humidity. Control flow looks like this:

   while true:
     temp = read_temp()
     humid = read_humid()
     http.get("http://192.168.1.5/environment.cgi?t=" . temp . "?h=" . humid)
     sleep(10)

The same web server has a page that uses D3 to plot temperature and humidity over time. Very simple and easy to do.

(and yes you learn to read the temperature and humidity over i2c, and set the chip up to connect to the wifi hotspot)

Thanks so much for the detailed reply, I'll spend a while digesting it!

One of the best things about ESP32 is that the ARduino layer is just a compatibility layer. I ported Zork to FreeRTOS and booted it natively as a FreeRTOS app on the ESP32, that was massively educational.

AFAICT basically nobody is using python to program these things, just C. Building my own breakout board is crazy. But my friend did build an Arduino from scratch on a breadboard from AVR, etc. Don't see the point- that's all work that doesn't bring me closer to driving my 3D printer.

I run a MicroPython meetup and many of the members use the ESP32. Due to it's rich feature set and low price it's basically the gateway drug to MicroPython...

Definitely not just C. Also most certainly people are using Javascript to program these boards. Espruino is a NodeJS like environment which is extremely featureful and supports alot of peripherals.

https://espruino.com/

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.

At $60+ per, that is a very expensive board unless you really need LTE built in.

they have variants with different feature sets, that is one has all the toys.

Just be aware that PyCom chose to fork the MIT-licensed MicroPython and re-licensed it with GPL.

As a MicroPython contributor I can't/won't use PyCom's fork because any code I develop for it cannot be accepted upstream.

I do like their hardware, it's a shame they chose to make their software licensing incompatible.

Interesting. I did not know this. I'll look more into it. Thank you. I agree their hardware is awesome so I will look into alternative firmware if possible.

I'd like to work on tailoring a mainline MicroPython build to their boards - to support their peripherals - but it has, so far, been low on my priority list.

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.

> 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

Funny reading this advice after all the Copilot drama.

Admittedly, I come from more of a hardware background, and it has been a tradition going back at least a century, of people publishing DIY construction plans that they expected others to duplicate. Likewise in science, a published paper was supposed to provide enough information for a skilled person to reproduce the work. Also copyrights didn't readily apply to hardware, and things like electronic circuits were actually quite hard to patent.

Maybe life was a little bit simpler in some ways back then. Things that are now being hashed out regarding usage rights in the software world, were taken for granted in the early hobby and scientific communities.

My understanding of the Copilot issue is that it's hard to know the legality of using the code provided by the tool.

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 had to write C for the first time to get arbitrary text scrolling across a random 4x7 seg display I had left over from another project. It was tougher than I thought it would be, but getting the tooling set up with VSCode was tougher. There was a big sense of accomplishment that came from getting code running on something that doesn't look like a computer though, very rewarding.

I find the M5StickC is good for this

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

Eh, if you're running Linux it's a computer with GPIOs, not an embedded device, though.

Yes - the new Pi Pico and its RP2040 family are more comparable to the ESP32, though it's a bit of a shame the Pico boards currently out don't have any wireless connectivity options.

Reply on news.ycombinator.com