[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