6.1   Shell

Am einfachsten kann man mit Shell Kommandos die Analogwerte einlesen. Zunächst muss man den gewünschten Analogeingang GPA1 auswählen, das geht mit

root@armv5te:~# echo "1" > /dev/lpc3131_adc

Danach kann man schon die Analogwerte einlesen mit

root@armv5te:~# cat /dev/lpc313x_adc

Die Ausgabe ist einfach eine Hexzahl, z.B.

0x3b2

Die voreingestellte Auflösung des Wandlers ist 10 Bit. Damit liegen die eingelesenen Werte zwischen 0 und 0x3ff (dezimal 1023). Der Wandler kann auch mit 8- oder 4-Bit Auflösung arbeiten, genaueres kann man [2] entnehmen. Die README Datei des Treiber beschreibt, wie man die Einstellungen des ADC ändern kann.

Wenn man mit cat wiederholt Werte aus einer Datei (in unserem Fall eine "Pseudodatei") herauslesen möchte, dann ist auch das Werkzeug watch sehr praktisch. Es gibt regelmässig neue Werte in der Konsole aus, die alte Ausgabe wird alle 2 Sekunden durch die neue überschrieben:

watch cat /dev/lpc313x_adc

Wenn man den neuen Wert jede Sekunde erhalten möchte, dann gibt man ein:

watch -n 1 cat /dev/lpc313x_adc

Die Ausgabe sieht damit so aus:

Every 1.0s: cat /dev/lpc313x_adc              Mon Jul 9 11:07:21 2012

0x1f89

Genaueres sagt wie immer die man page zu watch (man watch).

6.2   Python

Ein einfaches Python Programm zum Ansteuern des ADC sieht so aus:

import os

DEVICE = '/dev/lpc313x_adc'

def select_gpa1():
   fd = os.open(DEVICE, os.O_RDWR)
   os.write(fd, "0x0001")
   os.close(fd)

def get_adc():
   fd = os.open(DEVICE, os.O_RDONLY)
   av = os.read(fd, 256)
   os.close(fd)
   return av[:-1]  # strip off trailing '\n'

if __name__ == "__main__":
   select_gpa1()
   ad_val = get_adc()
   print ad_val

Den zurückgegebenen Hex-String (z.B. 0x37b) kann man einfach in eine Zahl umwandeln. Dazu nimmt man die eingebaute Funktion int(val, 16).

So wie der Treiber momentan programmiert ist, erfolgt das Einlesen des ADC Wertes beim Öffnen der Gerätedatei. Man muss also bei jedem Einlesevorgang den Zyklus Öffnen, Lesen, Schliessen durchlaufen. Wenn man die Zeit misst, die für das Einlesen von 1000 ADC Werten benötigt werden, dann kommt etwa eine Sekunde heraus, das heisst, je Abtastvorgang wird etwa 1 msec benötigt. Es ist klar, dass die mächtige Interpretersprache hier langsamer sein wird als ein in C geschriebenes Programm.

Ein nützliches Muster zum Messen der Zeitspanne in Python ist

import time
t1 = time.clock()
...
t2 = time.clock()
print t2 - t1

Verzögerungen baut man mit time.sleep() ein, z.B. verzögert folgende Zeile um 0,3 Sekunden:

time.sleep(0.3)

Genaueres sagt wie immer die Dokumentation der Python Standardbibliothek zum time Modul [3]. Die Homepage der Sprache Python ist http://www.python.org.

6.3   Ruby

# adc.rb
# Gnublin Project www.gnublin.org
# <Hubert.Hoegl@hs-augsburg.de>, July 2012
#
# This program reads from ADC input pin GPA1.

file = File.new("/dev/lpc313x_adc", "w")
file.puts("1")  # select GPA1
file.close

n = 0
while (n < 10)
    file = File.new("/dev/lpc313x_adc", "r")
    adc_value = file.gets()
    file.close
    puts(adc_value)
    sleep(1)
    n = n + 1
end

6.4   Lua

-- adc.lua
-- Gnublin Project www.gnublin.org
-- <Hubert.Hoegl@hs-augsburg.de>, July 2012
--
-- This program reads from ADC input pin GPA1.

if os.path_exists("/dev/lpc313x_adc") == 1 then
   f = io.open("/dev/lpc313x_adc", "w")
   f:write("1")   -- select GPA1
   f:close()
else
   print("no such file: /dev/lpc313x_adc")
   os.exit(1)
end

n = 1000
print("reading " .. n .. " ADC values")
repeat
   f = io.open("/dev/lpc313x_adc", "r")
   t = f:read("*line")
   f:close()
   n = n - 1
until n == 0

6.5   C

In C sieht das Programm wie folgt aus:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>

unsigned char buffer[256];

void select_gpa1()
{
   /* select ADC 1 */
   fd = open("/dev/lpc313x_adc", O_RDWR);
   write(fd, "1", 2);  /* "1\0" */
   close(fd);
}

int get_adc()
{
   fd = open("/dev/lpc313x_adc", O_RDONLY);
   n = read(fd, buffer, 256);
   close(fd);
   return n;
}

Dieses Programm kann man durchaus mit dem gcc direkt auf Gnublin übersetzen, allerdings sollte man etwas Zeit mitbringen. Es wird ungefähr 30 Sekunden dauern. Diese lange Wartezeit entsteht durch die geringe Speichergrösse von 8 MByte. Der (riesige) gcc muss zum Kompilieren den Swap-Speicher auf der SD-Karte nutzen und das benötigt viel Zeit. Schneller geht es, wenn man die Kompilierung auf dem Hostrechner mit einem ARM Cross-Compiler erledigt und die ausführbare Datei anschliessend auf das Gnublin Board überträgt. In Zukunft soll es Gnublin auch mit 32 MByte Hauptspeicher geben, was die Zeit zum nativen Kompilieren erheblich reduzieren sollte.

Die Funktion get_adc() gibt die Anzahl der gelesenen Zeichen zurück (inklusive des '\n' Zeichen am Ende). Das C Programm benötigt für 1000 Lesevorgänge etwa 0,18 Sekunden, ist also ungefähr 5 Mal so schnell wie das Python Programm.