EsPiFF: An ESP32 in the Raspberry Pi form factor | Hacker News Reader

EsPiFF: An ESP32 in the Raspberry Pi form factor

github.com

131 pointsjicksaw65 comments

I love seeing more ESP32 based projects and hardware. It’s a remarkably capable platform with a robust ecosystem that for a “microcontroller” somewhat resembles that of the Raspberry Pi.

I have an irrational frustration when I see people doing simple GPIO, etc with a Raspberry Pi 4 (when you used to be able to get them). I mean come on people, it has four cores, gigabytes of RAM, and can drive two 4k displays(at 30Hz) and you’re using a pin?!?

The Raspberry Pi has relatively low power consumption compared to what most people are used to with anything x86 but an ESP32 based solution comes in at 1/10 the power consumption (or less), a fraction of the cost, and you can actually get them these days.

Then I calm myself down when I remember GPIO on a Raspberry Pi is following one of the 100,000 guides that’s been written on the topic and can be done in a comfortable, standard Linux environment with a few lines of python (or whatever).

Question for this project - does anyone know the specific regulatory issues of a “commercial” product that calls for an external WiFi antenna? From my little understanding on the topic it seems that ERP, etc could pose a regulatory issue although I think there are exceptions for low scale/hobby products.

I love it, because the ESP32 is more powerful than this little one,

https://en.m.wikipedia.org/wiki/PC1512

Many folks don't have a real perception of how powerful these little computers happen to be.

Although not the same, everything from around MS-DOS 3.3 - 5.0 time that could fit onto 512KB would be a possible application, plus the extra cores and connectivity options.

You could stick the equivalent of a BBC micro in a matchbox and have room for a battery. Whole generations of programmers cut their teeth on platforms like that.

The ESP32 is stronk. I wasted a bunch of time implementing fixed point maths and lookup table trig functions because “of course” before testing it and finding that for our purposes just calling sin/cos wasn’t an issue.

Edit: If you’re doing ‘real’ real-time stuff then make sure you get a dual core model and use core 2 for time sensitive things, though. The wifi stack uses up some solid chunks of time.

To be fair, back in the day most likely you have had to use fixed point math. :)

Yep, I think the last proper embedded project I worked on before this one was on an i386EX running at 40MHz, trying to eke 40KHz sample rate processing the output of a line scan CCD. I, a brash 22yo, declared it impossible to process ~250 pixels in 10 clock cycles (there was DMA and cool dual-port RAM stuff going on). My boss at the time explained the obvious way to approach it and I tried again, I think I got to 36KHz or something after pulling out all the stops. Fun times.

The idea that you could just use trig functions and get away with it on a micro is still kinda foreign. :P

The problem is that today, a lot of programmers remember that and ignore the fact that you can often do floating point math on a modern real time system and meet all your deadlines.

Just last week I fixed a bug in such a system: in an effort to speed things up by avoiding floating point math, calculations were done with uint32_t's and the developer(s) didn't notice that in some cases there was an internal overflow before the final result was produced.

ESP-32 is a little computer that is very capable but this new breed of low cost SoC is really taking it to the next level [1].

This new SoC has MMU for full Linux installation, NPU for AI processing and network peripherals for IoT.

[1]The $8 Linux Computer:

https://news.ycombinator.com/item?id=34024914

rp2040 might be a good alternative nowadays, esp with its PIO blocks. esp32 might have some other political "risks" these days as it is made in china.

I am not sure why the Raspberry Pi Pico abandoned the 40 pin interface. It would be really cool to be able to develop C or Python code both under Linux, for ease of editing and debugging, and then run it on a microcontroller.

pico does have 40 pins, and yes I develop all c/python on it under x86 linux, you can also develop it on a Raspberry Pi.

I mean the 2x20 header. It's become a standard for Linux SBCs but not for microcontrollers.

The Pico doesn't let you use a Raspberry Pi with ssh to develop your code using the very same hardware modules that you will use on the microcontroller. You need to either make a mess of jumper cables, or cross compile and transfer the executable constantly over serial.

Wish there was an ESP64 with just enough RAM to run a Debian distro, even slowly, so we could stop waiting for Zeros to get cheaper.

You can run Armbian and DietPI (both Debian derivatives) on most small boards; some like the NanoPI NEO are in the same price ballpark as the Pi Zero, but are in stock.

https://www.friendlyelec.com/index.php?route=product/product...

https://www.armbian.com/download/?device_support=Supported

https://dietpi.com/#download

BeagleBone has always been an option. The cool kids just choose to ignore it.

It is quite expensive (US$ 50-ish). In 2023 we should have plenty of $2-5 chips capable of running a normal distro of Linux.

I have a BBB in a drawer somewhere. It's a very nice platform, but I quickly realized that for the $50, I could use a $30 RasPi B+ (back when you could get them) talking to a $2 arduino clone and accomplish the same thing far more easily.

This new breed of similarly price low cost SoC is an awesome alternative to ESP-32. It has MMU for full Linux installation, NPU for AI processing and network peripherals for IoT [1],[2]:

[1]The $8 Linux Computer:

https://news.ycombinator.com/item?id=34024914

[2]Sipeed M1s DOCK development board:

https://wiki.sipeed.com/hardware/zh/maix/m1s/m1s_dock.html

> writing permanent its log files and swap partition

If this is the problem, the solutions are no swap and log2ram https://github.com/azlux/log2ram

I also noticed that Armbian logs to a ramdisk. I didn't investigate the implementation and if its contents survive a reboot.

The only real problems for me are that the SD card will eventually fail no matter what (I mean, much sooner than a SDD or HDD) and that there are basically no Pis at sale at a reasonable price. As a platform it is nearly dead.

I have mostly relied on SSD over USB for my RPi stuff, which takes up more space... With the price hikes on RPi 8GB, I've started just getting the small intel boxes N5000/6000 series mostly, since the cost became not much different than RPi + encloser + power anyway.

Thinking about trying to sell my 3x RPi 4b 8gb in DeskPi cases with ~480gb ssds while prices are still pretty inflated.

They also have a built-in ramdisk overlay, which basically solves the problem (so long as you don't need persistence!)

I use this in a little raspberry pi project. For persistence, I occasionally copy data to a writable partition and then at boot, after the ram overlay is mounted, I copy it back.

This seems like a bug in the SSD firmware? I should be able to write zillions of times to the same logical sector, they don't map 1:1 to physical blocks on the flash.

I've also run tons of RPis off of SSD root and never had this problem. I hear about it constantly though, so maybe it's urban legend?

> While it was easy to get a (RPI) solution up and running in a short time, over time we got a lot of problems resulting from using the Pi. A key problem of the Pi's design is, to rely on an SD-card.

> after some months the SD-card broke and the application crashed. High-end industrial SD-card lasted longer, but finally still broke.

> So we made the decision, to build a replacement, which is focused on high-reliability, but still enable the use of Raspberry Pi universum of add-ons, like HATs and enclosures. We choose the ESP32 dual core, 2x240MHz WROVER module with 8MB PSRAM and 16MB Flash. The EsPiFF, the Esp32 in Raspberry Pi Form Factor was born.

> After the EsPiFF is now mature enough, we we are preparing a campaign at Crowd Supply.

I try to never rely on the Pi's SD card. Either I use a system which uses RAM disk like Alpine Linux or a modified Raspbian. You can even PXE boot with later Raspberry Pi3b+ and 4

But yes, then you need network storage or USB SSDs or something

They decided to design this whole thing instead of just going with a read only SD partition or one of the CM4 docks with eMMC?

Don't get me wrong, the end result is really cool and if just an ESP can cover their entire use case then the Pi was definitely overkill, but it just seems like inventing a flying car because you once got a flat tire.

We also depend on RPys.

Right now the supply chain problems RPys are so big,that they are reselling RP 4s for over 300 euros!!

Imagine that over night the price of cars go 3x and you have to wait a long time for them.

Different people are finding different alternatives. We also created a very convoluted solution.

I think that when the dust settles RPi will have lost a lot.

Lots of alternatives available and superior for most specific use cases, which people are discovering and/or transitioning to because of RPi's availability issues. Once this happens it'll be difficult to win those people back.

Depends on how well those alternatives bank on the situation. I've always been disappointed by the lack of support and functionality on any non-Pi board I bought.

The problem here is, that an esp32 is not an alternative for a RPi,... it's a totally different kind of a device, that is only suitable in cases, where rpi was a clear overkill. This is like replacing a truck with a bicycle... if a bicycle was enough in the first place, there's no point in even using a truck for such a simple task.

The real alternatives are many other linux-based single-board computers (from <other fruit>Pis onwards)... sadly most of them come and go, and trying to find a recent OS image (with working binary blobs) for eve a 6 months old devices is proving to be hard.

Where the price of the truck is almost the same as the bike

> if a bicycle was enough in the first place, there's no point in even using a truck for such a simple task.

Right, but people still use the truck, because it's what they know, and maybe because they like the form factor. A lot of Pis are overkill for the projects they're used in. If those projects could start using this, freeing up Pis for projects that actually need them, that would be helpful.

I think form factor and reliability account for a lot... I've tried using other arm boards, and they just haven't been as reliable in terms of support/drivers/reliability as the RPis have been in general... With the inflated pricing, I've actually just jumped up to the tiny intel systems, since I'd usually be getting a separate enclosure and ssd anyway. I can see others going to esp32 if their original use was a bit overkill, if easier to work against.

The other fruit pis also have supply issues and the boards themselves can be quite buggy. Design your own with parts you can get in sufficient quantity seems to be the way, unfortunately.

That's understandable, but has nothing to do with what the poster was saying.

...or a case with a place for an ssd an a usb3.0->sata or whatever interface...

RPi4 supports usb boot for some time now.

Yeah, but it's not something you'd really want to use in production though.

Why not? There are plenty of RPi enclosures that will bridge to USB and hold the SSD for you. For me, the cost of an RPi 8gb + enclosure + ssd + power is now close to the micro intel boxes.

It's both many times faster than booting from microSD, and unless you buy the absolute cheapest SSD from a no-name manufacture, many times more reliable.

Additionally, if you have a good power supply and don't write tons of data on a daily basis to the microSD card, it will be quite reliable as long as it's a name-brand, high quality card.

Source: I've deployed about 50 RPis in various conditions, all but two booting off microSD cards, and have only had one failure requiring swapping in a new microSD card, over the past 8 years of use.

Industrial microSD cards are especially robust and are now available from a variety of manufacturers with environmental and wear ratings that rival decent SSDs.

It's not so much about the SSD, but the USB cable being quite easy to unplug accidentally, though I suppose if you used something like one of those short Samsung Fit drives or a NVMe dock and had a custom enclosure that holds it in place after the Pi is screwed in, then maybe yeah.

For most, I'm sure the WiFi integration was the main driver for rpi, which was just plain easier to use than Arduino+wifi thanks to python on-device.

That's probably why the esp series caught on so quick: way cheaper than rpi, Arduino+wifi, way smaller than both, and still had int wifi.

They saw this, and the RPI2040 has all of the above. Python, low power, low cost, integrated WiFi.

The smaller BOM should also make this less likely to sell out permanently.

Yeah I also though the same : this justification is the wrong one (just configure your system or use a distro doesn't log on disk... e.g. OpenWRT doesn't log on NOR/NAND flash !). Regardless of logs, I totally understand that SD-cards are often unreliable (noting that RPi CM4 and also some alternatives such as some Orange Pi include an eMMC which is a bit more resilient). More generally, other justifications (more convincing than this logfile-on-SD issues) could be 1°/ the power consumption of the Pi, 2°/ the complexity of a Linux system (hence vulnerability / attack surface), 3°/ the supply chain shortages on Pis (and costs)...

Anyway, kudos to this board designers ! :)

The campaign is at: https://www.crowdsupply.com/mdc-service-wittenburg-gmbh/espi...

Personally I'm interested in running ADC daughter boards on it. Current solution is to hook an eMMC Pi-clone to a separate co-processor board, but having both on a single board is easier. An alternative would be to run a RTOS on the Pi-clone, but I don't know any that support clones with eMMC (I have Tinker Boards and RockPis)

How does one get PCBs with all the components wired in? I've been prototyping for a while, and it would be great for me to learn how to start putting stuff in cases instead of having wires dangling around.

I was looking at PBCWay just yesterday, and the process is unclear. If I say that I need some parts, do I have to source them, or can PCBWay/alternative do so for me?

EDIT: what software does one use to draw PCBs for production too? I've seen a few options online, perhaps a better question is what preferences there are. One thing I'm curious about is whether that software will say "you need this much resistance between these 2 components".

Jlcpcb has the easiest and most affordable service. They have a library of pre selected parts that you have to choose from, but it is pretty comprehensive (300k or so to choose from). They are the only ones that do the pre-selected parts library thing, but it also makes them SO much cheaper and faster.

They also have their own free eda software to design the schematic and pcb that links up with their parts library. Easy eda. It puts out a generic gerber file and bom too so you can shop around if you want to double check what the cost will be at another producer. Kicad is another alternative for PCB design.

I’m also curious how people come from the level “I know C, C++, Arduino, I understand what capacitors, resistors, transitors and diodes do” to the level of “I can integrate a 3.3V Arduino Nano with 5V or more circruitry with logic level shifters, I know when to use certain capacitor types, understand when inrush current conditions can happen, etc”. And I mean just for hobby. Not interested in anything pro.

I’m also a hobbyist and I think it’s just slow and incremental.

This year I decided to expand my electronics hobby into synth stuff. I was by no means prepared for this, but after a year of studying various synth module circuits I’m starting recognize certain patterns when I look at a schematic.

Perhaps the hardest part of this process was learning enough to start asking good questions. Everything has gotten so much easier in the last 2 or 3 months because I’ve finally built enough confidence, knowledge and intuition to ask my EE friends why something was designed a certain way. I’ve also learned that they are often equally puzzled. :-)

I think it helps if you have a project you’re working towards.

The PCB can be prepared with KiCad or Eagle for example. Then you do a lot of preparation work. You have to prepare the bill of materials, be super careful about the annotation layers on the PCB to prepare a PDF of the components.

Finally you pay. :) PCB assembly services exist from various places, for example Seeedstudio is very reliable but pretty expensive. Note that different factories have different formats for the BOM and annotation PDFs.

Speedrun

KiCad[0] is an open source tool for electronics CAD/EDA [1]. You will use it to create a schematic in the schematics editor, assign a "footprint" [2a] to each component (that's the size and shape of a components) and then import it into the PCB editor to lay these components out. The board outline goes onto the Edge.Cuts layer, the traces [2b] onto the copper layers, e.g. F.Cu for the front layer and B.Cu for the backside layer. You will also place your components on these outer layers (You won't need inner layers for a while). You can switch your traces between layers using a "via" [3].

Generate Gerber and drill files then using the "Plot" dialog, zip them and upload them to a service like JLCPCB (very cheap!), OSHPark, PCBWay, e.g. Aisler [4] if your based in Europe. I'd choose leadfree HASL [5] as surface finish. It's cheaper then ENIG and perfectly fine for the beginning.

If you are fine with soldering, then source the parts from e.g. Mouser or Digikey [6] and solder them yourself. That will save you the trouble of having to generate a list of which parts go where for the manufacturer. Make sure you order the parts with exactly the footprint that you put on the PCB.

Start small, ideally with a circuit of which you already know that it's working. This way you can concentrate on getting the details of the PCB manufacturing process right.

[0] https://www.kicad.org/

[1] https://en.wikipedia.org/wiki/Electronic_design_automation

[2a] https://en.wikipedia.org/wiki/Footprint_(electronics)

[2b] https://en.wikipedia.org/wiki/Signal_trace

[3] https://en.wikipedia.org/wiki/Via_(electronics)

[4] https://jlcpcb.com/, https://oshpark.com/, https://www.pcbway.com/, https://aisler.net/

[5] https://en.wikipedia.org/wiki/Hot_air_solder_leveling

[6] https://www.mouser.com, https://www.digikey.com/

Does it fit precisely into a raspberry pi case?

I don’t see the TRRS audio/composite video connector.

It would be good if it also had a VGA output port using USB microB.

Esp32 supports these things so it would be nice to see them on this pi “clone”. You might consider the more powerful WROVER-E which has 8MB psram and 16MB flash. https://www.espressif.com/sites/default/files/documentation/...

Add 2 CH599's for only $1 each and you could add 4 USB ports, like the RPi.

Fit it into a genuine case then you'd pretty much have a feature match - VGA video, composite NTSC/PAL video, audio, USB ports, sdcard.

"All I want for Christmas is SD-card reader on my ESP32."

- Finds micropython library. Ok.

- Finds schematics for physical connection. Ok

"But where do I find that fiddly SD-card bracket?"

- Opens a drawer, sees a mound of useless MicroSD-adaptors. Ok.

Esp32-cam has sdcard reader

That was easy -- eventually. One only has to believe what the micropython manual says and not watch any instructables-videos.

   >>> os.mount(machine.SDCard(slot=2),"/sd")                                                                                                            
   >>> os.listdir('/sd')                                                                                                                                 
   ['DCIM', 'VIDEO', 'PHOTO']

Using SD-card on ESP8266 was more challenging.

upip.install('sdcard') did not work.

But ChatGPT truly helped and suggested I find it in Github.

https://github.com/micropython/micropython-lib/blob/master/m...

> The EsPiFF V3 will bring the following > an RP2040 IO-processor additional to the ESP32

It's a shame that the RP2040 doesn't have a good low power sleep mode. Not really appropriate for battery powered applications.

> RP2040

There's a lot of shame with the RP2040 in my opinion.

1. No internal oscillator. Always requires external clock.

2. No internal flash. Always requires external flash + somewhat complex startup sequence.

3. ~500uA per MHz current consumption. Much higher than competitors (ex: STM32L1 has 180uA per MHz). This is a relatively power-hungry chip both in active, and sleep, modes.

-------

I think RP2040 is some kind of bridge device between the microcontroller and microprocessor worlds. But the M0+ core is an odd choice for this. Real world uCs / processors utilizing a Cortex M7 (or similar) would probably be a better idea?

That being said, the ESP32 is high-power (~100mA) due to the radio. Radios always use lots of power, especially during transmit. So the RP2040 probably is fine for this use case.

I <3 ESP32, working on microcontrollers is fun and there's a decent variety of tools available. You can run Linux on one ( s l o w l y ) but running on bare metal is more fun. There's a good package ecosystem for working in C or micropython.

From TFA:

> A Linux system like the Pi on the other hand, is writing permanent its log files and swap partition or to the SD-card

...only if you don't know how to configured an embedded Linux.

Even then... I mostly stopped using SD on these things when I had a (other-fruit)-Pi device that would on rare ocassion (3x in under a year) just nuke the SD card's data when power was cycled... I was using it for a mini emulation box (atari, nes, etc) and just irked me to no end. Since then, SSD over USB, far more reliable, properly configured or not.

Does it really have a ground plane directly under the antenna?

Does not matter. "Wifi needs an external antenna". And indeed there is typical Nokia antenna plug on top right.

That’s a bit weird. The built in PCB antenna on the ESP32 is pretty good. You only generally need an external antenna for some applications.

The modules with both the connector and PCB antenna normally hace a jumper resistor to switch between.

From the readme:

    Please notice, that the ESP32-module PCB antenna can not be used, an external wifi antenna is required. This is because of space restrictions, the RasPi form factor not allow us to make the board larger, and there is simply no space left for the required keepout area for the PCB antenna.

Shame they couldn’t make it work.

> Because several people mention the integrated PCB antenna, the version 3.2 offer at least a basic use of the PCB antenna. Still, the external PCB antenna is the prefered way to use Wifi with the EsPiFF, now to use the integrated PCB antenna as well. Keep in mind, that the ESP32-WROVER-IB module requires a solder jumper modification before the PCB antenna can be used.

Also from the Readme:

It's nice that they removed the ground plane, it should be fairly good now.

Reply on news.ycombinator.com