Where I describe the function - analogWrite().

Introduction#

While analogWrite can be an easy function to use, its not easy to initially understand. This stems from a couple of reasons, first, its mis-named in that the function is not doing anything from an analog perspective and second, it uses a concept called pulse-width modulation (PWM), which in itself is difficult to understand.

Pulse Width Modulation (PWM)#

Lets start with explaining pulse-width modulation. Here is a video where a pulse is being modulated:

Where I describe how to use the Library functions in AVR_C.

Introduction#

This page describes where to find specific functions for programming an AVR microcontroller in Standard C using functions similar to the Arduino Language Reference. In this case, the AVR_C framework consists of:

1. The Standard C Library also known as avr-libc
2. The AVR_C Library, a GitHub repository developed to mirror the functionality of the Arduino Language

Standard C Library#

The Standard C Library is provided by AVR Libc. This library is incredibly important as it provides the ability to develop code in Standard C for the AVR family of microcontrollers. It has all of the functionality you would expect if your were using the a Standard C book such as The C Programming Language Kernighan and Ritchie (available in PDF and paper copy). I recommend having a link to the online manual open while developing code.

Where I attempt to direct all of the questions, pertaining to Developing in C for the Arduino Uno.

How do I find my Serial port?#

A: There is more than one way!

CLI methods

# identify using device
ls /dev/tty* | grep -E 'ACM|USB'

# identify using tio
tio -l

# if you have multiple devices, using tio will provide more information

GUI methods

1. Open the Arduino IDE and go to Tools -> Port and write down the port which has (Arduino Uno) after it. If you aren’t using an Uno, it might not identify itself. Which means you might have to guess, or unplug your board and see which one goes away.
2. Open CoolTerm, it will provide a drop-down of devices which can be connected to by, CoolTerm.

Why is learning C important for the Arduino Uno?#

A: C is the ideal combination of a common language and a language which is “close” to the hardware. For example, the AVR assembly language allows writing directly to the hardware (the best example of “close”), except it is not commonly known or easily understood. On the other hand, Python is widely known and easily understood, however, due to it’s requirement to be compiled on-board, it is too large to fit into the memory of the ATmega328P (the microcontroller used by the Arduino Uno). The Arduino approach is to use C++, however, C++ is a little more abstract and requires more memory than C. It’s a good compromise for teaching, however, it is not the best language for embedded development.

Where I describe the process of developing code for the Arduino Uno(AVR ATmega328P), specifically, the build process.

Introduction (from Edit)#

The middle three steps compile/link/locate are typically called the build process, which can simplify the five steps to three:

1. Edit
2. Build
3. Upload

For a detailed and very worthwhile description of the three steps in Build, I highly recommend this page, Compiling, Link and Locating: Barr Group.

2. Build (compile/link/locate)#

The image is a typical start-up build sequence, I need to cd three times, to get into the specific folder. Once there, I use make clean to ensure I have a clean start (source code and makefile only) then I execute a make flash.

Where I describe the process of developing code for the Arduino Uno(AVR ATmega328P), specifically, editing the code.

Keyboard Commands Cheatsheet (in all applications)#

VS Code Keyboard Commands Cheatsheet#

Terminal Commands Cheatsheet#

Setup Raspberry Pi Development Screen#

This is a a very simple configuration. The left-half of your window is VS Code and the right half of your window is your CLI (terminal application.) Use tabs on both to view multiple files or instances.

Where I describe the process of developing code for the Arduino Uno(AVR ATmega328P), specifically, uploading code to the Uno.

Introduction (from Edit)#

The middle three steps compile/link/locate are typically called the build process, which can simplify the five steps to three:

1. Edit
2. Build
3. Upload

Upload#

Determine the port#

The most important step in uploading to the Uno is to ensure your env.make file is using the correct serial port. The easiest method for this is to plug-in your Uno and use the Arduino IDE and Tools -> Port to identify the port used by the Uno. Here is a screenshot of this process on the Mac:

Where I discuss how to implement and use git to develop code in C for the Arduino Uno.

Sources#

• Beginner’s Guide to Git and GitHub

Introduction#

In this post, I’ll describe how to use git to add the Lab content. I’ll also offer some guidance as to how to use git in your own projects. I am not a git expert and I’ll try not to stray too far from status->add->commit-push…

Where I describe a new error caused by a bug in GCC 12 as it relates to the AVR microcontrollers.

Sources:#

• GCC Bug report
• Another bread crumb

Description#

While debugging a setup script, I ran across this error on my Linux system, however, it didn’t show up on my macOS or Windows computers.

$ make flash
avr-gcc -Os -mcall-prologues -g3 -std=gnu99 -Wall -Werror -Wundef -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums  -ffunction-sections -fdata-sections  -DF_CPU=16000000UL   -DBAUD=9600UL -DSOFT_RESET=0 -I.  -I../../Library -mmcu=atmega328p -c -o main.o main.c
main.c: In function 'main':
main.c:33:9: error: array subscript 0 is outside array bounds of 'volatile uint8_t[0]' {aka 'volatile unsigned char[]'} [-Werror=array-bounds]
   33 |   PORTB &= ~_BV(PORTB5);
      |         ^~
cc1: all warnings being treated as errors
make: *** [<builtin>: main.o] Error 1
$

It does seem rather odd as 0 is certainly not “outside array bounds”, therefor I had no idea as to how to remediate it.

Where I demonstrate how to use make and makefiles to automate your build process.

Update#

While this entry accurately describes how to use a Makefile, the approach has changed significantly. See Developing in C for the ATmega328P: Make, Makefile and env.make for the latest information.

Automate using a Makefile#

We’ll use the Makefile from Elliot William’s book, he has in the folder setupProject. This Makefile is comprehensive and delivers an Arduino IDE type of simplicity with significantly increased speed. I’ve made some changes to it to make it easier to switch between different types of systems. Here is the file:

Where I compare the execution speeds of different combinations of boards and languages. I will continue to update this post with other languages and processor combinations.

Table for the impatient#

Introduction#

While writing about CircuitPython and the FIDI board, I was curious as to the execution speed of CircuitPython on a extremely powerful (relative to the AVR ATmega328) ARM M0+ microcontroller. The M0+ is a modern RISC 32-bit processor with a considerable amount of memory, while the ATmega is 20 year old RISC 8-bit processor with a limited amount of memory. That said, one can’t run CircuitPython on ATmega processors, one must use C or Forth.