Category Archives: analog digital wandler

Arduino UNO, NANO connected to Scratch

Arduino UNO has an USB connection, which supports serial connection to a host computer. The arduino can be used as a IO expander, connecting digital io lines, pwm, servo or adc-inputs directly to scratchClient and to scratch.
On digital inputs D2-D12, the firmware supports counters. The inputs are debounced and frequencies are possible till prox 50Hz.

This setup with scratchClient can be run on Raspberry or on windows, unless scratch 1.4 is used.

Powered by the USB-connection, the UNO provides 5V-compatible inputs/outputs. This is an advantage in some constellations. But do not connect these outputs directly back to the raspberry GPIO pins. And be careful on power consumption. Small servo can be operated, but larger current devices need external 5V supply.

The solution is also applicable to arduino NANO. This small board offers a breadboard friendly layout.

Sample setup with a NANO, 3 LED, Poti, Button, Servo and NANO on breadboard. Host computer (Raspberry Pi or Windows) not shown.

The functionality presented here is not a bridge to mesh network, propagating events and sensor updates into the arduino. There is a custom arduino sketch needed which only exposes the IO resources, but does not allow for additional logic in arduino (yet).

Configuration of the io-pins (direction, pullup, pwm, servo) and adc-pins (whether used or void) is controlled by scratchClient through configuration.
The scratch names used are configurable in configuration too. This is common functionality of the framework.

Communication between host computer and arduino is by a serial line USB connection. Speed is 115200 bd, set line end to LF . The arduino protocol uses as short as possible command sequences.
Example:
pwm:4,90\n sets PWM channel 4 to 90.
p:4,90\n is the same command, abbreviated.

With
help\n
a summary of command features can be printed.

The protocol is build on readable ascii sequences, which makes debugging with arduino serial monitor easy (set line end feature to ‘newline’). This also allows to fully drive the protocol from the serial console.

The command parser uses a state based approach for speed purpose. Each received char needs to be processed as quick as possible, which is only possible with a state machine.
First implementation was collecting chars in buffers and on a LF-char the data have been compared to the different commands. This needed many expensive strcmp-operations, decoding the parameters was done by sscanf. This approach limited throughput.

The parser code is generated by a python program and the resulting code is then inserted into the arduino C-program.

The code for arduino, sample configuration for scratchClient and sample scratch program is in the scratchClient distribution.

For setup, follow the steps described below.

Step 1, program the firmware to arduino

Start arduino IDE software, load arduino/arduinoUno/arduinoUno.ino from the scratchClient distribution and program it into the UNO or NANO. This needs to be done only once. I run this from a windows machine, but arduino IDE should also be supported on Raspberry Pi.

The LED13 on the arduino should blink at 5Hz, quite fast. This indicates that the firmware is running, but did not yet receive configuration.
On a serial monitor, you should see:

arduino sending@115200 Bd
arduinoUno, version 2016-02-21
config?
config?
config?

The config?-request is printed each second until the host provides configuration commands. Close serial monitor in order to allow scratchClient to have access to the serial line.

With ‘help’ from the serial monitor (use newline for line end separator), the arduino provides the list of supported commands.

Step 2, sample Hardware setup

The hardware uses a potentiometer (2k to 10k are ok) on AD0. On D3, there is a button connected. The other side is having a 1k-resistor to GND (just in case the output is configured as an output, this prevents damage to the IO).
Two LED are for output. The green LED is on a PWM-output D5, so it can be dimmed.

This setup is a sample. The functionality of all the inputs and outputs are defined by configuration in scratchClient. See config/config_arduino_uno.xml for a sample.

Step 3, connect arduino with USB-Line to RaspberryPi or windows computer.

On raspberry, lookup /dev /tty* connections and configure the UNO serial device in config/config_arduino_uno.xml-File.

For windows, you see the COMn-Device used in deviceManager. Configure this name in config file.

An arduino UNO or NANO needs a few 20mA when running, LEDs add prox 10mA each. This current is provided by USB port of host computer. If more power is needed, then an external power supply is needed.

Step 4, start scratchClient with configuration

cd ~/scratchClient
python src/scratchClient -c config/config_arduino_uno.xml

After a short while, the LED13 should start blinking at 0.5Hz, quite slow. This indicates that configuration was downloaded and system ready to be used. The Tx, Rx-LED on arduino should flash now and then. Quite often when you turn the potentiometer, or when you press the button.

Step 5, start scratch with sample program

There is a sample program in scratch/arduinoUno/arduino.sb

The program takes the button input and controls the red LED with it.
The value from the potentiometer is used to set the pwm-rate and dims the green LED. The mapping of the variable names or sensor names to IO-points is done in config file.

ID-Code

The arduino can have an ID-code in eeprom, which can be set by serial line console and read out from remote. This ID allows the host raspberry to recognize the arduino and provide configuration for this special device. This is a very nice feature for school setups where some experiments are hard wired and need fixed configuration. There is a starter code available which checks the connected arduino, and presents the related config files for scratchClient to start. I am working on an extension to start scratch with a basic program too. Avoids a lot of handling errors in school, especially where the focus is on driving an experiment and coding is not so important.

The serial protocol allows to read and set the ident code.

cident?\n request idcode
cident:<char16>\n write idcode

Configuration Tool

The setup of the xml config file is not very intuitive. There is a config gui available to edit the file. The tool is started with

cd ~/scratchClient/tools
java -jar scratchClientConfig.jar

The left side of the frame is the editor pane which allows to select the various functions for the arduino. The right panel is a view-only display of resulting xml data.

Existing files can be loaded, but current version (2017-02-10) only allows to handle one adapter of type ‘UNO_Adapter’.

Constraints

The adc-channel is limited to 10Hz update rate. There is averaging for three samples per measurement value transmitted.
The digital inputs are limited to 20Hz update rate.
The adc-channel of atmel328 allow for analog inputs or GPIO usage.
PWM pulses are created with arduino native analog_write on the digital pins. Value range for pwm are 0..255.
Servo pulses are created with Servo-library. See limitations of this library in Arduino Servo [https://www.arduino.cc/en/reference/servo]. Input values for servo are 0..180.
Configuration is not persisted in the arduino (but downloaded from the the scratchClient adapter); there is no interface for custom logic (for fast sensors).
Configuration is requested to be sent from PI or windows to arduino on reset of arduino. If scratchClient configuration is changing, then a reset of arduino is needed to make this active. As in most cases a hardware change is made with arduino disconnected from power (either USB cable or power plug), this is only a small limitation.

This scratchClient adapter runs also on windows platform. This allows setups where a windows computer, scratch 1.4 for windows are using IO connections.

Other libraries

Recently I discovered ‘nanpy’, a python library to control an arduino by python programs.

Updates

Updated 2017-03-15, Counter for digital inputs added.
Updated 2017-02-10, Config tool for xml config file included.
Updated 2016-02-21, Some remarks on state based parser, command sets.
Updated 2016-02-15, added servo capability.

Environmental Sensors for scratchClient

The recent months have been busy with preparing new experiments for my
school project, especially one experiment measuring temperatures with TMP36. See →
link

When looking in detail to the datasheet of TMP36, there is an accuracy of max
+- 4K (G-Grade device) and +- 3K (F-Grade device). This is not bad for -40 to 125 °C. At 25°C, accuracy is +- 3K (G-Grade device) and +- 2K (F-Grade device).
Unfortunately the ADC on my adapter board, the MCP3202, uses the
vcc-voltage as reference, which gives additional error for the measurement.
With patch cables, there is also some noise. I twisted signal and ground
line, added some capacity close to the TMP36 power pins and a low pass
filter in the adapter logic. Which reduced, but did not remove the problems.

So I started to look for more precise alternatives. LM35 in combination
with an adc ads1015 and internal precision reference voltage gives better results.
LM35A specs give +-1K over -40 to 110 °C, around 25°C +- 0.5K.

When starting to look for integrated solutions, complex devices like SHT15
come around. Main purpose is to measure humidity, but temperature
measurement is included. +-0.3K around 25°C and +-1.5K in -40 to 90°C are
quite good. I2C is not supported, but a two-wire GPIO protocol is
available. Disadvantage is the high price.

BMP085 is a digital pressure sensor with temperature sensing included. +-2K
accuracy in 0 to 65°C. I2C, internal calibration data in registers, needs
some calculations to correct the raw values.

MAX31855K is used with k-type thermocouples and extends temperature range
to -200 to 1350°C. Note that K thermocouples have about ±2°C to ±6°C
accuracy. SPI interface is easy to use.

And for curiosity, I added a luminosity sensor BH1750 to this collection of
devices.

Scratch integration is ‘as usual’ with adapters, where configuration is
done by xml files.

Hardware interface to the devices (to be more precise: the breakout boards
with the devices, is by I2C, SPI or plain GPIO. For the SHT15, I added a
serial resistor of 1kOhm for the data line to protect against
input-output-mismatches during debug phase of code. For the clock line, this
is not needed, but in general a good idea to a serial resistor there too.
Too expensive this device, to take the risk of burning it away.

These sensors will not be part of the school workshop documentation. Setup
is described in the scratchClient handbook → link.

ADC-328-Board is here

The boards for the Atmel-328 based ADC board are here. And it works, only the LED connection was on the extra pin used by the 20MHz-version of this design. Corrected in software, already.

See the adc-board post, the capacitive sensor post for application details. The basic design is for a breadboard, but I wanted to have a portable package for this.

Schematic is here, the eagle schematic and board files are in the software package.

To get the board running with scratch, you need my scratchClient software.

Functionality are – with the firmware – 2 adc channels, frequency counter, impulse counter and infrared control. The two rotary encoders are prepared, but not yet coded.

The board uses 1206-size SMD components, just the size you can solder without a microscope.

JP1 is usually open, and connects GPIO4 to clock input. See flashing instructions.

SV1 is to the RPi

SV2 is ADC input. 1 = GND, 2 = GND, 3 = ADC0, 4 = ADC1, 5 = VCC, 6 = VCC

SV3 is usually open. It allows to connect RX, TX with those of RPi. It is aligned to allow to connect with two jumpers. I used this mainly for debugging purposes.

SV4 is the frequency measurement input. 1 = GND, 2 = input, 3 = VCC

This project is no kickstarter, and I do not sell this pcb.

So setup the parts on a breadboard, and if you like it find one of the reasonable cheap, long delivery time vendors in the world and build your own copy.

Atmel atmega328 used as AD-Converter for Raspberry Pi

[german]

Atmel 328-Prozessor used as AD-Converter

The microcontroller ATmega328P in DIL-package can be used on a breadboard.

This controller has many build-in functions, as ADConverter, timers SPI and more.
The Arduino boards use this controller, making it very popular and many literature is available.
The ADC has 10Bit resolution and in DIP package there are 5 channels available.

Wiring to Raspberry Pi is quite simple. The firmware can be programmed directly from RPi, no programming device needed. The focus of this article is not the programming of the device. The needed firmware is attached to the samples.
Cost of the devive are comparable to simple ADConvertes and are about 4€.

Disadvantage is the more complex setup needed.

On the download page, I provide a firmware which can read two AD-channels and to control a LED. More functions are planned, as frequency measurement, infrared control or rotary encoders.

The firmware of the controller can be programmed with the RPi. No extra flashing hardware is needed.
Prerequisite is that the controller has the internal 8MHz oscillator enabled. This is factory preset.
Basic setup of the controller is defined by ‘fuses’, especially the setup of the oscillator used. Without a working oscillator, programming is not possible.
If you get an already flashed device, e.g. prepared to be used in an arduino board, these will have internal oscillator shut off. In this case, reading out the software will not work. Workaround is to activate GPIO#4 of RPi as a clock source and connect to the 328. See attachments for a short tutorial. Or to use a flashing hardware.
Caution: when you use a device from an arduino board it is likely that the bootloader is overwritten. There is no simple way back.

parts list

ATmega 328 P-PU (DIL-package)
breadboard
precision socket for the processor. DIL 28 pin, 0.3 wide. Insert the socket to the breadboard, and insert the controller into socket. The controller can be used directly, but with the socket insertion and removal is simpler.
LED. The longer wire is the anode and is the ‘positive’ side.
resistor 1kOhm
capacitor ceramik 100nF, min 10V
trim potentiometer for test
cables f-m, 7 or 8 pieces
wires for breadboard.

Setup procedure

Basic steps are wiring, flashing the controller and activating scratchClient software.

electrical setup

Shut down RPi and disconnect power source.

Place processor on breadboard and connect according to scheme.

VCC 3.3V is taken from from Raspberry.
SPI-connections MISO, MOSI, SCK and SS at CS0 of RPI allow communication.
RESET pin 1 to GPIO24 is needed for flashing in addition to SPI.
LED with serial resistor 1kOhm is connected to PB1, Pin 15.
ADC-inputs used are ADC0 and ADC1, Pin 23, 24.

This is how the controller sits in socket on breadboard.

Installing flash software on Raspberry Pi

sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get install python-dev pip
sudo pip install spidev intelhex

Activate SPI driver. Use raspi-config , enable SPI.

Copy the programming software to /home/pi .

Download software and store in /home/pi and unpack “tar xfvz program_328.tar.gz”.

tar xzvf program_328.tar.gz

Validate hardware and software setup

The following steps validate correct cabling and whether flashing the controller is possible.

Read Fuses

cd ~/program_328
sudo python src/program.py -rf

The output should look similiar to

PROGRAMMING_READ_CALIBRATION_BYTE b0 10110000
 PROGRAMMING_READ_EXTENDED_FUSE_BITS ff 11111111
 BODLEVEL0 1
 BODLEVEL1 1
 BODLEVEL2 1
 PROGRAMMING_READ_FUSE_BITS e2 11100010
 CKSEL0 0 ENABLED
 CKSEL1 1
 CKSEL2 0 ENABLED
 CKSEL3 0 ENABLED
 SUT0 0 ENABLED
 SUT1 1
 CKOUT 1
 CKDIV8 0
 PROGRAMMING_READ_FUSE_HIGH_BITS d9 11011001
 BOOTRST 1
 BOOTSZ0 0 ENABLED
 BOOTSZ1 0 ENABLED
 EESAVE 1
 WDTON 1
 SPIEN 0 ENABLED
 DWEN 1
 RSTDISBL 1
 PROGRAMMING_READ_LOCK_BITS ff 11111111

If there are errors (Device not in sync), then either cables are not correct connected or the processor has wrong fuses already programmed.
Check connections. If error persists, then connect external clock.

Read out current code

Another step in validating the setup is to read current code. Should be empty on a brand new device, but is useful to check communication.

cd ~/program_328
sudo python src/program.py -r

The output should look similiar to

python src/program.py -r
 ('read', 'out.hex')
 programming_readCode
 programming_enable
 ('PROGRAMMING_ENABLE', [172, 83, 0, 0])
 (0, [255, 255, 83, 0])
 programming_enable end
 programming_disable
 programming_readCode ende
 ok

Flash testcode to controller

When everything went smooth so far, then it is time to load the first testcode into the controller. It dies nothing but let the LED blink.

cd ~/program_328
sudo python src/program.py -p 328/steckbrett_328_blink.hex

LED should blink slowly.

Program Fuses for oszillator

The controller runs with internal oscillator, but frequency is limited to 1MHz. By setting the correct fuses, the Controller runs with 8MHz.

Please do not program the fuses, if there have been errors in steps before (which are not yet fixed) and the LED is blinking.

cd ~/program_328
sudo python src/program.py -wf

Blinking should stop shortly, and restart quicker, 5 times a second.
Oscillator setup is completed now.

Flash firmware to controller.

Final step is flashing the application firmware. It handles the AD-Conversions, LED-Settings and alike.
cd ~/program_328
sudo python src/program.py -p 328/steckbrett_328.hex

After programming is complete, the LED should blink 8 times. This is part of the RESET routine.

Application – testcode

Blink the LED, long bright, short dark.
cd ~/program_328
sudo python src/test_blink.py
The duty cycle is set by the python code in side Raspberry. This indicates that it is the reaspberry having control.

Read firmware version.
cd ~/program_328
sudo python src/test_get_version.py

Display should show ’93 09′; second number is minor version and can be higher.

Read ADC, Channel 0
cd ~/program_328
sudo python src/test_adc_0.py

Scratch-Connection

When tests for application software work, the next step is the connection to scratch.

cd ~/scratchClient
sudo python src/scratchClient.py -config config/config_adc_atmel328.xml

Configuration can be adjusted in the config file. ADC-channels can be enabled / disabled, or reference voltage can be 3.3-V or the internal reference 1.1V.
The internal reference voltage is useful when an tempperature sensor TMP036 is connected.
The 3.3V-reference is perfect when a potentiometer is connected.

The ADC values are sent with variable names ‘adc_0’ und ‘adc_1’ to scratch, range is 0..1023.
Broadcast commands from scratch to controller are ‘led_off’, ‘led_on’.

SPI-Communication between RPi and Controller

SPI is a synchronous protocol. The Controller as slave has no chance to indicate ‘slower please’ to the master. Therefor, each command from RPi to controller needs to be answered in the time between receiving the first an second byte of a sequence. Otherwise, there will be garbage read back.

This limits transfer speed to 240kHz with the 8MHz controller. With the 20MHz variant, this will be faster.

Appendix: GPIO#4 of RPi as clock-input for 328

Der GPIO#4-Pin can be configured to provide a MHz range clock signal for the controller. The program for this is in bin/-folder. It is based on code from guzunty.org.

Connect GPIO#4 with XCLK-Eingang of controller. Then start program bin/gz_clock_1.92MHz.

cd bin
chmod +x gz_clock_1.92MHz 
sudo ./gz_clock_1.92MHz

While this program is running, execute read/write of fuses in a second terminal window.
Then disconnect GPIO#4.

Update history:
2014-04-01 Fixed connections of LED

Capacitive Sensor for Scratch

[german]
Using an oscillator and a microcontroller atmega328 it is possible to build a fill level measurement for scratch, based on a capacitive sensor.

The controller is measuring the frequency of the oscillator. Data are transmitted by SPi to raspberry. A scratchClient adapter is calculating the frequency and forwarding them to scratch.

The video shows the setup on breadboard. Left side is the oscillator, in the middle is the controller and then the connection to raspberry. The sensor is build from a stripe of copper coated epoxy, separated in the middle. As air has different electrical characteristics than water, the capacity of the capacitor changes close to water. An oscillator, using this capacitor, will change its frequency.

The scratchClient uses the adapter ‘Atmel328_ADC_Adapter’. The firmware is the same as for the ADConverter AD-Wandler.

The oscillator ist standard TLC555, the cmos cousin of popular 555. The frequency range is in the example 13,5kHz in dry air and 9,6kHz with water in glass.

Frequency measurement is done in controller on 10ms or prox 72 periods. The controller is averaging the last 16 measurements. The ‘open’ construction causes some disturbances, causing sporadic measurement failures.

Update history:
2014-04-01 Fixed connections of LED

Kapazitiver Sensor für eine Füllstandsanzeige

[english]

Mit einem Oszillator und einem Microcontroller ATMega 328 kann ein Füllstandsanzeiger für Scratch gebaut werden.

Der Microcontroller ermittelt die Frequenz des Oszillators. Die Daten werden über SPI an den RaspberryPi gegeben. Der Scratch Adapter wertet diese aus und gibt sie an scratch weiter.

Der Film zeigt den Aufbau auf dem Steckbrett. Das enthält den Oszillator links, in der Mitte den Controller und dann die Verbindung zum RPi. Der Sensor ist ein Streifen einer Epoxydplatine. Die Kupferschicht wurde längs unterbrochen, so dass die zwei Platten eines Kondensators entstehen. Da Luft andere Eigenschaften als z.B. Wasser hat, verändert sich die Kapazität des Kondensators in der Nähe von Wasser. Ein Oszillator, der diesen Kondensator verwendet, wird seine Frequenz verändern.

Der scratchClient benutzt den Adapter ‘Atmel328_ADC_Adapter’. Die Firmware des Controllers ist dieselbe wie für den AD-Wandler.

Der Oszillator ist ein TLC555, die CMOS-Ausführung des bekannten 555. Zusätzliche Bauteile sind 2 Widerstände 1M Ohm und ein Kondensator 100nF. Frequenzbereich ist im Beispiel etwa 13,5kHz ohne Wasser im Glas und 9,6kHz mit Wasser.

Die Frequenzmessung erfolgt im Microcontroller über ca 10ms bzw 72 Signalperioden. Die Werte werden auf dem Controller mit den letzten 16 Werten gemittelt. Wegen des offenen Aufbaus gibt es einige Störgrössen, die ohne Mittelwertbildung/Filterung sporadische Ausreisser produzieren.

Update history:
2014-04-01 Fixed connections of LED

Atmel 328-Prozessor als AD-Wandler für Raspberry Pi

[english]

Siehe auch
MCP3202-AD Wandler am Raspberry PI
ADS1015 als AD-Wandler am Raspberry Pi
Arduino UNO, NANO connected to Scratch

Atmel 328-Prozessor als AD-Wandler für Raspberry Pi

Der Microcontroller ATmega328P im DIL-Gehäuse kann auf dem Steckbrett in Betrieb genommen werden.

Der Microcontroller hat viele eingebaute Funktionen, wie z.B. AD-Wandler, Timer, SPI und anderes mehr.
Dieser Microcontroller ist im Hobbybereich sehr bekannt, da die Arduino-Boards mit diesem Microcontroller arbeiten.
Der AD-Wandler des Microcontrollers hat eine ausreichende Auflösung mit 10 Bit und es können bis zu 5 Eingänge angeschlossen werden. Damit kann er als Ersatz für einen AD-Wandlerbaustein benutzt werden.

Der Controller ist einfach an den Raspberry Pi anzuschliessen und sein Programm kann vom RPi aus aufgespielt werden. Wie der Baustein programmiert wird soll hier nicht beschrieben werden. Das benötigte Programm ist bereits übersetzt in den Beispielen enthalten.
Die Kosten für den Prozessor sind mit einigen Euro etwa so hoch wie für einen AD-Wandler.

Nachteil ist die etwas komplizierte Inbetriebnahme. Die ist deshalb so lang geworden, da viele einzelne Schritte und Überprüfungen aufgenommen wurden.

Das interne Programm des 328-Microcontroller ist in den Beispielen enthalten.

Das Programm kann zwei AD-Kanäle auslesen und eine Leuchtdiode ansteuern. Weitere Funktionen sind in Planung, wie ein Frequenzmesser, ein Anschluss für eine Infrarotfernsteuerung und Drehencoder.

Das Programm des Microcontrollers kann mit dem Raspberry in den Controller übertragen werden. Es ist also kein extra Programmiergerät erforderlich.
Voraussetzung ist, dass der Microcontroller den internen 8MHz RC-Oszillator aktiviert hat. Das ist bei fabrikneuen Microcontrollern der Fall.
Die Grundeinstellung des Microcontrollers, also auch die Steuerung der Oszillatoren wird über ‘Fuses’ eingestellt. Damit kann man den interen Oszillator aktivieren oder es werden Quartz-Oszillatoren oder eine externe Taktquelle aktiviert. Das Problem ist, dass ohne aktiven Oszillator das Programmieren mit dem RPi nicht funktioniert.
Falls man einen bereits programmierten Prozessor erhält, dann kann dieser den internen Oszillator abgeschaltet haben. In diesem Fall funktioniert bereits das Auslesen der ‘Fuses’ nicht.
Dann braucht man entweder ein spezielles Programmiergerät oder muss den GPIO#4 als Taktquelle aktivieren. Eine Anleitung dazu ist am Ende des Artikels zu finden.

Einkaufsliste

ATmega 328 P-PU (DIL-Gehäuse)
Steckbrett
Präzisionsfassung 28 pol, DIL 28 pol, 0.3 breit. Die Fassung ist für den Prozessor, damit die Beinchen nicht so leicht verbiegen. Fassung auf verbogene Kontakte kontrollieren (vorsichtig gerade biegen) und ins Steckbrett einsetzen. Den 328 in die Fassung einsetzen. Die Füsse des Prozessors sind ab Fabrik nicht genau parallel ausgerichtet. Vorsichtig auf einer glatten Platte ausrichten.
Leuchtdiode. Der längere Anschluss ist die Anode und wird mit ‘+ 3.3V’ verbunden.
Widerstand 1kOhm
Kondensator, Keramik 100nF, min 10V
Trimmpotentiometer zum Test
Steckbrücken Buchse-Stecker, 7 Stück oder 8
Kabelbrücken fürs Steckbrett

Inbetriebnahme

Aufbau der Verkabelung, Programmierung des Prozessors und Aktivieren der scratchClient-Software.

Elektrischer Aufbau

Strom des Rpi abschalten.

Prozessor auf dem Steckbrett aufbauen.

VCC des Prozessors wird aus 3.3V des Raspberry versorgt.
SPI-Verbindung MISO, MOSI, SCK und SS an CS0 des RPI.
RESET des Prozessors Pin 1 an GPIO24
LED mit Serienwiderstand 1kOhm von Port PB1, Pin 15.
ADC-Eingänge am atmega328 sind ADC0 und ADC1, Pin 23, 24.

So sieht der Controller im Sockel auf dem Steckbrett aus.

Programmiersoftware auf dem Rpi installieren

sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get install python-dev pip
sudo pip install spidev intelhex

Den SPI-Treiber aktivieren. Der ist über raspi-config zu starten, (enable SPI).
Oder über
sudo modprobe spi_bcm2708

Programmiersoftware in /home/pi kopieren

Das Archiv laden und auf dem RPi in /home/pi speichern und auspacken.

tar xzvf program_328.tar.gz

Überprüfen der Hardware und der Programme

Die folgenden Schritte prüfen, ob die Verkabelung korrekt ist und die Programmierung des Controllers möglich ist.

Fuses auslesen

cd ~/program_328
sudo python src/program.py -rf

Die Ausgabe sollte folgendermassen aussehen

PROGRAMMING_READ_CALIBRATION_BYTE b0 10110000
 PROGRAMMING_READ_EXTENDED_FUSE_BITS ff 11111111
 BODLEVEL0 1
 BODLEVEL1 1
 BODLEVEL2 1
 PROGRAMMING_READ_FUSE_BITS e2 11100010
 CKSEL0 0 ENABLED
 CKSEL1 1
 CKSEL2 0 ENABLED
 CKSEL3 0 ENABLED
 SUT0 0 ENABLED
 SUT1 1
 CKOUT 1
 CKDIV8 0
 PROGRAMMING_READ_FUSE_HIGH_BITS d9 11011001
 BOOTRST 1
 BOOTSZ0 0 ENABLED
 BOOTSZ1 0 ENABLED
 EESAVE 1
 WDTON 1
 SPIEN 0 ENABLED
 DWEN 1
 RSTDISBL 1
 PROGRAMMING_READ_LOCK_BITS ff 11111111

Wenn es Fehlermeldungen gibt (Device not in sync), dann liegt ggf ein Schaltfehler vor oder der Prozessor ist bereits mit unpassenden Fuses programmiert.
Dann erst mal nicht weitermachen und Verkabelung überprüfen. Wenn diese stimmt, dann externen Takt anschliessen.

Aktuelles Programm auslesen

Wenn die Ausgabe stimmt, dann kann man versuchen das aktuelle Programm auszulesen. Das ist bei einem neuen Prozessor noch leer. Hier dient das zu einer weiteren Überprüfung der Kommunikation.

cd ~/program_328
sudo python src/program.py -r

Die Ausgabe sollte wie folgt aussehen

python src/program.py -r
 ('read', 'out.hex')
 programming_readCode
 programming_enable
 ('PROGRAMMING_ENABLE', [172, 83, 0, 0])
 (0, [255, 255, 83, 0])
 programming_enable end
 programming_disable
 programming_readCode ende
 ok

Test-Programm in den Controller laden

Sind die bisherigen Schritte erfolgreich, dann kann man das erste Testprogramm in den Prozessor laden. Es sollte die LED blinken lassen.

cd ~/program_328
sudo python src/program.py -p 328/steckbrett_328_blink.hex

Jetzt sollte die LED langsam blinken.

Fuses für Oszillator programmieren

Der Microcontroller läuft bisher mit dem internen Oszilator, aber durch einen Teiler wird die Frequenz auf 1MHz heruntergesetzt. Der Teiler kann mit den Fuses abgeschaltet werden und der Controller läuft dann mit 8MHz, was bei 3.3V Betriebsspannung das Maximum ist für diesen Controller.

Die Fuses nur programmieren, wenn es bei den vorherigen Schritten keine Fehler gab und die LED auch blinkt.

cd ~/program_328
sudo python src/program.py -wf

Das Blinken hört kurz auf, und sollte dann deutlich schneller wieder anfangen, 5 mal die Sekunde.
Jetzt der Oszillator konfiguriert und der Controller läuft mit 8MHz.

Anwendungsprogramm in den Controller laden

Jetzt kann das eigentliche Anwendungsprogramm geladen werden. Es sorgt für regelmässiges Auslesen der AD-Werte ADC0, ADC1.
cd ~/program_328
sudo python src/program.py -p 328/steckbrett_328.hex

Nach dem Programmieren oder Einschalten des RPI mit dem Steckbrett sollte die LED 5 mal leuchten.

Anwendungsprogramm – Testprogramme

Die LED blinken lassen, lange hell und kurz dunkel.
cd ~/program_328
sudo python src/test_blink.py

Auslesen der Version des 328-Programms
cd ~/program_328
sudo python src/test_get_version.py

Die Anzeige sollte ’93 09′ sein; die zweite Zahl kann höher sein.

Auslesen der adc_0-Werte
cd ~/program_328
sudo python src/test_adc_0.py

Scratch-Verbindung

Wenn die Tests für die Anwendungssoftware funktionieren, kann die Verbindung mit Scratch in Betrieb genommen werden.

cd ~/scratchClient
sudo python src/scratchClient.py -config config/config_adc_atmel328.xml

Die Konfiguration kann über Parameter angepasst werden und erlaubt das An-Abschalten der AD-Kanäle. Die Referenzspannung kann 3.3-V sein oder die interne 1.1V-Referenz.
Die 1.1V-Referenz kann z.B. mit einem Temperatursensor TMP036 benutzt werden.

Die 3.3V-Referenz ist ideal, wenn Potentiometer ausgelesen werden.

Die Werte der AD-Wandler werden als ‘adc_0’ und ‘adc_1’ an Scratch geschickt, Wertebereich 0..1023.
Befehle von Scratch an den Controller sind ‘led_off’, ‘led_on’.

SPI-Kommunikation zwischen RPi und Controller

Der Controller muss alle Befehle, die vom RPi gesendet werden überprüfen und die entsprechende Aktion ausführen. Der Controller muss das so schnell erledigen, dass die nächste Anfrage des RPi schon die korrekten Daten erhalten kann.

Die Übertragungsrate kann deshalb nur relativ langsam sein mit 240kHz. Das ist aber bei der Kommunikation mit Scratch kein Problem.

Trotz dieser Beschränkungen wurde SPI gewählt, da diese Verbindungen bereits zum Programmieren des Controllers vorhanden sind.

Anhang: GPIO#4 des RPi als Taktgenerator für den 328

Der GPIO#4-Pin kann als Taktausgang konfiguriert werden. Das dafür notwendige Programm ist im bin/-Verzeichnis enthalten, Es basiert auf Code von guzunty.org.

GPIO#4 mit den XCLK-Eingang des Controllers verbinden. Dann das Programm bin/gz_clock_1.92MHz starten.

cd bin
chmod +x gz_clock_1.92MHz 
sudo ./gz_clock_1.92MHz

Die Ausgabefrequenz ist ca 2MHz.

Während das Programm läuft, das Auslesen und Schreiben der Fuses ausführen.
Dann diese Verbindung wieder trennen.

Update history:
2014-04-01 Fixed connections of LED

ADS1015 als AD-Wandler am Raspberry Pi

Siehe auch
Atmel 328-Prozessor als AD-Wandler für Raspberry Pi
MCP3202-AD Wandler am Raspberry PI
Arduino UNO, NANO connected to Scratch

Die Firma adafruit vertreibt eine kleine Platine, die einen 12-Bit ADC ADS1015 enthält. Dieser hat eine eigene Referenzspannung und einen einstellbaren Verstärker. Bis zu 4 Analogkanäle können angeschlossen werden. Der nutzbare Spannungsbereich ist 0 bis 3.3V, da im Beispiel die Platine mit 3,3V betrieben wird.

Diese Platine kann zum Anschluss von analogen Sensoren mit scratch benutzt werden.

Benötigt: Steckbrett, Lötkolben, Lötzinn, Steckkabel Buchse/Stecker und einige kurze Drahtstücke. Potentiometer 2.2kOhm (hier geht auch bis 10kOhm) als Beispiel für einen Sensor.

Um die Platine an den RPi anzuschliessen ist ein Steckbrett nötig. Die Platine wird ohne montierte Steckleiste ausgeliefert, diese muss selber angelötet werden. So sieht das dann aus.

Die Verkabelung ist hier aufgezeichnet.

Hier ist das Potentiometer an den Eingang A2 angeschlossen. Es kann jeder Eingang verwendet werden, das muss dann aber auch in der Konfiguration des scratchClient berücksichtigt werden.

Vorbereitung (siehe auch die Installationsanweiung in der Dokumentation des scratchClient):

sudo apt-get python-smbus i2c-tools
sudo modprobe i2c-bcm2708
sudo modprobe i2c-dev

Die ‘i2c-tools’ sind eine Sammlung von Werkzeugen, um den i2c-Bus zu prüfen und Geräte anzusprechen. Nach der Verkabelung kann geprüft werden, ob der Baustein ansprechbar ist.

pi@raspberrypi ~ $ sudo i2cdetect 1
WARNING! This program can confuse your I2C bus, cause data loss and worse!
I will probe file /dev/i2c-1.
I will probe address range 0x03-0x77.
Continue? [Y/n] Y
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
pi@raspberrypi ~ $

Der ADS1015 taucht hier mit der (hexadezimalen) Adresse 0x48 im Listing auf.

Start des scratchClient:

cd ~/scratchClient
sudo python src/scratchClient.py -c config/config_adc_ads1015.xml

Scratch erhält die Werte vom scratchClient im Bereich 0..3300 (ungefähr) als adc_A2. Das ungefähr deswegen, da der Baustein die Spannung absolut mit seiner eingebauten Referenzspannung misst. Wenn jetzt die 3.3-V-Versorgung der RPi etwas vom Sollwert 3300 mV abweicht, so weicht auch der Maximalwert ab.

Der Name ‘adc_A2’ ist in der Konfigurationsdatei so eingestellt, da im Beispiel der Kanal A2 verwendet wird.

MCP3202 AD-Wandler am Raspberry Pi

Siehe auch
Atmel 328-Prozessor als AD-Wandler für Raspberry Pi
ADS1015 als AD-Wandler am Raspberry Pi

Im Schulkurs wird eine Adapterplatine verwendet. Im Prinzip sind alle Experimente aber auch ohne diese Platine möglich.

Eine der Ausnahmen ist der Anschluss eines Potentiometers, für das ein Analog-Digital-Umwandler ‘ADC’ benötigt wird.

Der im Kurs verwendete Baustein “MCP3202 CI/P” ist im steckbaren DIP-Gehäuse erhältlich. Der Baustein kann auf dem Steckbrett benutzt werden.

Der Baustein wird über den SPI-Bus angespochen. Das sind die im Diagramm verwendeten blauen Signale. Die schwarzen und roten Drähte sind die Stromversorgung des Bausteins. Der gelbe Draht ist der Spannungseingang des ADC; da ist im Aufbau ein Potentiometer angeschlossen.

Für den Aufbau der Schaltung sollte der raspberry pi ausgeschaltet sein. Die Schaltung sorgfältig aufbauen und kontrollieren.

Die für den Anschluss an scratch nötige Software ist der scratchClient, die Konfiguration ist config/config_ikg_adc.xml.

cd ~/scratchClient
sudo python src/scratchClient.py -c ikg_adc

Bei der Installation des Rechners muss der SPI-Treiber aktiviert werden.