[Noisebridge-discuss] Discussion Group: Function Programming in Embedded Systems.

nils at shkoo.com nils at shkoo.com
Sun May 24 05:45:23 UTC 2009


I found this that describes what Atom does:

http://www.haskell.org/haskellwiki/Applications_and_libraries/Hardware_verification

It looks like Atom generally targets compiling to Verilog and VHDL. 
That's a little bit of a different paradigm than regular arduino 
programming.

The arduino hardware is microcontroller-based; at its most basic level you 
supply assembly instructions to it (usually generated by a compiler).  It 
then executes those instructions, which tell it what to do.  It's very 
similar to a regular computer in that way.

Verilog and VHDL are quite different; they tend to run on a Field 
Programmable Gate Array (FPGA).  A FPGA is basically a bunch of logic 
gates that you can connect to each other; the "program" you upload tells 
the FPGA which logic gates should be connected to which others, and how. 
(Verilog code is a bit higher level than this but that's what it compiles 
down to, from what I understand). If you have deep pockets, you could then 
get your Verilog/VHDL program produced as a custom chip (like an ASIC).

Here is an example of an FPGA board: 
http://www.sparkfun.com/commerce/product_info.php?products_id=8596

I don't know if a lot of people around NB have experience with FPGAs; I 
certainly don't.

I did see the "atom for arduino" page and I'm not sure what that's all 
about.  It looks like the main loop just calls the atom-generated code 
over and over, so I'm guessing that's equivalent to simulating the ticking 
clock of a FPGA.  But it could be interesting.

Here's another interesting page I found which gives a little bit more 
extensive example of using atom:

http://leepike.wordpress.com/2009/05/05/an-atomic-fibonacci-server-exploring-the-atom-haskell-dsl/

-nils


On Fri, 22 May 2009, Jason Dusek wrote:

>  I'd like to put together a discussion group for functional
>  programming in embedded systems.
>
>  A good example of projects in this vein is Atom, for Haskell;
>  many other presentations present the same basic idea. It's
>  something like this:
>
> .  The system is broken in to little pieces, each of which is
>    associated with some C that will be run on the embedded
>    system.
>
> .  In a strongly-typed, functional language, rules for
>    composing the little pieces are stated in terms of the type
>    system. These rules are subject to formal verification.
>
> .  If the pieces turn out to make a mess of the rules, pieces
>    and rules are rewritten. Rinse and repeat.
>
> .  A verified system is assembled according to the rules.
>
>  I'd like to talk with people who know something about embedded
>  systems to help assess the validity and scope of this
>  approach, using Atom. Naturally, as the Haskell teacher, I am
>  going to work with everyone to make Haskell transparent. I
>  have no insight into embedded systems (no idea how to place
>  code on a device, &c.) and will need some help there.
>
>  Please do write in if you are interested so we can work out a
>  time to meet.
>
> --
> Jason Dusek
>
>
> |...Atom...|
>  http://leepike.wordpress.com/2009/05/05/an-atomic-fibonacci-server-exploring-the-atom-haskell-dsl/
> _______________________________________________
> Noisebridge-discuss mailing list
> Noisebridge-discuss at lists.noisebridge.net
> https://www.noisebridge.net/mailman/listinfo/noisebridge-discuss
>



More information about the Noisebridge-discuss mailing list