Programming Languages

From OpenCircuits
Revision as of 17:13, 12 April 2025 by DavidCary (talk | contribs) (link to yet another microcontroller C compiler)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search

Introduction

Perhaps the title should be for Programming Languages for Microcontrollers, in any case that is what the content is now and probably should stay.

Very high level languages are less suitable for microcontrollers, so the choices are less than one would find on a PC. The main programming languages used in microcontrollers are Basic, C, and assembly. Microcontrollers are generally harder to program than PCs because it isn't as easy to view debugging output, it takes more time to flash a new firmware, and the tools are generally less developed than PC tools. One suggestion is to learn basic programming on a PC first and then migrate to embedded systems after gaining some understanding. One hint on selecting a language is to always consider using the same language as the people you work ( play ) with do. This makes getting help much easier. Or pick a language with a strong support system on the internet. Of course the language cost and features matter too.

Basic

Some people consider Basic to be the easiest programming language to learn. The language is line oriented so compilers tend to produce more debuggable error messages.

Basic encourages incrementally developing and testing software, an interactive technique that supports rapid application development.


Basic can either be interpreted as in the Basic Stamp from Parallax or compiled as in PicBasic. Generally speaking the interpreted basics run slower than the compiled basics. In some cases the basic firmware is part of the chip, this can boost the cost of the chip significantly. Still this type of solution can get a beginner up and running quickly.

A Basic Stamp module from Parallax can get a beginner up and running quickly.

Traditionally basic has not required declaration of all variables and may not be strict about typing of variables, these can be a plus for beginners, by may be disliked by more experienced programmers. Not all Basics have these characteristics and some have optional settings.

For Pics

C

C is a middle level language that is considered to be high enough for productivity but close enough to the hardware to have some of the power of assembly. C has free form formatting rules so the look of C varies according to style and C compilers tend to produce harder to debug error messages. C is gaining in popularity over assembly with microcontrollers as embedded systems are becoming more and more complex. C is almost always compiled instead of interperated. Advanced C requires understanding of pointers which requires lower level understanding of the hardware than some people are interested in going. C compilers can be very expensive, however several free or demo versions of compilers are available.

Perhaps the most common open-source C compilers in embedded system development are:

  • SDCC (open-source C compiler for many low-cost 8-bit microcontrollers such as the 6502, Z80, 8051, etc.)
  • GCC (open-source C compiler for most 32-bit microcontrollers and the 8-bit Atmel AVR ATmega)

For Pics

Forth

Forth is a low level language designed for extremely compact programs -- ideal for a microcontroller with little program memory.

Forth also encourages incrementally developing and testing software, an interactive technique that supports rapid application development.

Forth for PICs

(shamelessly cribbed from the Massmind list of Forths for PICs)

  • PicForth, a Forth compiler for PIC 16F87x and 16F88 -- there is a tutorial for PicForth
  • IRTC, a Forth for the PIC18Fxxx microcontroller family.
  • mary, an Optimizing Forth Compiler for the PIC
  • FLASHFORTH for the PIC18 and PIC24 microcontrollers and for the dsPIC30 and dsPIC33 DSPs.
  • Purrr is a Forth dialect for microcontrollers. Currently has a PIC18Fxxx microcontroller implementation.
  • Pic18Forth is a 16-bit implementation of the Forth programming language for Microchip PIC18Fxx2 microcontroller devices.

Forth for other microcontrollers

See the list at ForthFreak, the list at Massmind.


C++

C++ is an extension of C. Many people consider C++ an object oriented language.

Some of the extension include:

  • Associations between data( classes ) and functions ( member functions ) that operate on that data
  • Modifications to existing classes through an extension method called inheritance without requiring modifications to the original code
  • Operator and function overloading

C++ is not as common as C for microcontrollers mostly because many microcontrollers are not powerful enough to run software large enough where the extra features become important. C++ is not supported by as many compilers as C for microcontrollers.

The "Arduino programming language" is C++.

Assembly

Assembly is a near exact mapping to the actual instructions executed by processors. It is very processor specific. Some architecture such as the older PIC processors are optimized for assembly programming where some RISC based architectors are optimized for higher level languages.

Some C compilers do not produce the best possible code so writing in assembly can theoretically produce faster code, but poorly written hand assembly can be worse. Some people mix C and assembly in the same project and most compilers make it easy to integrate assembly in C programs.

Situations that absolutely require assembly are now rare, but still important -- such as the "self-programming flash unlock sequence" and certain other parts of bootloaders, certain parts of new compilers, certain parts of new multi-tasking demand-paged operating systems, etc.

Python

see Python

As of 2025, Python is the highest-level programming language commonly available for many microcontrollers. (MicroPython and CircuitPython). Alas, many more microcontrollers are not powerful enough to run Python (or Python has not been ported to it yet), so people using microcontrollers are pretty much forced to use a lower-level programming language -- C, BASIC, Forth, JAL, or Assembly language.

Multiple programming languages

Often modern embedded systems include Python software running on a Raspberry Pi (see Python and the Raspberry Pi) communicating with C or C++ software running on Atmel or Microchip PIC microcontrollers. Or, in general, software in some high-level programming language on a Linux machine communicating with software in some low-level programming language running on some microcontroller.

The low-level software handles things that microcontrollers handle well -- extremely rapid response to sensors (such as, for example, avoiding driving over a cliff) and extremely precise precision timing (such as, for example, driving the stepper motors in a 3D printer) -- see RTOS. The high-level software running on a Linux machine handles things that Linux handles well -- user interfaces; or large databases; or internet access; or some combination.

In a few cases, the Linux machine also includes the compiler and an upload tool to update the software on the microcontroller -- see PIC Programmers, In Circuit Programming and BootLoaders

Related:

Other

Perhaps we should have some generally useful embedded Programming Tips ?

We should expand this section, but for now will just mention some names, you can google them: