concurrency4all Parallella

1.4: news.adds/Parallella/
concurrency4all got funding:

Parallella project will make parallel computing
accessible to everyone.
first seen here:
3.9: sign up here: parallella.org .

27: news.adds/openware/
seeed Open Hardware Facilitator:

seeedstudio.com's open-sourced hardware .
Seeeduino blog .
. Seeeduino Mega first show on Modkit:
Modkit is an in-browser graphical programming environment
for microcontrollers. Modkit allows you to
program Arduino and Compatible hardware
using simple graphical blocks and/or traditional text code.
Modkit’s graphical blocks are heavily inspired by
the Scratch programming environment
developed by the Lifelong Kindergarten Group
at the MIT Media Lab
. Seeeduino is an Arduino compatible IO board:
Based on Duemilanuve Schematic, 100% compatible to its
existing program, shield and IDEs.
On the hardware part, remarkable changes are taken
to improve the flexibility and user experience.
see the arduino guide .
Arduino is a tool for making computers that can
sense and control more of the physical world
than just your desktop computer.
It's an open-source physical computing platform
based on a simple microcontroller board,
and a development environment
for writing software for the board.
Arduino can be used to develop interactive objects,
taking inputs from a variety of switches or sensors, and
controlling a variety of lights, motors,
and other physical outputs.
Arduino projects can be stand-alone,
or they can be communicate with software
running on your computer
(e.g. Flash, Processing, MaxMSP.)
The boards can be assembled by hand
or purchased preassembled;
the open-source IDE can be downloaded for free.
The Arduino programming language
is an implementation of Wiring,
a similar physical computing platform,
which is based on the Processing MPE
(multimedia programming environment).
- The Arduino software is published as open source tools,
available for extension by experienced programmers.
The language can be expanded through C++ libraries,
and people wanting to understand the technical details
can make the leap from Arduino to the
AVR C programming language on which it's based.
Similarly, you can add AVR-C code
directly into your Arduino programs
(see Stanford and MIT courses).
. AVR ? {Atmel VLSI, Alf Vegard} RISC, 
Atmel® AVR® 8- and 32-bit microcontrollers:
Optimized to speed time to market,
they are based on the industry's
most code-efficient architecture
for C and assembly programming.
No other microcontrollers deliver
more computing performance
with better power efficiency.
. the ATmega is the "The Next Step in
AVR Microcontroller Capacity and Performance"
for designs needing some extra muscle.
Ideal for applications requiring large amounts of code,
the megaAVR offers substantial program and data memories
with performance up to 20 MIPS.
Innovative picoPower technology minimizes power consumption.
All megaAVRs offer self-programmability for
fast, secure, cost-effective in-circuit upgrades.
You can even upgrade the flash while running your application.
Based on industry-leading, proven technology,
the megaAVR family offers our widest selection of devices
in terms of memories, pin counts and peripherals.
Choose from general-purpose devices
to models with specialized peripherals
like USB, or LCD controllers,
or CAN, LIN and Power Stage Controllers.
picoPower technology
— Selected megaAVR features ultra low power consumption
and individually selectable low-power sleep modes
that make it ideal for battery-powered applications.
High integration
— The megaAVR features on-chip flash, SRAM, internal EEPROM,
SPI, TWI, and USART, USB, CAN, and LIN, watchdog timer,
a choice of internal or external precision oscillator,
and general purpose I/O pins,
simplifying your design and reducing bill-of-materials.
Analog functions
— Advanced analog capabilities, such as ADC, DAC,
built-in temperature sensor and internal voltage reference,
brown out detector, a fast analog comparator
and a programmable analog gain amplifier.
The high level of integration allows designs with
fewer external analog components.
Rapid development
— megaAVR microcontrollers speed development
with powerful in-system programming
and on-chip debug.
In addition, in-system programming
simplifies production line programming and field upgrades.

- The Arduino is based on Atmel's
ATMEGA8 and ATMEGA168 AVR microcontrollers.
The plans for the modules are published under a
Creative Commons license,
so experienced circuit designers can
make their own version of the module,
extending it and improving it.
Even relatively inexperienced users
can build the breadboard version of the module
in order to understand how it works and save money.
see other projects to do with AVR:
. tutorial& kits by Ada .
. articles by avr freaks,
and their beginners site;
wikibooks .


make a kind of smart card and it's reader
. the master avr at reader
and the slave at card .

To connect two AT90S8515s via their serial ports,
if they are at 1m + distance
you will have to use driver circuits: RS-232 or RS-422..
Usually in applications like this
you will use so called "command-response" protocol
with active serial interrupts set to the highest priority ..
If you want to use the SPI
you have to link the SPI lines of the 2 micro's as:
micro1 <-> micro2
regarding the SS line, it depends how you want to
comunicate between the 2 microcontrollers.
The simplest way is to consider one micro the "Master"
and the other one "Slave"
and tied the SS lines according this to VCC and ground.
Look to the "AVR151: Setup and use of the SPI"
Application note from atmel site :
http://atmel.com/dyn/resources/ ... doc2585.pdf
http://atmel.com/dyn/resources/ ... AVR151.zip

Also see Procyon AVRlib
It contains SPI interface modules as well .
Is your own wire/protocol
the best way to connect two micros?
Why not TWI/I2C or SPI or UART?
[ I2C is Inter-Integrated Circuit;
(generically referred to as "two-wire interface")
is a multi-master serial single-ended computer bus
used to attach low-speed peripherals to an embedded system .]
I am emulating a floppy drive on an Amiga 500.
Timing is pretty tight. I have looked at SPI and I2C
however they take too many clock cycles to manage.
I've had to add a second AVR chip
just to handle the data lines.
This chip is used as a buffer
and the other is used to manage the storage.
The connected pins are essentially one way.
I'm confident in my programming ability
and knowledge of the ATMega chips I have,
but I'm not so confident in my electronics .
In addition to adding the 1 K resistor between the two pins,
be sure you also connect the grounds together.
The grounds of each board should be tied directly together,
NOT through a 1 K resistor.
Do NOT connect the V+'s together.
Serial Peripheral Interface (SPI)
The SPI is a peripheral used for communicating
between the AVR and other devices,
like others AVRs, external EEPROMs, DACs, ADCs, etc.
With this interface, you have one Master device
which initiates and controls the communication,
and one or more slaves
who receive and transmit to the Master.
Before you can successfully communicate through the SPI,
both the Master and Slave
must agree on some clock signal settings.
. not all AVRs have an SPI
but you still can implement it in software .
Having two SPI Masters may be possible:
see your datasheet .
3 pins of the master
are attached to the same pins of every slave:
# MISO (Master In Slave Out):
# MOSI (Master Out Slave In):
SCK (Serial Clock):
. then for each slave,
the master needs a dedicated out.pin
connected to the slave's SS' (Slave Select).
Since in an SPI setup you can have
several slaves at the same time,
you need a way to select
which Slave you want to communicate to.
This is what SS' is used for.
The software of the Master
must control the SS'-line of each Slave.
If the SPI-device is configured as a Master,
the behavior of the SS' pin depends on
the configured data direction of the pin.
If SS' is configured as an output,
the pin does not affect the SPI.
If SS' is configured as an input,
it must be held high to ensure Master SPI operation.
If the SS' pin is driven low,
the SPI system interprets this as another Master
selecting the SPI as a Slave
and starting to send data to it.
use of I2C for a dual core:

μnix [mu-nix] Operating System
The μnix project is an endeavour to create a
complete workstation and UNIX-like OS
using standard logic IC's and 8-bit AVR microcontrollers.
The goal isn't to make something that will compete with
a traditional workstation in computation;
it's an educational exercise
and electronic DIY hobbyist project.
AMPS (AVR® Multi-Processing System) clocked at 32MHz,
the μnix workstation (pronounced "myoonix"
due to the greek letter μ, meaning "micro")
will be able to perform
some impressive feats of agile computation.
The AMPS core is situated on
removable daughter cards
that can be removed or augmented
two microcontrollers at a time,
allowing a minimum dual configuration
and a maximum of
quad AVR MCU's working in tandem .
. after seeing mu-nix be vaporware,
consider moving up to real concurrency:

SWARM (SWift Adaptive Runtime Machine)
the Epiphany multicore processor is much more than
just a floating point coprocessor.
The Epiphany processor was designed to be an accelerator,
but it's definitely NOT a GPU.
It runs ANSI-C code like a regular CPU,
but shouldn't be confused with powerful x86 processors.
In a nutshell, the Epiphany multicore processor
is really a new type of animal with its own set of features.
16 core Epiphany-III processor
64 core Epiphany-IV processor
17: news.adds/openware/Rasp'Pi falls short:
www.zdnet.com/... story-of-the-raspberry-pi
. the Pi is not viewed as an open system in all quarters.
A recent criticism of its open-source credentials
was that the firmware for the GPU
on the Pi's Broadcom chip
is a closed-source blob,
and not open to anyone outside of Broadcom
to peruse or rewrite it.
While the GPU driver might be open source,
critics claim it operates at a high level
and does very little of the heavy lifting,
describing it as "little more than a message passing shim".
Some tweaks to extend the Pi's graphical capabilities,
for example adding new OpenGL features,
cannot be carried out by modders
as they would require access to the
GPU's closed-source firmware, it was claimed.

The decision to base the Pi on the ARM architecture
has also been called into question by those who decry the
lack of publicly available documentation for the
ARM core and its extensions,
and the difficulty they say this causes
in tasks like porting open-source VMs.
From the point of view of being able to learn about
the hardware and hack into it,
these critics argue that open chip architectures
like the LatticeMico32
would have been a better choice.
Upton says he struggles to understand the level of criticism
by some members of the open-source community.
"I was a little bit disappointed that people were unhappy.
I thought we'd taken a useful step
in the right direction," he said.

"We have got to a point where
everything on the ARM is open source
and that is a new thing.
Ninety-five percent of people gave us credit for
doing what we could.
People who are porting OSes are finding it useful,
it accomplishes many of the goals of wanting to have
free software," he said.