Resources for Embedded Development

AVR Boards for Embedded Development  **NEW** Designs for starter kits to learn AVR embedded C programming.

Embedded C Programming Tutorial for novices  **NEW** with coding examples to run on various AVR dev boards

Four-wire Keypad Interface to Micro-controller

Graphics Function Library for Monochrome LCD Module 128x64 pixels, using KS0108, ST7920 or SH1106 controller

Generalised User Interface for Embedded Applications using graphics LCD module and a cluster of push-buttons

Digital Audio (PCM) Sound Effects Software for embedded micro-controller applications (PIC32 target)

PIC32MX Application Framework, including... * USB Host Mass Storage (Flash Drive), * FAT32 File System * Command-Line Interpreter, * Real-Time Kernel (RTCC)

USB Test & Measurement Class device firmware... USBTMC/USB488 Reference Design (AT91SAM7 target)

MIDI-Controlled Sound Synthesizer Module ** Revised ** Real-time high-quality sound synthesis using a PIC32MX or Teensy 3.x microcontroller.

Your comments and enquiries are welcome... send email to:

___

Building your own micro-controller development board will not only improve your workshop skills, but the completed product will serve well as a hardware platform for learning embedded programming skills.

The "AVR-BED" is based on Atmel’s ATmega88PA microcontroller. An ATmega328P (as in Arduino Uno and Nano boards) may be substituted if more memory is needed. The board incorporates a 2-line x 16-character LCD module, 9 LEDs, four push-buttons and a potentiometer providing a 0..5V analogue signal source.

In addition, the AVR-BED incorporates a USB-serial adapter (FTDI FT232RL breakout board) interfaced to the ATmega88 on-chip UART, allowing serial data communication with a host PC. The USB connector (mini-B) provides 5V DC power to the board.

AVR-BED original design (v1)

AVR-BED "Nano" alternative build (v2)

The MCU pin allocations and peripheral interconnection scheme are designed so that all of the on-board resources can operate “concurrently”, assuming appropriate driver software. A peripheral function library is provided to support operation of on-board resources, plus an optional external 4x4 keypad. Pin-headers on the board allow connection of add-on devices and I/O expansion.

All of the parts needed to build an AVR-BED are available at ridiculously low prices from online suppliers.

The download pack contains detailed design and construction notes, a peripheral function library, plus a "test and demo" program. Sample code was developed with AVR GCC under Microchip/Atmel Studio IDE (v7).

Download AVR-BED Distribution Pack (zip)

Embedded C Programming Tutorial for novices

Here is a self-study tutorial intended as a first course in embedded microcontroller programming using a sub-set of the C language called “C-less” (C language essentials). C-less was conceived to provide enough of C to develop “real-world” applications, while avoiding unnecessary complex constructs which novices might find overwhelming.

The software development environment used in this tutorial is Atmel Studio IDE (version 7). This is a free download from Atmel’s (or Microchip’s) website.

Coding examples and exercises are targeted towards Atmel 8-bit AVR microcontroller devices, specifically the ATmega88PA or ATmega328P, as fitted on the author’s “AVR-BED” and “Nano-BED” development platforms. Compatible hardware platforms can be built around Arduino Uno or Atmel ATmega328P "X-mini" boards.

Many of the program examples in this tutorial use a pre-built function library to facilitate access to peripheral devices such as displays, timers, push-buttons, analogue inputs, etc. This approach avoids the need for a detailed understanding of peripheral driver code in the early stages of learning when the focus is on C language syntax. Later in the tutorial, the source code comprising some of the library functions will be analysed for more advanced learning exercises.

The Tutorial has a companion "C-less Reference Manual".

View/Download AVR Embedded C Tutorial

View/Download  C-less Reference Manual

Download Tutorial Example Programs

___

Four-wire Keypad Interface to Micro-controller

This article describes a technique to connect a 16-button (4 x 4) keypad or larger size keyboard to a micro-controller using only four wires.  more...

Download Software (zip)

Graphics Function "Library" for Monochrome LCD and OLED Modules

This software package is designed for monochrome (1 bit-per-pixel) graphics LCD modules with a display format of 128 x 64 pixels. The package includes device drivers for GLCD modules based on the KS0107/KS0108 controller chipset or ST7920 chip. Also included is driver code for the SH1106 OLED display controller. 

Suitable GLCD and OLED modules are sold by Adafruit and Sparkfun. Compatible modules may be available at lower cost via eBay, AliExpress, etc.

NB: The package is not a hack of the Arduino "GLDC" library! My software was developed from scratch to be simpler, easier to read, more efficient and to optimise write speeds for text and bitmap image rendering. 

The drivers were designed for Microchip PIC devices, but hardware dependencies are confined to the low-level driver files so as to make the code easily portable to other MCU device types, e.g. Teensy 3.x.

Functions provided in the LCD Graphics library:

void LCD_Init(void); // LCD controller initialisation
void LCD_ClearScreen(void); // Clear LCD GDRAM and MCU RAM buffers
void LCD_Mode(uint8 mode); // Set pixel write mode (set, clear, invert)

void LCD_PosXY(uint16 x, uint16 y); // Set graphics cursor position to (x, y)
uint16 LCD_GetX(void); // Get cursor pos x-coord
uint16 LCD_GetY(void); // Get cursor pos y-coord

void LCD_BlockFill(uint16 w, uint16 h); // Fill area, w x h pixels, at cursor (x, y)
uint8 LCD_PutImage(uint8 *image, uint16 w, uint16 h); // Show bitmap image at (x, y)
uint16 *LCD_ScreenCapture(); // Return a pointer to the screen buffer

void LCD_SetFont(uint8 font_ID); // Set font for char or text display
void LCD_PutChar(uint8 uc); // Show ASCII char at (x, y)
void LCD_PutText(uint8 *str); // Show text string at (x, y)

// These macros draw solid rectangular objects at the current cursor position (x, y)
#define LCD_PutPixel() LCD_BlockFill(1, 1)
#define LCD_DrawBar(w, h) LCD_BlockFill(w, h)
#define LCD_DrawLineHoriz(len) LCD_BlockFill(len, 1)
#define LCD_DrawLineVert(len) LCD_BlockFill(1, len)

Character font sizes available: 8, 12, 16 and 24 pixels (char cell height, incl. descenders).
Some fonts are mono-spaced, others proportional; some fonts support bold weight.

The software package includes support for Microchip's "Graphics Resource Converter" (GRC) utility.
Bitmap image definitions generated by the GRC can be transformed into a bitmap format suitable for display using the library function LCD_PutImage().

The GitHub repository (link below) includes a test/demo application with all project files required for development using Microchip MPLAB.X IDE.

There is another package specifically for 1.3" OLED display applications using the Arduino IDE.

Go to GitHub repository for LCD/OLED Graphics Library

___

This article is concerned with firmware design and implementation for microcontroller-based devices incorporating a "local" user interface (front panel) comprising an LCD screen and keypad (or a number of push-buttons). The technique can be extended to build a graphical user interface (GUI) comprising an LCD screen with touch-panel.

Typical applications will have many "screens" to be presented and, for each screen, a selection of user options for various actions, most of which will result in a switch to a different screen or a change in displayed information on the current screen. For all but the most trivial of applications, navigation from one screen to the next presents a challenge to the developer and can easily become a convoluted mess if not handled methodically...

Download article (pdf)

Digital Audio (PCM) Sound Effects Software

Appealing sound effects are generally too complex to be generated in real time by the target micro-controller of an embedded system. Therefore, sound effects may be synthesized by a purpose-built application and stored as a sequence of PCM samples in a data file. Saved sound effects can be loaded into flash memory in the target embedded system for fast access by an audio player function. The storage medium is typically a "serial data flash" (SDF) memory device interfaced to the MCU via SPI. However, the micro-controller’s internal flash program memory can also hold sound FX data.

PCM sound effects data files can also be produced from standard audio file formats such as WAV, MP3, etc, using "Audacity" -- a free open-source audio editor application. There is a plethora of sound effects available for download on the internet. Audacity can also be used to record sounds using a microphone, CD player, sound synthesizer or musical instrument, etc. Once loaded into Audacity, audio data can be re-sampled at the required sample rate and then exported in “RAW” data format (stripped of header information) compatible with the target embedded player.

The software described in this article comprises a simple sound FX synthesizer application, an audio player function and various utilities to transfer sound FX data files between the SDF memory device and a removable mass-storage device, e.g. a USB flash drive. The software was originally developed for Microchip’s PIC32MX (32-bit) micro-controller family, but could be easily customized to suit others... more...

The Digital Audio software is included in the PIC32MX "Application Framework" package (below).

PIC32MX Application Framework

The "PIC32MX Application Framework" is a suite of example applications comprising a command-line user interface (CLI), USB mass storage (Flash Drive) support, FAT32 file system with file management commands, real-time kernel with task scheduler, hardware RTCC support, digital audio (PCM sound effects), serial data flash memory support (SST25VF016), I2C EEPROM (24LCxx) and more.

The package includes device drivers for on-chip peripherals, e.g. UARTs (interrupt or polled Rx data, queued Tx data), I2C, SPI, timers, OCx (PWM), etc, plus drivers for external devices, e.g. I2C EEPROM (24LCxx), serial data flash (SST25VF016), LCD modules (ST7920, KS0108), wireless comm's module (MRF24J40MA), etc.

The example applications provide a reliable framework upon which to develop different applications. Include the code modules you need in your project; remove those not required. It is highly recommended to use the project directory structure noted in the download package, although project folders may be re-named without upsetting MPLAB'X.

The hardware platform I chose for development is a low-cost "PIC32-MX460" development board from Olimex (www.olimex.com). The MCU is a PIC32MX460F512L clocked at 80MHz. The board has a prototyping area which I used to fit connectors for I/O expansion, a numeric keypad and graphics LCD module, as shown in the picture below. I shortened the board so it would fit in my chosen enclosure. I added an ICSP header (6-pin SIL, right-angle, 0.1" pitch) accessible through a cut-out in the enclosure, for more convenient connection of a programming/debugging tool (PICkit-3, etc). The tiny (useless) LCD screen was removed and a battery-backed I2C real-time clock module (MCP79410, Microchip part # AC164140) fitted in the space left vacant. The space provided for an optional RF comm's module was used instead for adding a 2MB SPI flash memory chip (SST25VF016), which I used to store PCM audio sound clips.

The download package includes all project files required for development using Microchip MPLAB'X IDE. 

Download PIC32MX Application Framework (zip)

All dependencies on Microchip's legacy peripheral library (PLIB) have been removed from the framework code, except for modules extracted from Microchip's Library of Applications (MLA), i.e. the USB host mass-storage stack and the MDD File System. Apart from those modules, MPLAB XC32 compiler version 1.34 and later may be used without problem. If your project needs a Microchip MLA module, you can use XC32 v1.33, or you can try to remove the PLIB dependencies by importing code from the relevant PLIB source file(s). Good luck!

USBTMC/USB488 Device Firmware Stack and Reference Design

USBTMC/488 is just one of many interface options when designing a control system or test and measurement setup using a mix of virtual and real instruments with interoperability. First there was GPIB/HPIB which was superseded by serial busses (mostly based on EIA485), then USB and Ethernet. More recently, Ethernet has become the preferred option for inter-instrument communication. All of these options remain in use, however.

If you choose USB to implement your instrument interface, consider a design with a VISA-compliant USB-TMC/488 interface using the IEEE488.2 command/response message syntax, to get the following benefits:

• Avoid the need to develop and maintain USB device driver software for the host computer
• Choice of host computer development environments for your instrument application software...
  e.g. NI LabVIEW, Microsoft Visual Studio (VB, C/C++), etc
• Use an existing standard API function library (VISA) -- freely available from NI or Agilent
• USBTMC/USB488 Reference Design, with source code, available here...

Initial target platform was Atmel AT91SAM7-xxx (ARM7) with on-chip USB peripheral. The example "application layer" and USBTMC "class layers" (source modules) have been designed to be independent of hardware platform, so the code can be more easily ported to other platforms, e.g. SAMD21. The source code and supporting annotation is of professional quality.

More than 15 years has elapsed since the USBTMC project was begun, so the reference design is now freely available to use without any licence fee. To obtain a copy of the package, send an email request to the author (address below). Please include your country, city, organisation web address (if applicable) and the hardware platform you plan to use. This information will be kept private.

Click here for more info on the USBTMC Reference Design

Disclaimer: Source code and other "intellectual property" offered as free downloads on this website are original works of M. J. Bauer, except where acknowledged to the contrary. Otherwise, any resemblance to prior art originated or developed by others is purely coincidental, or due to derivation from similar works or well-established art in the public domain. The author does not accept liability for any adverse consequence of the use of "intellectual property" obtained from this website or respective GitHub repository.