Hacker News new | past | comments | ask | show | jobs | submit login
Arduino Goes Pro at CES 2020 (arduino.cc)
190 points by actionowl on Jan 7, 2020 | hide | past | favorite | 198 comments

<rant> In my opinion Arduino and "pro" does not belong in the same sentence.

I work as an embedded software engineer who's tasked with ripping all the terrible arduino code out of a fairly large codebase where I work and the arduino core libraries are the lowest quality code I've ever had the displeasure of working with.

It's full of awful decisions everywhere in the arduino core libraries such as defining min and max macros when they're writing C++ code which in turn results in STL includes blowing up if you attempt to use something simple and safe as std::array.

I could go on for days about all the terrible decisions that reeks to high heavens of always taking the path of least resistance... </rant>

And yet Arduino has created an ecosystem of libraries, tutorials, blogs and communities that changed the industry. Now you can program dozens of chips with Arduino core, such as ESP8266/32, etc.

If it wasn't for arduino, many project would never take off.

At university I was taught to program microchip pic16 and oh boy was it painfull. Their software was low quality, errors were incomprehensible, etc.

I think Arduino is Javascript of embedded development: many people use it because it's easier, there is a library for everything and half of them don't work right.

Their i2C has had the same issue for like 8 years and last time i checked it still isn't fixed.

Agreed. Manufacturers that need volume won't touch $100 per item plus the supply chain reliability issues of Arduino distribution. Portenta is therefore, at best, only useful for a niche area of higher processing requirement small volume users.

At small volume with assured availability right now you can plug together off the shelf microcontrollers and ethernet modules for $3-5 per node. That's 5% of the Portenta price.

What Arduino originally did right was USB flashing + cross platform IDE + library management + examples + media noise. The fact nobody else has bested them is a sad comment on industry.

>> The fact nobody else has bested them is a sad comment on industry.

I wouldn't say nobody has bested them.

The real professional Arduino is the Mbed, run by ARM.

It's for professionals, by professionals, and it shows in good quality.

But, you pay for the abstraction - it's inefficient with hardware resources.

Another alternative is modm.io.

It's a modern take on the hardware abstraction layer, claimed to be very efficient.

It may just be that with it's combination of high efficiency and portability, you would get the cheapest mcu for your project.

I must respectfully disagree based on research conducted within the last 2 weeks. Everyone claims their IDE is the business, in fact all the closed source ones are all crap, poorly documented and only allow you to easily taget a subset of platforms from a subset of development environments. For example, out of the box MBed Studio doesn't support many lower and mid range chips in the STM range. If you want to buy a high end chip with a MAC, it might be a great option (look at their hardware gallery[0] for an idea of what they're clearly targeting). It's apples and oranges. AFAIK most pro's apparently still use Keil, which is Windows only and expensive.

[0] https://os.mbed.com/platforms/

// only allow you to easily taget a subset of platforms from a subset of development environments

I'm not sure the mbed is intended for products with a deep focus on price.

So less hardware selection might fit.

But modm.io does have support for some low end devices.

modm.io looks interesting, thanks. Unsure I agree with the premise that using a value line 32 bit MCU implies a "deep focus on price". To me, that would mean something like EM78P173NSO MDT10P509S11 SN8P25D HR7P155 PMS150C or https://en.wikipedia.org/wiki/Electronic_packaging#Glop-top

> At small volume with assured availability right now you can plug together off the shelf microcontrollers and ethernet modules for $3-5 per node.

Source? I'm looking for that right now and can't find any cheap microcontrollers that include an ethernet jack. The price I find make a Raspberry Pi a viable solution... which is quite sad.

Not included. Use external module, eg. ENC28J60 (dominant and open source drivers for ~all platforms) which is cheapest, SPI based and 10M limited. For higher throughput look at Wiznet modules or bigger MCUs with MII/RMII which gets much pricier - with low end MCUs you can't generate or process that much data anyway.

Thanks! I didn't know the ENC28J60 could be that cheap. I had seen it in the past but it was always 10-15$ and with a microcontroller, that made it quite expensive. Next time I order a bunch of ESP8266 from China, I will add a bunch of them too.

To get a sense of realistic prices use 1000 piece quantities quoted on electronic component stockists in Guangdong such as http://lcsc.com (or via https://jlcpcb.com/quote#/parts which is a significant subset thereof) and http://hqchip.com (but avoid the red=import results). For a popular component such as a network module, roughly assume chip cost plus 1-2RMB for the PCB, resistors and socket and assembly. Same approach works for microprocessors.

> And yet Arduino has created an ecosystem of libraries, tutorials, blogs and communities that changed the industry.

Has it, really? I have difficulty finding projects that went from Arduino to major success.

The only thing which (I think) has an Arduino that actually became a "success" is the Formlabs 3D SLS resin printer.

Few directly to market. How they’ve changed the industry is by empowering non-EEs to prototype products that they can then take to engineers to DFM. I know of, or have built, countless products that started as Arduino prototypes, even if it was just to mock up the user experience.

raises hand I worked on a product (a $150000 medical device) where I started out using an Arduino, but eventually replaced it with a ATmega.

Nope, no Arduino involved! The original Form 1 and 1+ used an STM32F103. Some of the firmware used libmaple [1], which exposes an Arduino-ish API, but most of the code was low-level C and C++.

(I'm an electrical engineer at Formlabs, and was around through the Form 1+ product cycle)

[1] https://github.com/leaflabs/libmaple

I think the whole Reprap project, thus cheap 3d printed market was triggered by Arduino....

the software on arduino sucks, the hardware on the raspberry pi sucks.

If they could have a kid...


- crappy software environment, and no networking. (designed by hardware guys?)

+ wonderful hardware.

+ The pins are female and don't accidentally short on things.

+ There are a variety of devices available with the number of pins you need.

+ Powering the device is simple and straightforward.

+ Driving different types of hardware is easy.

Raspberry Pi:

- terrible hardware. (designed by software guys?)

- hard to power. Must be 5v, power supply must be carefully chosen, lots of limits.

- pins are male. who does this?

- hardware arbitrarily (capricously?) changed from release to relase (moved LEDs, etc..)

- hard to drive different hardware

+ software is wonderful.

+ you can run a variety of operating systems.

+ you can run really high level software (python, GUI, machine learning, compiler, web server, ... so much more)

+ networking (all the kinds)

Can you shed any light on platforms that are the opposite of your experience with Arduino?

I've enjoyed doing a few small projects with PyCom [0] products and have found them good enough for what I was after, however I can stake no claim on it being any better and have always been curious.

[0] https://pycom.io/

In my experience, Arduinos are really useful as ATMega328pb boards for beginners.

Once you're used to the development environment, you "take off the training wheels" and start to program in ATMega328pb directly. Or in this case, use an STM32 ARM 480MHz chip.

The IDE is also spectacularly buggy, stagnant, and lacking so many needed features.

I'm not even sure to what to attribute arduino's success. I think they just made the simple things (GPIO and loading code to the device) simpler than anyone else. And even that is not done terribly well on an absolute scale. Think about how often new users encountered FTDI driver issues over time...

A USB bootloader and a standard footprint with a line of addon shields. 10 years ago, the only choices I saw were to buy an uno or get a pic and somehow figure out how to program it with crazy dongles and things. It was an easy choice.

So what should one use if they want to make interesting yet useful products?

I am new to this space, and have only heard of Rasberry Pi, MicroPython and Arduino.

I’m not trying to denigrate you, but “real” products produced at moderate scale will source their own microcontrollers/microprocessors, have their own pcb design, and have the BOM cost-optimized.

A Raspberry Pi or Arduino is fine for early prototyping and hobbyists, but if you’re going to make a million of something then you aren’t going to stuff a Raspberry Pi in your product unless the ecosystem is one of your selling points. Otherwise, using a Raspberry Pi means that you’re paying for USB ports, Ethernet ports, WiFi, Bluetooth, led lights, header pins, and every other component on the board and your produce probably doesn’t need them all. Including a bunch of components that you aren’t using is just leaving profit on the table.

How does one write code for arduino?

Easiest way is to download their IDE (or use the web version) and code in C/C++.

32-bit ones also support Micropython and I think there have been ports of Node.js, but I haven't looked into those.

There are also block-based coding IDEs. I have taught physical computing to primary school kids using it.

That is my impression of the Arduino codebase as well. I think the goals of the project are to say "yes" to every contribution, and to pretend that a sketch can work on every Arduino-compatible piece of hardware.

For amateurs, this is all fine. You don't care if the code is good, because you're just making a $60 555 timer. And you want your sketch to work when Adafruit sends you a new MCU in your monthly hacking box or whatever. So Arduino does very well there, because that's what users want.

Over in the real world, you pick a board and use that for the lifetime of your project. Going through 8 abstraction layers so you can run your code developed against an ARM M4 on an ATMEGA32U4 is not something anyone cares about.

What people do care about is developer productivity, and the Arudino toolchain is just terrible. I'm not talking about the IDE, which is what it is, but the actual mechanics of building and flashing devices. I have a Windows workstation, and the % chance of being able to successfully flash a sketch is about 50%. Sometimes the device switches ports and this confuses the IDE greatly. Sometimes the device just doesn't show up properly. Maybe this is all Windows' fault, I don't know, but I have the exact same problems on Linux. Meanwhile, the same board in UF2 mode works perfectly every time. I can edit Python code against a file sitting on the device, or run "tinygo flash" with a 100% success rate. What am I even getting from Arduino if I can't edit or try my code efficiently? I don't know where it all went wrong, but the arduino-cli manages to be just as flaky, so I think it's just systemic. You glue together an abstraction layer and 1000 flaky vendor-provided tools... and the result is flaky.

I think hobbyists tolerate it because they are told that hardware is "hard" (it's right there in the name), so they are perfectly happy to chant magic incantations because they don't know right from wrong. But if you've written software before, you know this is wrong. All the toolchain needs to do is translate C++ to machine code, which I know from writing C++ that can all work quite well. Then the toolchain needs to copy that machine code into Flash memory on the device, and tell the MCU to restart. I know this works quite well too because I've used UF2 programmers and it works every time. Finally, you need to make a virtual serial port to support debugging. My tinygo programs successfully send serial output to my computer 100% of the time. Arduino IDE? 50% on a very lucky day. Mostly I click around hopelessly, crawl around on the floor trying to plug and replug USB devices, press the reset button on the MCU 700 times... and then 30 minutes later I can see my debugging output. What was I working on again? I forget.

Anyway, I suppose that none of this is unique to Arduino. I've used Atmel Studio, I've used Nordic's NRF52 dev kit, I've used avr-gcc and teensy-cli... all are bad in their own way, but they do consistently work and don't get in my way. Arduino consistently gets in my way by not doing the basics right consistently. All so my code can run on devices that I don't have. It's not worth it. I am not sure how this appeals to pros. They should hire some actual software engineers and check back in in a year. I'd be happy to try Arduino again.

I have pretty much given up on Arduino. They had me almost interested again when they announced the Pro IDE, but several months later they still haven't put the source code on Github: https://github.com/arduino/arduino-pro-ide

I am not interested in the Electron-based IDE, but they seem to be using the Clang language server, which is perfect for integrating with Emacs. I have been sitting here for months ready to hack on this stuff and make it work perfectly, but all I have to work with is the raw source files contained in the Electron bundle with no license, so I've basically given up. Once again, the Arduino team is doing Weird Stuff with software, and this whole Pro thing feels like "the joys of working with Broadcom, but we stick random Open Source logos on thing without actually being Open Source".

I have a lot of microcontroller projects I want to do, but without modern development tools, it's not worth it. They are so close... just let me hack on your source code, please. I'll do it for free and you can do whatever you want with the code. But they don't seem to want to play ball.

(Recently I have been playing with Tinygo, but I am still not motivated because "go doc", my favorite go tool, and gopls don't work... and I'm not quite sure that it's worth the effort to make work yet. My toy tinygo projects have gone pretty well, though, so maybe it is worth making their IDE support work, and forgetting Arduino ever existed. I feel like Circuit Python / Micropython is the path of least resistance right now.)

Too bad regarding the Arduino pro IDE. There’s so much room for improvement in microcontroller space. If you can use a Linux based SBC you might check out Nerves (nerves-project.org/). It’s nice for a lot of “one off” projects and with boards like orange pi zero, pi zero, etc the cost isn’t bad. I’m working on support for Omega2+ boards which are pretty low power and have decent WiFi. Still they’re not as suitable for low power, really small size, or real time projects. For microcontrollers, Rust seems to have decent support for a few of the STM boards. I’ve been tempted.

Get an STM32 "pill" board, platform.io in VSCode or any way you like to write C using CubeMX to generate a project structure, then Make to build and flash.

STM HAL isn't exactly great either, but Arduino is best placed IMO as entry level novice stuff, or blasting out something working in five minutes.

You have lots of microcontroller projects you want to do, but can't because you can't get up to date source on the arduino IDE? wat? Just use a different editor.

I have other stuff to do, and the prerequisite to any microcontroller project is to spend a week fighting with tools. So I just don't care enough.

You can use Visual Studio/VS Code with plugins like (free) VisualMicros or (paid) VisualGDB to build Arduino C++ in a much better environment.

Platformio is also a good choice.

Platformio is definitely what I’d recommend using. It’s been the best experience I’ve had so far

Looks like they're finally using a top-of-the-line MCU, the STM32H7. Very nice.

Unfortunately I don't see how this is a significant improvement otherwise for industrial uses, where the biggest barrier for custom components is certifications (FCC, UL, CE, ATEX, etc).

Those SMT32H7s are some beefy cores. Colocal M7 and M4. Lots of fun, compact deep learning work going on for those chips. Same with NXP's RT1000 series.

... In theory, if you could debug your code. The debugging capabilities on Arduino boards are unfortunately basically inexistent compared to traditional MCU dev boards. Hardware is great I agree though.

Which in my opinion makes the "goes pro" statement misleading. Without proper JTAG/SWD debugging functionalities, how do you program anything serious on Arduino?

we released the beta Pro IDE with JTAG debugging capabilities. we have a powerful cli written in go which lets you compile /upload your code very simplt with whatever IDE you like the most. This board is certified for industrial temperature and other industrial certification are being done now.

Oh I wasn't aware of these, it looks awesome - thank you!

Write a makefile and use GDB I guess...

printf() FTW

STMCubeIDE integrates pin routing, debugging, and writing of code all into one nicely packaged solution. If the goal is to write and debug Arduino code, the Arduino API could be integrated into your Cube project while also reaping the benefits of Cube.

javascript and python support seem like huge improvements

On one hand I think it's ridiculous to mention these languages for industrial applications.

But I've also just spent the past year programming an automated mobile restaurant. We use a traditional PLC for everything safety or time-sensitive, but everything else is JavaScript.

We're planning to use even more JS on the next-gen system. Details are in my profile if you want to help, or if you want to convince me otherwise.

BASIC was a common industrial automation language at one time. If the platform has the resources, use them.

You've just reminded me of the BASIC Stamp, which lead me to find this interesting website comparing that to the Arduino head-to-head. The BASIC Stamp was weirdly expensive for what it was, but that's probably my post-Arduino post-Raspberry Pi bias:


> Getting to the “Hello World” of microcontroller projects, the blinking LED, on Arduino costs $32 compared to the $119 for a Basic Stamp. This is perhaps a little unfair because the Basic Stamp board contains a full bread-boarding space. A similar setup for Arduino would cost about $60, still a 2x savings (and can made cheaper if you want).


> The standard Atmel AVR ATmega8 chip used on the Arduino board can be obtained for less than $4. The Basic Stamp must be obtained from Parallax and costs $50.

As a kid who once got a BASIC Stamp microcontroller and project kit, one super important thing to understand was that it came before Arduino brought the prices way down. It was reasonable for what it was at the time, ie a tool used for teachers that also happened to be sold to the public. I don't know how popular it was in industry

Why JavaScript? Unless it's a training constraint, I just don't see anything about the language that directs people to write good code.

It just seems insane to me to use a language with such bizarre semantics.

Investing in a better class of developers is not only more expensive, it's more difficult to find them, whereas javascript developers are a dime a dozen.

I think you should stick with the language you know the best, especially if you are the one doing the coding.

I agree with that, but writing code for industrial applications is fundamentally different from whipping up a backend for the hottest new Lyft for Parrots startup.

If industrial equipment malfunctions, people can be killed or horribly maimed. Industrial equipment needs to do exactly what it was designed to do 24/7 for years or decades in horrible (EMI, temperature, etc) environments.

> If industrial equipment malfunctions, people can be killed or horribly maimed.

In what way does C vs. python or javascript have any impact on this? If anything, C has way more ability to shoot yourself in the foot than python or javascript. Hell, what about a non memory-managed language like rust?

Like somebody else says, this feels more like a cultural issue than an actual technical issue.

Because the debate is often not C Vs JS/Python, it’s [C, Js, Python] Vs [Ladder Logic, PLC-specific Langs] where PLC languages have time-guarantees in the language

If someone is dumb enough to be using an Arduino in a life-critical application then what language they're programming it in is almost a moot point.

To the larger point of coding for these kinds of applications, keep in mind that there are entire classes of bugs that are common in traditional microcontroller languages like C which literally do not exist in Python or Javascript.

As far as I've seen as an outsider to the embedded world the main barriers to adoption of higher level languages have not been based upon concerns of reliability, but instead memory usage and timing constraints, the former of which is less and less of a real problem outside of extremely cost constrained applications.

Pretty sure that class of equipment will not be using any kind of Arduino board (see also: certifications above).

I've been in a few 27/4 biotech labs that run all the environmental sensors, and some of the industrial controls, off arduinos. ALways fun to open a field box and find a DIN-mounted Uno.

HN commenters love to talk about how Raspberry Pi and Arduino boards aren't suitable for use in production hardware.

I recently had a chance to wander around one of the bigger EMS factories in the Bay Area, rubbernecking at everybody else's products in various stages of assembly. It's safe to say not many naysaying HN'ers have done that recently, or they would be saying something very different.

The comment I was replying to was talking about DEATHS being caused by failure, not environmental sensors. I have nothing against its use.

Agreed, and I'm not necessarily defending this practice, just saying that it is, in fact, being done.

One of the RasPi-based devices I saw being assembled was actually some kind of medical device that will presumably have to be FDA-certified. It was going into a very nice enclosure, with top-grade plastics and other materials, and they were building a (literal) ton of them. In principle I'm sure that can be done successfully, but I have to wonder if it'll really save the company that much time or money.

I've used embedded linux systems for industrial control systems many times. In those applications, as you mention, we integrated with a PLC for life-safety systems or another control system via contact closures. We ran python for most of our on-board system level software and some networking related services. No way in hell would I have used our output relays to do things like close a flood gate.

Most modern embedded devices are way more powerful than 60's mainframes where Lisp used to run, or Xerox PARC workstations, so I see it more as culture issue than anything else.

Heck, the ESP32 runs circles around the Amstrad that I used to play Defender of the Crown on.

it's a dual core board. you run c++ /mbedos on the CM4 for your mission critical software then you can use the m7 for high level languages / tensorflow. you can even RPC between cores

What's the automated mobile restaurant?

Our first brand is "Ono Blends", a smoothie truck in LA (onoblends.co)

To address the sibling comment, we don't use much TypeScript yet, but I'm open to it. I'm also looking at ReasonML because I'm cautious about half-measures when it comes to type safety.

Much of our complexity stems from race conditions between PLC and the JS server, so the next system is likely to use node.js on linux boards instead of a PLC. We currently have a supervisory safety system with all safety-rated hardware and controls, and will almost certainly continue using this approach as we replace the PLC.

Are you using TypeScript?

I might be wrong but I believe the problem with using these languages in industrial applications has to do with the back end running them as these os's are subject to system calls or interrupts that mess with critical timing situations.

I believe this is the reason 3D printers and other CNC machines still use a seperate dedicated controller such as original arduino rather than just using the GPIO on a newer arm board running a full stack.

There's Industrial, and then there's Industrial.

Factory automation applications written in BASIC have been a thing for decades. Javascript & Python are improvements in many ways.

Like everything else in engineering, you have to know what you're doing, what you and your tools are capable of, and what performance is needed. Not everything has a 1ms deadline and the vast majority of so-called "industrial" applications will work perfectly fine on a 1-second loop.

True enough, there are many applications that do not require critical timing.

As far as engineering goes I would expect most engineers would feel more comfortable putting their seal on something that was over-engineered than just good enough. This is similar to why when designing a circuit it is common practice to double the power dissapation or wattage of components.

I see no reason Java or Python languages wouldn't work or any other language for that matter, as long as they were running on a stable system, I'm just not convinced that arm processors offer that stability but again I may be wrong.

I think the vast majority of these iot applications are something like “read; send; sleep 60”. But your point stands that people needing high precision and timing probably won’t reach for this.

That's the point of having the M4 cores alongside the M7 though, isn't it? Let the M4's handle real-time stuff like driving motors, and the M7 do communication and/or user interface.

Do they share a memory bus? How do they contend with devices? Can an interrupt or memory access on the M7 core cause the M4 core to miss a critical timing? If so it's not really a good design.

If it's two totally independent cores with totally independent sets of devices, how do you manage the pinmux? Are there independent pinmuxes?

And finally is the M4 core capable of detecting single-faults in the cache, memory, flash registers, and instruction pipeline? Such as might be caused by cosmic rays?

These are some things I would look for if I was specifying a processor pair for use in a safety-critical system.

I tried reading the datasheet and they could have spelled out a lot of these things a bit more clearly I think.

As far as I can see they have mostly separate memory busses, and a lot of the peripherals can only be accessed directly by either the M7 or the M4. Though there is some cross-bus access and how that works I have no idea.

They specify that all the SRAM memory and Flash uses ECC, but no mention of the registers that I could spot.

By no means a simple chip to wrap ones head around, but certainly looks interesting. Pricing of the Arduino though... not for me, at that price I'd rather take the RPi plus some extension board.

I am very interested in your comment about different core functionality. If I understand you correct there are different functions for specific cores, if this is true, I would humbly request that you create a blog/post covering this topic as these traits have been totally been missed by me. This is probably the result of my biased opinion towards ARM devices but I would genuinely like to know this information.

I'd never want to write microcontroller code in js or even really python. You spend most of your time moving strongly typed data around so yea, it's more accessible but you can't really do anything serious unless you're at least using a language with a reasonable type system.

Try it.

MicroPython/CircuitPython is the funnest thing ever. And you can do all the serious things you need. There is nothing you can't do in MicroPython. And if you need to do stuff fast, writing C libraries is quite easy.

It's totally fair to not like it and for sure it has strengths and weaknesses, problems where its a good fit and problems where it is a bad fit - but don't dismiss it. It's simply to good for that.

I know it's heresy but I don't really enjoy python in general. I only really use it for tooling and I find the environment is really annoying. I'm generally a big rust for uC advocate though.

Rust is really great for microcontrollers, the Embedded WG is doing great work!

I think that languages like JavaScript or Python really shine is when you need to iterate quickly to understand your problem space. And where they suck is when you're trying to maintain some really prickly logic that someone "clever" wrote. But you can also get into the same kind of trouble in C++ or C.

My favorite example of that is the system that a contractor wrote for us using bitwise logic and dual-nested loops that worked perfectly for function but each time we needed to make a change we needed at least 3 days to re-read the code for understanding. It passed all of our system-level and integration-level testing but if you put any one of us on the spot about how it actually worked we would have been screwed.


ARM M7 at 480MHz and ARM M4 at 240MHz


16MB Flash

USB, host and device



10/100 Ethernet

MIPI DSI lcd panel

DisplayPort over USB-C (graphics out)

Integrated Li-Po charger

3x ADC 16 bit

2x DAC 12 bit, 1MHz


22x Timers

2.95µA in standby mode

That's obviously way too much to come out of the Arduino style pins. There are two 80 pin high density connectors on the back which have everything on them.

The price seems very high for the category.

Arduino's have always been a little pricy for the hardware you get. I think a lot of what you pay for (at least for a regular, non pro, Arduino) is the ease of use and the eco system.

That being said, do you have any examples of other entries in this category that are suitable for industrial / automotive use?

There's little reason to commit a whole Arduino board to a project when you can easily flash the Arduino bootloader onto an ATMega and embed one in your gadget. I think I own exactly two Arduinos: an UNO SMD edition that I use for flashing bootloaders on ATMegas and programming ATTinys, and a regular UNO that I stuck a ZIF socket on that I use to program ATMegas.

Yeah you pay for the hobby convenience of flashing over USB on the regular board which is a nice convenience when you're just noodling around with a project not intended to become a product. (Or doing rough PoC prototypes where iteration speed is important).

Definitely, looks like others are taking note. All of TIs newish launchpads seem to have a built in usb debugger/programmer. Pretty sure that was a direct response to the popularity of Arduino.

Eh, TI has been doing the in circuit programming route on their BASIC Stamp boards since before USB was popular. I don't think they had anything special for debugging though

> The price seems very high for the category.

Does anyone else remember when a Keil C 8051 at 20MHz devkit would cost you several hundred dollars for the hardware, and then several hundred dollars for the compiler?

I remember... it was like... what? 10 years ago? Not actually very long ago...

the product starts a 49. it's an industrial product with industrial temperature grade parts. it's also a quantity 1 price. if you buy in bulk directly the price comes down

Not trying to troll - just don't know.

Why would anybody use an Arduino versus a five dollar Raspberry Pi Zero?

>Why would anybody use an Arduino versus a five dollar Raspberry Pi Zero?

1. The $5 Raspberry Pi Zero isn't really $5.

2. The fact that the $5 advertised price isn't the real price, and the inventory games they play raises ethical problems for some people.

3. You can get an Arduino clone for less than $2 (for real, and in bulk).

4. The Pi and other SBCs have higher power requirements, so they can't reliably run off AA batteries.

5. The Pi also requires an SD card, increasing the cost.

6. The Arduino comes in many form factors which are considerably smaller than SBCs.

7. The two aren't drop in replacements, the Pi runs a "real" opperating system that does a lot of things in the background. So communicating with other devices which have specific timing requirements is significantly more difficult on the Pi.

8. The market for Arduino "shields" is much more competitive than the Pi "hats".

9. There are just a lot more shields and sensors available designed to interface with the Arduino

10. The Pi's IO pins are 3.3v, where the Arduino's are (on most boards) 5v. So using sensors/boards designed for the Arduino requires a level shifter

But $5 is the real price of the Zero. Perhaps you’re thinking of the Zero W, which is $10? Or do you mean the $5 doesn’t include the power? If that’s what you mean, it should be noted that power doesn’t come with Arduinos either, and they both can be powered via USB.

And to what unethical inventory games are you referring? That seems like a pretty serious accusation you’re making.

When you actually try to buy one from the very few distributors permitted to sell them, you'll either end up paying $5-$7 in shipping, when it could be shipped for closer to $1 USPS. And you're only allowed to buy one. Or, if you walk in to a MicroCenter, the only distributor with a physical location you can walk in to and buy one, they're either out of stock, or again you're limited to just one, but you can buy more at a higher price.

I ran into this problem the other week. I was trying to buy 5 pi zeros for a few projects I have in mind and a couple of backups to have lying around. Couldn't do it. Very frustrating.

Anyone needing to buy several Pi W's should look into the Orange Pi Zero. They also play some games with the shipping cost, but at least the shipping cost per unit goes down the more you buy. Buying 5 would run you $10.60 each, and 10 would cost $10.30. (All US shipping prices from AliExpress)

The main thing to look out for is that it doesn't have HDMI out, only two headers for composite out. I imagine most people plan to run them headless anyway, but unless you have something that can display composite video, it can be a pain to set up at first.

Another option is that when you buy from Adafruit, you can buy one of each version. One Zero, one Zero W, and one Zero WH, for $29 plus shipping. You can then buy a USB WiFi adapter off E-Bay for about $1 shipped, and as many USB OTG adapters as you need for less than $1 each. Depending on shipping, that puts you in the $11-$12 per board range.

The $5 price is only valid for a single unit. When Microcenter has them has them in stock, they are typical $5 for 1, and $15 for every one after that. Other stores online who stock them avoid this issue by limiting you to a single item per cart. (I checked all three stores linked from the official RPi site; all behave that way.)

Microcenter often has the Zero W also discounted to $5 for a single and then $15 for every one after that. Right now, they have them discounted to $10 for 1 and $20 for every one after that. https://www.microcenter.com/product/486575/raspberry-pi-zero...

Forum post from a member of the Raspberry Pi team: "They will never be available in bulk amounts at the $5 and $10 price points, it's not cost effective to sell at that price. But they ARE available for bulk buys - i.e. demand no longer outstrips supply.

But we can sell individual items at that prices, for educational needs - i.e. those who cannot afford the higher price of the Pi3. Call it an educational discount." https://www.raspberrypi.org/forums/viewtopic.php?t=201916#p1...

From the above, I agree with the other poster who claimed that $5 is not the real price for the Zero, but rather a limited quantity specially discounted price.

> The $5 Raspberry Pi Zero isn't really $5

It is a real price. For the Zero W. I bought one a year ago. Ordered it, then headed to the store a bit later. https://i.imgur.com/ajeH8PQ.png

They've since changed the price to $10.

I also bought many at $5. One at a time on each trip into Microcenter.

IMO, if I can't buy 10 of something for $50 or 100 for $500, the "real price" isn't $5/unit. Microcenter would pretty consistently sell $5 for 1 and then $15 or $20 for each additional unit.

Not a bad question at all. The Arduino offers you the ability to code on a lower level, while the Raspberry Pi is giving you a full operating system. Some projects, especially IoT, don't need all the overhead of an OS with and without that comes improved reliability and better understanding of the state of the device.

Can you not flash a pi with some non-OS firmware?

I've been extremely pleased with the Nerves project. It's Elixir (or any flavor of Erlang, really) top to bottom. The toolkit will build and flash the SD card, so you don't need to worry about anything except your app.

Very nice to be able to ssh to my Pi and get dropped immediately into an IEX repl (no auth, no command prompt, it's just IEX over SSH)

That's incredible, thanks for sharing! Here's the links for the lazy:



Is nerves running without an OS on the Pi (baremetal)?

It's running on Linux. I am not privy to the specifics.

Yes; or, for greater ease-of-use, you could just write your logic as a Linux kernel driver, leaving the rest of the OS to do its job. After all, from the perspective of the controller, you're interacting with a peripheral—and that's exactly what device drivers are designed to do.

Yes, can do bare metal https://www.raspberrypi.org/forums/viewforum.php?f=72

Though I'm sure many `purests` will say this is not bare metal and it's impossible upon modern CPU's due to the ISA microcode.........

Which is weird because you'd think the board that could run Linux would cost more than the one that you're not able to run an OS on.

The RPi (all variants) is more expensive than the readily available AVR boards that you would use to deploy a solution (even if those boards are just Arduino clones which are readily available for at/under $3 delivered to the US).

The genuine Arduinos are expensive. The clones are cheap.

This crowd probably want no os

I would have thought that the real competition was the ESP32. It stays in the microcontroller space (no OS to manage, should stay lower power, etc.), dirt cheap, ships with wifi+bluetooth.

I'm doing a hardware selection and after much consideration, I'm picking a 3$ esp8266.

I don't see any purpose of Arduino outside education for kids. Makers should use cheaper products/knockoffs at worse.

The ESP8266 doesn't have hardware PWM, and only a single ADC channel, both which can make it unfit for a lot of tasks.

That said, it does come with a lot of SRAM and the wifi/bt connectivity is obviously great.

The only very slightly more expensive ESP32 boards have 18 ADC channels, 16 PWM channels, and 2 DAC channels.

Yeah the ESP32 is pretty darn awesome.

> The ESP8266 doesn't have hardware PWM

There are actually hacky ways to work around that using DMA but yeah. Software PWM sucks.

I recommend trying the ESP32 as well (more pins for ADC and a few other features).

Either way, the ESP's are an incredible value (I use both).

Same. I have a bin full of esp8266's that have become my go-to for little projects. Going to play with esp32's when I run through them

Fortunately ESP32 does have an OS, so you can use all kinds of niceties (multitasking, bootloader, etc.).

Which OS are you referring to? FreeRTOS or something else?


In an industrial environment price is usually less relevant, or even irrelevant. Reliability is key here.

Downtime of a machine can quickly rack up huge costs, so you want to spend extra on hardware that can resist greater temperature ranges, vibration, radiation, magnetism, moisture, etc.

Reliability is key.

But is the quality of the Arduino software/libraries good enough ?

this board runs MbedOs from arm which is a very robust Rtos with very advanced features. The the individual quality of libraries depends on the author like in any open source project.

There are many good Mbed boards available.

So calling this "the Arduino goes pro" seems like "marketing".

Reliability across power cycles or brownouts, for one.

Cost is another - sure the dev boards are expensive as compared, but the chips used are easier to integrate with your own designs than building an rPi into them.

Just different use cases, in essence.

AFAIK you can't do real-time stuff on a Raspberry Pi

Raspberry Pis aren't great when working with analog signals. I don't think they even come with analog->digital converters, and PWM can be janky

SD cards suck, when it comes to reliability. You can mitigate this by making the filesystem read-only, but your SD card will still crap out more quickly than built-in flash memory would.

Supply used to be an issue with the Zero, but I don't know if that's still true.

You control every clock cycle on an embedded controller.

You are at the mercy of the OS on a Pi.

For somethings that doesn't matter at all, for others it really, really does.

More detailed comments below, but in short: - lower power consumption (that you can control) - different environmental tolerances - peripherals with hardware support

Looks like this has a integrated Li-Po charger which should mean you can have a UPS like battery backup.

Folks may use this as a development platform that eventually gets a custom PCB made for the end product. ( it's open hardware so it has all the schematics https://content.arduino.cc/assets/Arduino-PortentaH7-schemat... )

It's really just different features for different needs.

ADC, DAC, and 2.95uA timers.

Can your Rasp. Pi Zero sleep at micro-amp currents, and self-wakeup 5 hours from now to perform some task, and go back to sleep? The specs here for this Arduino are downright ridiculous for low-power applications. We're talking about using 3x AA batteries for MONTHS. (3x NiMH AA will be 3.6V with 2000 mA-hrs. Using 3uA is 600,000 hours of battery, or 25,000 days of charge. You'll "only" last months because NiMH AAs will self-discharge before your Arduino actually uses all the charge).

And the Arduino here has all of the analog circuitry you need. 12-bit DAC means you have 4096-levels of output... a 3.3V signal can be varied in 0.8-millivolt increments. That's 0.0008Vs per increment.

The 16-bit ADC means that the Arduino can sense 0.05mV differences (probably at very low frequencies, but its an option with the right tradeoffs). Without any supporting chips. Alternatively, you have a 1MHz ADC (at some unspecified lower resolution. Probably 1MHz best-case 1-bit ADC), which means you can perform a million measurements in a second, to measure "rate of change" of your sensor.

The "1MHz" spec is useful for motors and other higher-speed equipment. If a Motor is rotating at 12,000 RPM, 10kHz ADC (1/100th of the max rate 1MHz, or 7-bits of precision per sample) will still be 500 samples per rotation, more than enough to get a good estimate on the motor's velocity.


Application: 3xAA batteries, remote sensor that sends a WiFi packet every hour for temperature (or any other sensor that can be represented by voltage between 0V to 3.3Vs. Or even a sensor that needs to "sample" over a few milliseconds to get a value, such as determining the speed of a motor)

Stick a cheap 5V solar panel + some simple charge circuitry to trickle-charge the AA NiMH batteries, and you probably can run the rig indefinitely. (Really, you just need to ensure that the AA batteries don't leak current through the solar panel. So maybe a 0.7V diode to prevent backwards current, and you're set. 5V solar panel minus 0.7V diode outputs 4.3V nominal, but then becomes current-limited (probaly??) as it drops down to the 3.6V the batteries are set at. As long as you're only pushing milliamps, you're in NiMH trickle-charge mode which NiMHs are really, really good at).


EDIT: I didn't even notice the integrated Li-Po charger. NiMHs are cool because they're bloody simple to use in trickle-charge mode. But if you've got a Li-Po charger built into the damn thing, you might as well use Lithium-Polymer cells instead.

There's a ton of complexity involved in safely charging, and discharging Lithium-Polymer batteries. But hell, if its built into the Arduino, might as well use it. In this circumstance, the 5V solar panel is plugged into the Arduino somehow, and the Arduino charge-circuitry will then safely handle the decisions involved in charging / discharging the Li-Po battery (also hooked up to the Arduino).


EDIT2: I guess a "normal" Arduino can do this at low power consumption too. The reason to get "Arduino Pro" is for integrated Wifi + 480MHz processor. So you'd want some "difficult calculation" associated with the sensor reading... maybe a local GUI with a screen + Javascript to simplify the GUI-design.

The Arduino can sleep most of the time, but if a user comes up to maintain the device, they can click a button, bring the Arduino out of sleep mode. It boots up to a Javascript web-GUI for maintenance, and then sleeps back down to 3uA sleep mode once the user is done with local maintenance.


100 Mbit Ethernet can have PoE, so any Ethernet Wire could transmit power instead (to a Rasp. Pi Zero). The Arduino's niche would be some kind of wireless, remote-power situation that requires very, very low power consumption on the scale of weeks.

Great comment!

I wonder if the newer low-self-discharge batteries might get you even more lengthy usage times. Something like a gen 2 Eneloop lite can hold onto 60% of its capacity after five years[1], which is just plain insane.

[1]: https://en.wikipedia.org/wiki/Eneloop#AA_size

If this is true, this makes possible a lot of very-low-power wireless applications where longevity is important. I'm recalling a project at my first job where we were using e-paper and CR2032s with wireless transceivers to create electronic shelf labels.

Longevity is important in this application because replacing batteries is very labor-intensive.

Arduino is a microcontroller, made for realtime. Like a stepper motor vs a normal DC motor

Or to buy a car when all you need is a wheel.

I don't think it's anything to do with the price. I'd say there are three primary reasons (based on my personal experience using each):

1.) Pin control simplicity - Arduino's bread & butter is basic logic statements wrapped around pin signals (e.g. if pin #1 receives an inbound burst of electricity, tell pin #2 to send an outbound burst of electricity). Since most commercial processes are loops of very specific routines, this is all that's needed (not to mention it's easily scalable to massive operations).

2.) Battery backup - Raspberry Pi wasn't really designed to be powered by batteries, and voltage fluctuations lead to crashes. Also, since Raspberry Pi requires more power (than Arduino) to operate, it would eat battery life much faster.

3.) Startup consistency - When Arduino is powered on, it has a consistent startup that quickly loads your sketch. The restart behavior is predictable and downtime is minimal. With Raspberry Pi, you're dealing with an operating system starting up. This makes it much more cumbersome to get back to where it was prior to loss of power.

Zero's are not available in bulk ( one of the many reasons actually ).

I thought zeros were available in bulk, just not at the $5 promotional price point.

They have Compute Modules for bulk use which are basically glorified Zeros anyway.

> five dollar Raspberry Pi Zero

They still need an SD card to function. So, that price is going to double at a minimum.

the pi is a great device but it's a consumer grade device. there are number of use cases it doesn't support very well (low power, realtime , industrial operational temperature etc)

Arduino is a much simpler device. Pi is a full linux computer, as opposed to Arduino which is a microcontroller.

this product doesn't follow the classic definition of microcontroller. (you can rve run a version of Linux on this thing)

For some applications it makes sense to use both. Use something that runs an OS for the high level functionality that it provides, and connect it to a microcontroller running simpler code for the stuff that has to run in real time.

The question is akin to "why would anyone buy an S-class Benz versus a Hyundai Elantra?"

They exist at different positions on the price/performance scale. It's as simple as that.

That doesn't seem like a valid analogy unless an S-class Benz is 10x cheaper than the Elantra?

It might be worth explaining the difference between the two. Plenty of people would have trouble understanding your analogy between the two cars. Jeff Bezos drives a Honda Accord.

[response edited] Actually, I think that kinda makes my point better than I did myself!

Using Mercedes vs Hyundai implies that there's a difference in quality, whereas my intent was to say that they are basically the same but with qualitative differences that only matter depending on the actual circumstances.

I find that the typical answer to questions like this (e.g., the ones already given) tend to confuse the questioner even more by tossing out technical jargon out that isn't helpful.

In the end, the choice of one computing/control platform vs. another is really just which one happens to be a more suitable choice for the problem it's being thrown at.

Again I'd have to ask you to explain the difference. If the differentiator is price, then why doesn't the richest man in the world have the most expensive one? It seems to me that if the richest man in the world drives an inexpensive car, then the more expensive car is worthless. And then to use the analogy, the more expensive Arduino is likewise worthless?

The reason I liked your answer is that it shows that the selection of Arduino vs Pi or Mercedes-Benz vs Hyundai is "application dependent."

Ultimately they're both computing platforms used for control purposes. In some cases, the predictable I/O performance of the Arduino is an advantage over the Pi. In others it's not. In some cases, the built-in network access, CPU speed, UI capability of the Pi is an advantage, in others it's not.

If Bezos actually does drive an Accord (with an entourage of security around him I imagine) then all that tells me is that for his "application," it's sufficient. It doesn't say anything about the merits of other cars.

The Pi is commonly used as a media center, the Arduino is used for prototyping your next invention. :-)

I’ve owned both. An S class accelerates faster, is quieter at 80mph, has more tactile feedback in the switches and controls, is more comfortable to drive for 2+ hour trips, has more space in the trunk, has a better audio system, has a more adjustable drivers seat, has better climate control, and is safer in a collision.

What I'm trying to do is prompt HeyLaughingBoy to provide useful context to their comment. Is this new Arduino really like the difference between an average car and a luxury car? Does it really make no difference which one you pick except for the money you're willing to spend?

No one needs an S-Class, it's merely a nice-to-have. Is that the same statement that no one needs this new Arduino? That they should only buy it if they have extra money to spend and want a luxury item?

Lots of people need S classes... professional drivers for luxury coach services. Get an Elantra and your revenue goes to $0. People need the new Arduino if the scenario being implemented requires it.

See, that's getting close to an actual answer.


The nice thing here is that they appear to be using automotive grade components (it says -40 to 85°C operating range). I've previously designed electronics for extreme temperatures (up to 150C in our case) and building hardware that works at those temperatures is very tricky. It's nice that you can buy something off the shelf like this, my life about 10 years ago would have been so much easier had this existed.

Why wouldn't you move to the existing STM32 ecosystem instead of sticking with Arduino for pro/industrial applications?

Most of Arduino's value proposition is easy programmability by non-professionals, with a vast library of examples. Cheap and powerful STM32 boards have been around for years about as long as arduino, supported by a number of free toolchains. But the care and feeding of said toolchains and libraries requires a lot more technical knowledge than Arduino's ecosystem.

I agree with this statement, and really praise what Arduino have done in this space (I started on one years ago). However, I think if you really want to work with embedded systems, you have to understand the technical details.

Understanding how communication protocols are supposed to work, knowing how to read a data sheet, and using those skills to set registers on an IC directly should be in everyone's toolbox. Otherwise, you're limited to whatever chips someone's wrote an Arduino library for.

Plus, debugging is much more difficult if you can't analyze a stream of data with a scope or logic analyzer, and actually understand what you're looking at.

To be a professional developer of embedded software, of course you need to be capable of dealing with things starting from the bare metal. Arduino is a recognition that many embedded software problems can be usefully solved above the register level. The deeper levels will always be there for those so inclined.

Do you have any good resources for embedded systems that you can recommend?

I was going to pick a few cheap books on Arduino as I thought that was the way to go.

I am a hobbyist, but I want to try to build some viable products.

Since https://platformio.org/ that is no longer the case as well.

This has been a major gap for Arduino for a while, and it's cool to see them take a crack at solving it.

Beyond the hardware, I'd love to get some more details on the software tool chain and their plans to sell/support turning the prototypes into production modules.

production modules

If there's no second source of boards, I can't consider that production ready for anything. It was and still is a COTS module that can be modified for a single purpose application but there's no way I would resell this as a commercial unit.

Same for RPi and all the others. Spin it yourself or take your chances.

The beauty of Chinese capitalism is such that if these become popular, clones will proliferate. I sell an industrial product that uses an Arduino Nano as a module on a PC board because I can buy them cheaper than I can build them.

Now, if you really care about supply chain security, that might be a problem, but for everyone else...

also if you care about your product actually working. There are so.many Chinese clones that are badly made or outright dangerous..

I wonder if this will finally bring HD video encoding to arduino platforms?! I'll have to check what kind of VPU IPU the STM32H7 has, at least I don't see how they can break out the IO for a camera interface, but this would be amazing.

Looks like the STM32H7 supports one MIPI CSI-2 peripheral (and/or one MIPI DSI).

Another comment on this thread mentioned on the back of this module are two long flat board-to-board style connectors.

Interesting, there has always been a large chasm between "Hobby" grade MCU boards like Arduino and "Industrial" grade systems. Hopefully this shift can get more people through that chasm into productive applications.

So Arduino Pro is an "IoT Platform". What is that? Can I say that it's a Cloud, like AWS/Google Cloud, but specifically tailored for IoT so we don't have to do it ourselves? (Or, a PaaS)

it's a combination of hardware Dev tools and iot cloud to build AIoT projects / products

A little out of topic question, but I'm curious is it possible to program Raspberry Pi on low level without OS, just like Arduino and if not, why?

You can program anything without an OS.

Here's an article on writing C targeting bare-metal Raspberry Pi.


You can and people do but it’s important to note that that the raspberry pi CPU is a tiny part of the SOC and the Broadcom proprietary part that bootstraps it is completely closed.

It's been reverse engineered and some minimal firmware for the VideoCore part was made: https://github.com/christinaa/rpi-open-firmware

What exactly is the "Broadcom proprietary part"?

Wouldn't that be the GPU (VideoCore IV/VI)?

It seems that it would. https://en.wikipedia.org/wiki/VideoCore

Sorry, couldn’t read the post because of the GDPR cookies pop up that simulate a looooong time to opt out just to force you to click cancel and accept cookies.

Gave up after a minute. What a shame using those dark patterns (and sad because I wanted to read it)

>The Portenta H7 is capable of running Arduino code, Python and JavaScript, making it accessible to an even broader audience of developers.

"Here, now you can buy hardware that enables you to hire bootcamp-level devs to do your professional industrial work. That way you can pay non-professional wages for professional-level work!"

Stop normalizing putting bloated, heavy languages on embedded platforms.

Arudino isn't great as a platform for industrial work anyways - most industrial applications will spin their own boards or run higher end PLCs that have more rugged designs and protections built in for industrial environments.

Arudino however is great as an experimentation platform, where having access to things like a Python or JS REPL can make experimentation a pleasure, being able to rapidly update and prototype is much easier when you don't have to reflash and reboot every time.

I recently bought a door access control pad, plugged it into an ESP32 and messed with it using MicroPython to better understand how it'd produce outputs. The datasheet it came with was lacking to say the least, but this was a big savior.

Respectfully what you say it's not entirely true. this product family is the response to the emergence of a lot of industrial automation projects that are built on Arduino hardware. Not everyone is building a nuclear plant or an artificial lung but there are plenty of SME companies solving problems with Arduino

> Stop normalizing putting bloated, heavy languages on embedded platforms.

Last time I checked, PICBasic was a thing, and spawned a generation of programmers.

Comodore 64 Basic, and TI-83 Basic were also simplified programming environments. (TI-83 implemented jumps as a O(n) lookup throughout your code... jumping to later functions was more costly than jumping to earlier functions...).

Its the simple programming environments that spawn new generations of programmers. Today, "Basic" is no longer the starting point, today's beginner programmers use Javascript or Python.

But there always were "beginner" languages, no matter how slow computers were in the past.

If the choice of language is because it's beginner-friendly, and the use-case is industrial hardware, then the choice is only being made so the company doesn't have to pay professional-level salaries.

Can the same hardware not be used for both industrial, and beginner-friendly settings?

Some of the biggest successes are because beginner-friendly kits were delivered to universities. Linux and Unix are a great example of this: students taught in Linux / Unix environments (even using "toy" languages like Python) end up growing into professionals who... still use Linux.

One of the most important business moves for a "platform" is to figure out how to get beginner-level students comfortable with your platform. Linux somewhat did this accidentally, but today we need to purposefully create that environment.


Besides, even on the same project... not everyone needs to be an expert embedded engineer. By allowing Javascript onto the platform, you can hire a Web GUI-developer who probably knows a lot more about UI-design than you.

The Web GUI master can work their Javascript into your application, and run code side-by-side with your tightly optimized C code. No, it won't be efficient. But that's what a 480MHz processor is for, to help you run less efficient code at speeds that are acceptable.

This isn't even hypothetical: with WiFi 802.11 n support, this Arduino could very well be running Web-applications served from some centralized location (distributed wirelessly over standard LAMP / HTTP stacks). It will be up to the C System programmers to ensure that a locked-up GUI thread won't wreak the system (or break realtime promises)... but there would be major benefits to distributing applications over standard internet mechanisms.

>Can the same hardware not be used for both industrial, and beginner-friendly settings?

Sorry but, if you have to ask this question, it's pretty clear that you have no idea what many industrial settings require.

There are ruggedness requirements, stability requirements, longevity requirements...

I work in an industry where our products are used for LITERAL decades. There's no way that anything even remotely marketed as "beginner friendly" could begin to work for anything we do.

You can't just throw more hardware at a problem and use that as an excuse for shitty software, come on. This incredibly flawed logic is why the minimum requirements for a chat program include 32GB of RAM.

> I work in an industry where our products are used for LITERAL decades. There's no way that anything even remotely marketed as "beginner friendly" could begin to work for anything we do.

Beginner friendly doesn't mean that the other requirements disappear.

The Arduino can run Javascript. Sure, you don't have to make it use Javascript, but it can be done. Just because Arduino runs Javascript doesn't change its -40C to +85C operating temperature.

Arduino can be BOTH beginner friendly, AND rugged enough to operate at sub-zero temperatures indefinitely. And if you really want to "remove Javascript" from your stack, then you're 100% welcome to do that.

Universities on the other hand, have other requirements. Beginner friendly is absolutely a necessity for students. You have to hook students with something easy if you want the students to be interested in projects. Having a SINGLE platform scale from beginner usage, all the way up to professional usage, is extremely important for the general ecosystem.

And I still argue that opening up Javascript developers onto the platform is a good thing. UI design is complicated, and someone who fully focuses on the user-experience, culture, and presentation is useful. (Even if a GUI designer is ignorant of embedded issues, they can remain helpful in other ways).

JS perf on MCUs is bad. V8 relies on way too many x86 specific assumptions. This is why JS sucks so bad on anything, but top tier ARM socs. On an MCU things will be even worse.

For example, it is impossible to control how V8 converts its internal integers to floats and how. One Math.* method may output a Number which is a float behind the scene, another one int, and another one int double.

GC on MCU is completely unpredictable too. If it fires when you need to poll latency sensitive peripheral, things hang.

>Beginner friendly doesn't mean that the other requirements disappear.

Beginner friendly includes price. If you have the other requirements, it's going to cost much more. Doesn't matter if it's beginner friendly if a development board costs $5k.

The development board literally costs $100 and the STM32H747XI costs $17 from Digikey. Yes, that's with -40°C ~ 85°C operating temperature and a pretty wide operating voltage of 1.62V ~ 3.6V.

The actual device here looks quite rugged, comes with a variety of useful specs. The Arduino Pro IS the beginner friendly development board, the beginner-friendly introduction to STM32.

A "real" product would strip off all the unnecessary parts and only use the $17 STM32H7 chip alone.

the basic model is $49 Qt 1. you can also order boards with just the parts you need (minimum quantity applies) the price comes down a lot of you want

Maaaybe there's different industrial settings other than your own? It's OK if this chip doesn't fit your needs. If it fits no one's needs, it'll fail.

But I suspect there are enough niches it fills it will be successful.

Commodore and TI home computers were self-contained development platforms. Very different from an Arduino, which is basically dependent on getting binary code from some sort of host platform. Since you have to do that uploading step anyway, you might as well program the platform in a modern, compiled language.

Your phrasing is snarky, but you make a reasonable point. Arduino performance is already atrocious with C and it's only going to get worse with a higher-level language.

atrocious ??, maybe on an 8 bit 8mhz device you can go faster if you write optimised assembly code but this is a 240Mhz+480Mhz device it's a different world....

The entire point of using bare-metal MCUs is to achieve efficient, deterministic performance with tight control over timing. All that goes out of the window if you're using a software stack that uses 30 instructions to toggle a digital output pin.

If you're going to use something that's basically a late-90s desktop and develop on the basis that you can afford to burn cycles, you might as well use a proper RTOS and enjoy all the affordances that come with it.

Using more powerful hardware as an excuse to make shitty software is incredibly flawed.

What a bunch of gatekeeping fuddy-duddy nonsense. Give me a break...

If newer hardware makes it cheaper and easier to make cool shit while maintaining the price point and power budgets of previous generations, who gives a shit?

This new stuff makes tinkering with hardware way more accessible than before and that is a good thing for everybody.

We have every right to gatekeep when Arduino are targeting industrial IoT developers. I don't want "tinkerers" designing products that could control industrial equipment or have access to sensitive user data.

Arduino is excellent for what it was originally designed for - an easy, accessible platform for artists and non-engineers to experiment and prototype. Arduino are now reaching well beyond that market and targeting more serious applications, so we are entirely right to question whether a) Arduino's design trade-offs are acceptable in mass-market products and b) whether we really want to lower barriers to entry in this area.

Personally, I think the answers are a) no and b) absolutely not. If you need the hand-holding that Arduino offers, you have absolutely no right to ask a user to plug your widget into their network. Engineers are in a position of trust and we have a moral obligation to treat that position with absolute seriousness.

Some friends of mine are entry-level developers that work alone on an Arduino/C++ codebase. Baremetal development and C++'s bad library support encourages them to write huge amounts of their own, very bad, code. They've taken a year to write the functional equivalent of a few hundred lines of Python and some packages.

Their codebase would improve immensely if they used a more powerful chip to run Linux and Python instead.

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact