Home > Distraction > Atom & Arduino :: Some Hacking (pt. 1)

Atom & Arduino :: Some Hacking (pt. 1)

When Tom Hawkins released the Atom package, I stole my friend’s Arduino Diecimila to see if I could get some Atom-generated code to work. Turns out it wasn’t that hard! I’ll be detailing this in the next few posts. I’m going to use this first post to point out two things I changed in atom-0.0.2.

  • By default, Atom hardcodes the C types which correspond to the Atom types. This means that an Int32 is always defined as signed int. Unfortunately, the ATmega168 CPU and the avr-gcc compiler define a signed int as an Int16. I needed a way to customize these types.
  • Even though an Atom action can refer to an external function, I wasn’t able to see a nice way to have Atom plop a #include in the generated code. I added this ability as well.

My changes only end up affecting two exposed functions. To facilitate the include files and the C types, I added an AtomConfig data type (this can be found in Language.Atom.Code).

data AtomConfig = AtomConfig {
    cIncludes :: Maybe [String],
    cTyper    :: Maybe (Type -> String)

I also changed the type signature of writeC. It now reads as:

writeC :: Name -> Maybe AtomConfig -> [[[Rule]]] -> [UV] -> IO ()

Now, we don’t actually have to call writeC our selves 1, but it does get called by compile from Language.Atom.Compile. The compile function now has this type signature:

compile :: Name -> Maybe AtomConfig -> Atom () -> IO ()

Other than the example in Language.Atom.Example, this is the only visible code that I changed.

Here’s how you use the AtomConfig type:

cType :: Type -> String
cType t = case t of
  Bool   -> "uint8_t"
  Int8   -> "int8_t"
  Int16  -> "int16_t"
  Int32  -> "int32_t"
  Int64  -> "int64_t"
  Word8  -> "uint8_t"
  Word16 -> "uint16_t"
  Word32 -> "uint32_t"
  Word64 -> "uint64_t"
  Float  -> "float"
  Double -> "double"
cfg = AtomConfig {
    cIncludes = Just ["blink.h"],
    cTyper    = Just cType

First, we define a function that takes a Type and produces a string representing the C type. We build the config with an optional list of include files 2 and an optional typing function. If Nothing is passed to both fields, then Atom will not use any include files and will use the built in type converter.

In the next post, we’ll start building a simple program: blink an LED hooked up to some I/O pins on the Arduino.

I’ve posted a diff of my changes to atom-0.0.2. Any criticisms are welcome.

  1. At least, I haven’t seen a reason to yet–perhaps this should not be exposed?
  2. These includes are the kinds that use quotes, not angle brackets. We’ll see #include "blink.h" rather than #include <blink.h>.
Categories: Distraction Tags: ,
  1. brian
    May 3rd, 2009 at 13:03 | #1

    Cool! Part 2, please!

  2. John Van Enk
    May 3rd, 2009 at 13:43 | #2

    It’s in progress!

  3. Radamés
    May 3rd, 2009 at 23:20 | #3

    Great idea! I’ve been thinking about haskell and arduino interacting by some serial communication with System.IO, however I’ve never thought about program arduino with haskell!! For a while, I don’t know to much Atom package for help you!
    Good job!

  4. Ivan
    April 22nd, 2010 at 23:17 | #4

    Is Pt. 2 still in progress? I have a Duemilanove; maybe I can test some programs you want to post. I’m using Haskell in several platforms (Angstrom on Toshiba e750, Debian on Freerunner, and my desktop of course), I’d like Arduino to be the next. Contact me if you think I can help.

  1. May 4th, 2009 at 22:58 | #1
  2. May 5th, 2009 at 13:03 | #2
  3. August 1st, 2009 at 13:19 | #3