Getting started with microcontrollers

[brucehoult]

Having the memory handling done for you might be easier

You can easily have this is C too.

Simply:

- apt install libgc-dev   (or the equivalent on your OS)

- in your program #include <gc.h> and call GC_malloc() instead of malloc()

- add -lgc to your gcc/linker options

That's it!

You can also build it to simply replace the standard malloc() and make free() a NOP.

The Boehm GC for C has been developed and used and battle-tested on almost every kind of computer for over 35 years since 1988. It has been used in many big programs such as Inkscape, GNU Java, and Guile, Mono. Probably tons more that don't advertise it.

I use it in basically all of my personal C/C++ programs.

In 2006 I ported it to Qualcomm's BREW mobile phone OS, for use in the AlcheMo Java compiler (on ARM7TDMI chips).

It's not appropriate for chips such as the AVR with 2K of RAM, but it's fine on anything that can run CircuitPython/MicroPython!

I don't know why more people don't know about and use it.

[radiolistener]

Still too much boilerplate needed in rust (unwrap, unsafe to name a few), and secret handshakes with the hardware the novice would not know what are they and where is it coming from (apb2enr, set bit, etc.)

yes, python looks more simple and short, but it produce slow and unsafe code. This is not a good choice for microcontrollers.
The gem of Rust is that it produce fast and safe code and don't allows to use things which leads to undefined behavior.

If Rust looks complicated, it's better to choice C language.
Microcontrollers have too small amount of memory and lack of processing speed, so using slow and bloat language is definitely not a smart choice...

[Picuino]

The advantage of C is that it is the most widely accepted language with the most compilers for microcontrollers.
Rust does not have the acceptance of C for now.

[radiolistener]

Rust is a natural choice for creating programs for microcontrollers, mobile devices and PC.

By the way, Rust is now supported for linux kernel development, you can use it instead of C now.

With 6.1, however, there is something fundamentally different. For the first time in Linux's history, in addition to C, you'll be able to use another language, Rust, for kernel development.

Why? As Wedson Almeida Filho of Google's Android Team said, "We feel that Rust is now ready to join C as a practical language for implementing the kernel. It can help us reduce the number of potential bugs and security vulnerabilities in privileged code while playing nicely with the core kernel and preserving its performance characteristics."

Specifically, as Alex Gaynor and Geoffrey Thomas explained at the 2019 Linux Security Summit, almost two-thirds of Linux kernel security holes [PDF] come from memory safety issues. And where do they originate? Inherent weaknesses in C and C++. Rust, on the other hand, dodges these issues by using far safer application programming interfaces (APIs). Rust is simply safer than C.

Recently, the US National Security Agency (NSA), which is in charge of securing code as well as breaking it, suggested that one of the best things you can do for your program's security is to use memory-safe languages such as Rust instead of C.

Rust is a modern replacement for old C. So, there is a sense to start your new projects in Rust.

[Rick Law]

Recall the OP's question is "Getting started with microcontrollers."

Given the ecosystem Arduino has, information and example are readily available - possibly exceeding competing ecosystems by many folds.  That made the Arduino ecosystem a prime choice for "getting started".

Once one got started, one can always switch to more feature filled, stronger, or more powerful systems.  For the getting started phase, the easiest and simplest (in getting going and in getting additional info/help) is probably the most suitable.

[tooki]

Here is nice startup code for novice. This is a code example for LED blinking.
It is written in Rust language for STM32 bluepill arduino board.

Code: [Select]

// std and main are not available for bare metal software
#![no_std]
#![no_main]

extern crate stm32f1;
extern crate panic_halt;
extern crate cortex_m_rt;

use cortex_m_rt::entry;
use stm32f1::stm32f103;

// use `main` as the entry point of this application
#[entry]
fn main() -> ! {
    // get handles to the hardware
    let peripherals = stm32f103::Peripherals::take().unwrap();
    let gpioc = &peripherals.GPIOC;
    let rcc = &peripherals.RCC;

    // enable the GPIO clock for IO port C
    rcc.apb2enr.write(|w| w.iopcen().set_bit());
    gpioc.crh.write(|w| unsafe{
        w.mode13().bits(0b11);
        w.cnf13().bits(0b00)
    });

    loop{
        gpioc.bsrr.write(|w| w.bs13().set_bit());
        cortex_m::asm::delay(2000000);
        gpioc.brr.write(|w| w.br13().set_bit());
        cortex_m::asm::delay(2000000);
    }
}

You can find more details on how to compile it and upload into microcontroller here:
https://jonathanklimt.de/electronics/programming/embedded-rust/rust-STM32F103-blink/

As you can see, it is very easy, you can play with it and extend its functionality. That way you can learn programming for microcontrollers.

”Very easy” my ass. Even passively understanding what that code does requires preexisting knowledge that a beginner will not possess. Heck, I’m not a beginner and I have no clue what most of that code does!

I see that reply as the kind of didactic disconnect so many naturally gifted programmers have: it’s in no way useful to a learner. It’s not simple, and merely declaring it is doesn’t make it so! 

[pcprogrammer]

It feels a bit like everybody needs to show how knowledgeable they are by bringing far to complex stuff to the table for a beginner.

Like Rick Law wrote this is about getting started with microcontrollers and for that Arduino based on the ATmega328 is the simplest one can get.

Forget faster or dual core or wifi connectivity or what ever programming language out there and just follow your already chosen path with the UNO. In time and when you feel like it, it is always an option to step up to something faster or more complex with a more "mature" IDE if needed.

[tooki]

It feels a bit like everybody needs to show how knowledgeable they are by bringing far to complex stuff to the table for a beginner.

Like Rick Law wrote this is about getting started with microcontrollers and for that Arduino based on the ATmega328 is the simplest one can get.

Forget faster or dual core or wifi connectivity or what ever programming language out there and just follow your already chosen path with the UNO. In time and when you feel like it, it is always an option to step up to something faster or more complex with a more "mature" IDE if needed.

Hear, hear!

[soldar]

Recall the OP's question is "Getting started with microcontrollers."

Given the ecosystem Arduino has, information and example are readily available - possibly exceeding competing ecosystems by many folds.  That made the Arduino ecosystem a prime choice for "getting started".

Once one got started, one can always switch to more feature filled, stronger, or more powerful systems.  For the getting started phase, the easiest and simplest (in getting going and in getting additional info/help) is probably the most suitable.

It feels a bit like everybody needs to show how knowledgeable they are by bringing far to complex stuff to the table for a beginner.

Like Rick Law wrote this is about getting started with microcontrollers and for that Arduino based on the ATmega328 is the simplest one can get.

Forget faster or dual core or wifi connectivity or what ever programming language out there and just follow your already chosen path with the UNO. In time and when you feel like it, it is always an option to step up to something faster or more complex with a more "mature" IDE if needed.

Yeah. It feels like some posts are more trying to scare me away. I am trying to not pay attention to them or i will just give up.

I have ordered the Arduino Uno R3 and when i get it I will get started with IDE 2.3.2 and ask questions from there. Often too many choices is a bad thing. 

[Rick Law]

...
I have ordered the Arduino Uno R3 and when i get it I will get started with IDE 2.3.2 and ask questions from there. Often too many choices is a bad thing. 

Good idea... That is simple.  I can give you a step-by-step, but I suspect you may just want to figure it out yourself.

Oh, this silly Arduino thing is not educational, so no sense wasting time "discovering" wading through the confusion.  Arduino call program source code a "sketch"...

[MarkF]

I have ordered the Arduino Uno R3 and when i get it I will get started with IDE 2.3.2 and ask questions from there. Often too many choices is a bad thing.

You can open the examples from the IDE file menu and compile them without any hardware.
It will give you a jump on learning your way around the IDE and you can see how the example code
is laid out.  You can also start learning C and the Arduino calls to read and write to the I/O ports.

Then when your hardware comes, you just plug it in and download the programs you've been learning.

Don't let the fanboys and their favorite programming language of the month scare you off.
C/C++ is still the most used language in industry (except for financial institutions) and they are slow to change.
I my 40 years of software development we used Assembly, Fortran, a brief year of Ada, and then C/C++.
Python seems to have a niche in the academic scene.

And there are about as many ways to write and document your code as there are programmers.
Unless you're working in a large group.  My largest group of programmers contained 14 people and we had
very strict guidelines to follow for number of lines of code per module, documentation, design reviews, etc.
Even down to variable names we were forbidden to use.  I see no reason for any of it to be brought up or
discussed here when someone is just learning a new language and MCUs.

[radiolistener]

Heck, I’m not a beginner and I have no clue what most of that code does!

Are you kidding? Common dude, the code is pretty clean.
It may scary for you just because it uses some new syntax which is not familiar for you, but that can be learned within several hours.

Just look, the structure is very transparent:

First we declare which libraries and featrues we will use:

Code: [Select]

// std and main are not available for bare metal software
#![no_std]
#![no_main]

extern crate stm32f1;
extern crate panic_halt;
extern crate cortex_m_rt;

use cortex_m_rt::entry;
use stm32f1::stm32f103;
Then we have main code:

Code: [Select]

#[entry]
fn main() -> ! {
...
}

which consists of two parts, first part is initialization:

Code: [Select]

    // get handles to the hardware
    let peripherals = stm32f103::Peripherals::take().unwrap();
    let gpioc = &peripherals.GPIOC;
    let rcc = &peripherals.RCC;

    // enable the GPIO clock for IO port C
    rcc.apb2enr.write(|w| w.iopcen().set_bit());
    gpioc.crh.write(|w| unsafe{
        w.mode13().bits(0b11);
        w.cnf13().bits(0b00)
    });
and the second part is main loop:

Code: [Select]

loop{
        gpioc.bsrr.write(|w| w.bs13().set_bit());
        cortex_m::asm::delay(2000000);
        gpioc.brr.write(|w| w.br13().set_bit());
        cortex_m::asm::delay(2000000);
    }

There is even no need to know Rust to read the code and say what it does, it self explaining...

The only thing which may be not obvious are these manipulations for GPIO port configuration. But this is not Rust specific thing, this is MCU specific details, which will be the same for any language. You're needs to read MCU datasheet in order to learn it.

[pcprogrammer]

Are you kidding? Common dude, the code is pretty clean.

Sure I can read it but it looks cluttered with all the objects needed to do  a simple thing. A bit like java with all the dot extensions to call a simple thing.

Like "cortex_m::asm::delay(2000000);" when in C with your own function "delay(2000000);" is enough. But here you need to select the top class, sub class and then the function you want to use.

And "safe" is just a word. Nothing is really safe. Mistakes are easily made even for experienced programmers and the "safe" flies out of the window.

Further more here we are most likely advising someone who has retired and wants to play with microcontrollers. Don't think "safe" code is high on his priority list.

[brucehoult]

Are you kidding? Common dude, the code is pretty clean.

Sure I can read it but it looks cluttered with all the objects needed to do  a simple thing. A bit like java with all the dot extensions to call a simple thing.

Like "cortex_m::asm::delay(2000000);" when in C with your own function "delay(2000000);" is enough. But here you need to select the top class, sub class and then the function you want to use.

It's crazy!  Will this code work on a board with an AVR, PIC, MIPS, RISC-V, ESP32 with XTensa?

I think no, it's got to be rewritten.

The Arduino code works on EVERYTHING, without any modification.

How many lines of code have to be changed if you want to toggle something other than pin 13?  I see four. It should be one. On Arduino you don't even have to know which pin the built in LED is actually on -- there'a a macro for that.

And "safe" is just a word. Nothing is really safe. Mistakes are easily made even for experienced programmers and the "safe" flies out of the window.

Completely agree.

In the 80s I was a big fan of bondage and discipline languages such as Ada, Pascal, and here we have Rust. I'm not now.

Sure, they make it harder to make certain kinds of coding errors. But they totally fail to address the other 90%, 98%, whatever it is. Not to mention specification errors, architectural design errors, algorithm errors.

Or even something as simple as writing..

Code: [Select]

loop{
    gpioc.bsrr.write(|w| w.bs13().set_bit());
    cortex_m::asm::delay(2000000);
    gpioc.bsrr.write(|w| w.bs13().set_bit());
    cortex_m::asm::delay(2000000);
}

I'm completely converted from bondage and discipline languages as the panacea to Test Driven Incremental Development. Write a little bit, test a little bit, write a little bit more. Keep lots of tests around to detect regressions.

Once you're doing that, even a typeless language can be used reliably, though I definitely prefer a language where you can write user-defined problem domain types on things such as function arguments and class members and critical local variables, firstly as DOCUMENTATION for the human, but the compiler also checks them if you supply them. And infers the types of everything else as much as possible.

[paulca]

what is better readable? 

Hey, give em a break.  They (MCU coders) are doing absolutely fine learning the 1980s.  Let's not have TOO high expectations, eh?

[soldar]

If I may interrupt for a moment....

I see ELEGOO UNO R3 Board ATmega328P with USB Cable(Arduino-Compatible) for Arduino which looks exactly the same and is $10 cheaper. Is it a clone that I can use exactly the same? Can I get this Elegoo board and use it just the same?

https://www.amazon.com/ELEGOO-Board-ATmega328P-ATMEGA16U2-Compliant/dp/B01EWOE0UU/ref=sr_1_2_sspa

[pcprogrammer]

Yep it is much the same. The main processor is the ATmega328P and that is what is needed.

The bonus on this one is the 16U2 MCU they use for the communication with the PC. So yes you can save yourself some money.

[soldar]

Yep it is much the same. The main processor is the ATmega328P and that is what is needed.

The bonus on this one is the 16U2 MCU they use for the communication with the PC. So yes you can save yourself some money.

Thanks. From some of the posts I had understood that the Arduino includes some kind of boot firmware or something like that which makes it work with the IDE on the computer and I want to make sure this will also work. If it works exactly the same then I will get it but if I need to tinker with it before I even get started then I would rather pay $10 more and save myself the trouble.

[pcprogrammer]

It states 100% compatibility. 

Even 2 dollar nano's bought on Aliexpress have the bootloader. Not sure if you can still get them for 2 dollar though. Have not looked at AVR (ATmega and ATtiny) boards for quite some time.

[Aldo22]

@soldar: Maybe a starter kit wouldn't be bad for the absolute beginning. There's a lot of cheap stuff to get you started playing.

e.g. (not tested)
https://www.aliexpress.com/item/1005006060347174.html

[Rick Law]

It states 100% compatibility. 

Even 2 dollar nano's bought on Aliexpress have the bootloader. Not sure if you can still get them for 2 dollar though. Have not looked at AVR (ATmega and ATtiny) boards for quite some time.

I tend to agree that likely you will not have compatibility issues.  In over a dozen rounds of UNO/NANO purchases, I've yet to come across one with boot-loader that has compatibility problem.  You do need to set your IDE to the right board (Arduino UNO), the right CPU (ATMega328), and perhaps the right COM port -- I think COM may be auto detect.  Not sure if you would need driver for the UNO's serial port as well.

I did get a pack that didn't have the boot-loader, just once shopping based of CPA (Cheapest Price Available) but just once.  With NANO, the more likely problem you may run into are the ATMega318's.  The ATMega318 is the little brother of ATMega328.  Price has come down so much that the 318 NANOs is rare, but I suppose the chip-shortage might have brought it back to life.  Buying on-line from a store an ocean away is like life, and life is like a box of chocolates -- you never know what you'll get...

Once you get past that (connect/compile/download), you may think "why would I waste money on a kit" when I can buy the components a lot cheaper.  Depending on what you try, you will gather up your own collection of components.  You know, a bread-board, some LED's, some ballast resistors, some more coffee, or whatever.  The difficulty is not just in getting the hardware, the difficulty may be getting the associated software (that really works) -- such as the software for an SD card reader module, or running a specific LED display.

[MarkF]

Yep it is much the same. The main processor is the ATmega328P and that is what is needed.

The bonus on this one is the 16U2 MCU they use for the communication with the PC. So yes you can save yourself some money.

Thanks. From some of the posts I had understood that the Arduino includes some kind of boot firmware or something like that which makes it work with the IDE on the computer and I want to make sure this will also work. If it works exactly the same then I will get it but if I need to tinker with it before I even get started then I would rather pay $10 more and save myself the trouble.

What you're looking for is clearly stated in the middle of the Amazon page.



The bootloader is a small piece of code in any MCU that allows you to download your program without the need for additional hardware (for example a PICKIT 3 for downloading programs into Microchip PIC microcontroller).

[pcprogrammer]

But in case something goes wrong and you need to reload a bootloader it is also not that hard.

An USBASP can be used to load a new one. (Search for USBASP programmer) Or a spare nano or UNO can be programmed to act as one and be used to do the same thing.



This video tells how to do it, or this instructable takes you through the steps. And of course Arduino itself also comes to the rescue.

[zilp]

Thanks. From some of the posts I had understood that the Arduino includes some kind of boot firmware or something like that which makes it work with the IDE on the computer and I want to make sure this will also work. If it works exactly the same then I will get it but if I need to tinker with it before I even get started then I would rather pay $10 more and save myself the trouble.

As others have already said, you will almost certainly get one with the bootloader installed, especially so given that the article description seems to say so, and also, just in general, clones are fine. After all, they aren't complicated, they are mostly the MCU with a crystal and a USB/serial bridge in a standardized form factor.

But also, even if the bootloader were missing, that's really not a hard thing to fix, especially with an electronics background. avrdude not only supports the bootloader protocol, but also various bit-banging adapters for the "native" AVR programming scheme, so, if you have some PC/laptop with a serial or parallel port, it's just a matter of wiring up a few pins and writing the bootloader to the chip that way.

Really, I think you are over-thinking this. Just buy one. Most likely, things will just work ... and in the unlikely case that something doesn't work, it won't be that hard to fix, especially with the help of this forum, and you would even learn something along the way. It's not like you will spend a month tinkering to get things working. Even in the worst case, you absolutely for certain will get this running in an afternoon at most, and most likely in minutes.

[tooki]

Heck, I’m not a beginner and I have no clue what most of that code does!

Are you kidding? Common dude, the code is pretty clean.
It may scary for you just because it uses some new syntax which is not familiar for you, but that can be learned within several hours.

Just look, the structure is very transparent:

…

There is even no need to know Rust to read the code and say what it does, it self explaining...

The only thing which may be not obvious are these manipulations for GPIO port configuration. But this is not Rust specific thing, this is MCU specific details, which will be the same for any language. You're needs to read MCU datasheet in order to learn it.

I didn’t say it was “scary”. I just said I don’t know what it means. As I said: I am not a naturally gifted programmer. What seems obvious to you may not be obvious to me, and just declaring that it’s obvious doesn’t actually make it so.

No, the code is not transparent or self-explanatory. Heck, it’s not even transparent or self-explanatory even with the knowledge of what the code does! The only reason it is transparent and self-explanatory to you is because you are already very familiar with the language and the MCU. As I said before: complete didactic disconnect.


The fact that programming that requires knowing the MCU intimately is precisely why Arduino is successful for hobbyists and beginners and everything else is not: Arduino does not demand that you familiarize yourself with the MCU intimately before you can get anything done. You clearly don’t see or understand the value of getting a beginner going with a low barrier to entry. Early successes are encouraging, and make the learner experience that they can get it to do something.

Arduino’s C/C++ code, especially the basics, are truly self-explanatory, and that also helps the learner learn both the syntax and the functions.