Electronics on Carmine Noviello

Upgrading Grove-UART WiFi V2 to latest ESP-AT firmware

Sat, 17 Dec 2022 00:00:00 +0100

The Grove - UART WiFi is a UART transceiver module from Seeed Studio featuring the ubiquitous ESP8266 IoT SoC. With integrated TCP/IP protocol stack, this module lets your micro-controller interact with WiFi networks with a dedicated set of AT commands.

Unfortunately, these modules come from Seeed Studio with a quite outdated version of the ESP-AT command set. The module I bought through DigiKey was delivered with the ESP-AT 1.6 release, that lacks several interesting features available in the more recent versions.

Elegoo Car Kit V4

Fri, 02 Dec 2022 06:23:00 +0000

Elegoo Car Kit v4.0

I have one regret in my life. Robotics. When I was just a child, I spent a great part of my life playing with the Lego Technics. One day an uncle of mine gave me a book, which at the time was also translated into Italian. The book was called *The Robot Builder’s Bonanza. *There were not any microcontrollers for the hobbyists at the time, and it was not simple to put that book in action.

Correct way to perform re-annotation of designators in Altium

Sun, 28 Aug 2016 17:02:53 +0000

It’s really common that at the end of the board layout we have that all component designators are randomly scattered over the board. R1 is somewhere, R2 is hidden in another place, and so on. This happens because often the development of schematics isn’t linear, especially if we are designing some sub-modules before others or if we are reusing some schematics sheets from other and well-tested designs. This is not a critical aspect if the board will be assembled using a pick-and-place (modern pick-and-places are able to process pick-and-place files that contain the exact coordinates of a given component on a board) or if it contains few tens of components. But if you are going to assemble a prototype manually (I’m used to assemble manually even boards with 3-400 components, believe it or not), then having all component designators scattered on the board is a hell. You can spend even minutes looking for the right place of a given component, and often you need to rotate too many times the board, running the risk to throw away already placed components.

Running STM32CubeMX on Mac OS. Finally!

Wed, 09 Sep 2015 06:20:05 +0000

Being a STM32 programmer on Mac OSX, I was frustrated every time I had to launch a virtual machine running Windows only to use the STM32CubeMX tool from ST. For those of you new to this program, it’s a really useful graphical tool that allows to automatically generate setup files for a STM32 MCU according the configuration we need. For example, if we have the Nucleo-F401RE, which is based on the STM32F401RE MCU, and we want to use its user LED (marked as LD2 on the board), than STM32CubeMX will automatically generate all files required to configure the MCU (clock, peripherals port, and so on) and the GPIO connected to LED (port GPIO 5 on port A on Nucleo boards).

How to precisely measure microseconds with STM32

Fri, 04 Sep 2015 09:41:12 +0000

I received this apparently simply question from a reader of this blog: how can I delay a fistful of microseconds in STM32? That is, how to measure microseconds precisely in STM32?

The answer is: there are several ways to do this, but some methods are more accurate and other ones are more versatile among different MCUs and clock configuration.

Let’s consider one member of the STM32F4 family: STM32F401RE, the MCU that equips the STM32Nucleo-F401RE board. This micro is able to run up to 84Mhz using internal RC clock. This means that ever 1µs, the clock cycles 84 times. So, we need a way to count 84 clock cycles to assert that 1µs is elapsed (I’m assuming that you can tolerate the internal RC clock 1% accuracy).

Adding ethernet connectivity to a STM32-Nucleo

Fri, 28 Aug 2015 05:23:37 +0000

One drawback of the Nucleo ecosystem is the lack of a version with ethernet connectivity or a dedicated shield officially supported by ST. There are 90 different STM32 MCUs available that provide an Ethernet MAC interface (this means that only an external ethernet transceiver - also called phyter - and few other things are required to bring your MCU to the IoT world). STM32Cube (the HAL officially supported by ST) also provides support for lwIP stack. But, all the current Nucleo boards are designed with a MCU without an Ethernet interface (I think that the main reason is that only two STM32 MCUs with Ethernet MAC are available in LQFP-64 package and the Nucleo boards are designed to be pin-to-pin compatible between its releases - L0, F1, etc). This means that without a dedicated expansion shield it is impossible to add network connectivity to our Nucleo. And this is a sin considering what that MCU can do.

Getting started with STM32F746G-DISCO

Mon, 13 Jul 2015 05:06:56 +0000

ST Microelectronics recently expanded its portfolio of STM32 microcontrollers with the new STM32F7 family. These are the new best-in-class MCUs from ST, with a Cortex-M7 core able to run up to 216Mhz (future releases will run up to 400Mhz with 2000 CoreMark index), with an internal flash up to 1Mb and 360Kb of RAM. STM32F7 is also able to run from external flash memory without performance penalty, thanks to a L1 cache (this is probably the most interesting aspect of these MCUs). STM32F7 are targeted for High-end embedded applications, especially to multimedia ones, and I think that it’s far from low-budget applications and hobbyist uses. At the time of writing, these MCUs are quite pricy, ranging from 12€ to 20€/pcs for low-volume orders. This is definitely a really high price, especially if you consider that you can find around Cortex-A7 MCUs for less than 10€. But I think that the price will be dramatically reduced in the future.

Running FreeRTOS on a STM32Nucleo using a free GCC/Eclipse toolchain

Mon, 22 Jun 2015 05:50:14 +0000

Using a micro like the STM32F4, able to run up to 160Mhz, with 512Kb of flash and about 100k of RAM, without using an operating system is a nonsense. Although it’s perfectly possible to use some forms of cooperative scheduling to execute firmware activities, basically this not convenient especially when dealing with low level events related to hardware (eg. interrupt handling) and aspects related to synchronization. As long as your firmware starts to grow, you’ll need constructs to synchronize firmware activities, like queues or semaphores. Moreover, especially when dealing with low-power devices, a busy spin (while(some condition);) it’s not the best solution if you have to fight with mAh.

Build STM32 applications with Eclipse, GCC and STM32Cube

Thu, 04 Jun 2015 14:13:18 +0000

If you landed to this page, you probably already know that I’ve covered this topic in the past. I showed in a series made of three posts how to successfully setup a complete Eclipse/GCC ARM tool-chain to develop applications for the STM32Nucleo-F4 developing board. Since then, many people have reported me positive feedback on that tutorial. But, some of them had serious troubles in getting those instructions working for other STM32 families (F0, F1 and so on). This was mainly caused by the GNU ARM Eclipse plug-in, or rather by the included templates in the plug-in. When a new project is created using the plug-in wizard, a template is used depending on processor family. Unfortunately, the plug-in author has updated just the template for STM32-F4 family to the more recently STM32Cube-F4 HAL framework from ST (which still supports only commercial IDE…..), leaving the other templates still based on the old Standard Peripheral Library, which is no longer supported by ST and STM32CubeMX tool used in my tutorial. *This causes my instructions to be wrong for processor families different from STM32-F4. *

BlueNRG shield for STM32 Nucleo

Sun, 08 Mar 2015 15:32:51 +0000

I recently received during a ST training day a sample of the X-NUCLEO-IDB04A1 shield. This shield is based on the BlueNRG network processor from ST and it allows to create Bluetooth Low Energy (BLE) applications using an Arduino compatible developing board. Obviously, ST designed the software for this shield to be used mainly with its Nucleo range of developing boards. In fact, all necessary libraries and examples needed to use this shield are designed to run on Nucleo-L0 and Nucleo-F4 boards using their respective HAL. However, ST still doesn’t provide official support to free GCC/Eclipse toolchains (an this is a pity…), and it’s a little bit tricky to use ST demo files and BlueNRG HAL without using a commercial IDE supported by ST (IAR, TrueSTUDIO, etc).

How to use STM32 Nucleo serial port

Mon, 02 Mar 2015 07:17:28 +0000

As we have seen in the previous tutorial about this new developing board from ST, the STM32 Nucleo provides an integrated ST Link v2.1 interface. ST Link is mainly designed to allow flashing of target MCU trough the mini-USB interface. But, it provides at least another really useful feature: a Virtual COM port. When you install the ST-Link drivers, a new device appears in your hardware devices list: the ST-Link Virtual COM port.

How to protect external door phone from ants and other phatogens

Sun, 25 Jan 2015 08:49:27 +0000

I live in the countryside. But that 2.0 campaign made of insects that eat almost everything, including capacitors and transistors.

Let’s be serious. Unfortunately, the red ants have decided that my external door phone is a great place to nest. I tried several times to tell them that’s not the case. But after two months they come back. And they mess up everything. Every 2-3 years I’ve to change the internal electronics of intercom (I ensure you that the formic acid destroy EVERYTHING). Door phones have become a widely-used consumer good (you can even buy kits at the supermarket..). This means that manufacturers have to save at any costs, and they can’t even apply a little bit of conforming coating to protect electronics. And so, we have to change intercom every 2-3 years. It’s the economy, stupid.

Setting up a GCC/Eclipse toolchain for STM32Nucleo – Part III

Fri, 16 Jan 2015 07:12:39 +0000

Let’s recap what we’ve done in the two previous parts of this series. In the first part we’ve configured Eclipse and GCC to build applications for the ARM-Cortex platform. We’ve used the GNU ARM Eclipse plug-ins to generate a minimal yet working example (a simple blinking LED app) for our STM32 Nucleo board. Next, we’ve used the CubeMX tool from ST to generate the right initialization code for our Nucleo. Lastly, we used ST-Link Utility to upload generated binary code on the target MCU. In the second part we’ve taken a deeper look in the debug topic. We’ve configured OpenOCD and GDB to allow step-by-step execution of our application on the Nucleo target MCU.

Setting up a GCC/Eclipse toolchain for STM32Nucleo – Part II

Wed, 07 Jan 2015 14:13:50 +0000

In the first part of this series we’ve successfully setup a minimal yet working tool-chain to develop applications for the STM32 family (we’ve especially focused on STM32Nucleo developing board). We’ve based the tool-chain over the Eclipse IDE and the GCC cross-compiler for ARM Cortex platform. We’ve also created a test project (a simple blinking LED) and uploaded it on our Nucleo using the ST-Link Utility.

Setting up a GCC/Eclipse toolchain for STM32Nucleo - Part I

Sun, 28 Dec 2014 17:09:33 +0000

I recently got in my hands a new development board from STMicroelectronics: STM32Nucleo. It’s a development board based on the STM32 MCU and it is compatible with the Arduino UNO pinout. This means that it’s possible to use the hundreds of shields available for the Arduino. However this is true in theory, since the most important aspect of Arduino’s world is the software (based on libraries, examples, and so on) made for this popular platform.