NIBObee-Berry

Aus Nibo Wiki
(Weitergeleitet von NIBObee/Berry)
Wechseln zu: Navigation, Suche

Info

NIBObee mit dem aufgesetzten Raspberry mit WLAN, Kamera und einer Powerbank als Stromquelle
Über die Berry-Erweiterung stehen 2 zusätzliche Schalter und 2 LEDs zur Verfügung, die nach Belieben Verwendung finden werden
Insgesamt hat unser Mega-Käfer jetzt drei Ebenen: NIBObee, Berry-Erweiterung und der Raspberry selbst

Mit dem Berry Modul kann ein NIBObee Roboter mit einem Raspberry Pi verbunden werden. Dadurch wird der Anschluss von nahezu beliebiger Sensorik (SPI, I2C, USB ...) möglich und zudem kann über den Raspberry via WLAN-Zugriff auf einen somit mobilen NIBObee zugegriffen werden.

Darüber hinaus stehen über den vollwertigen Linux-Computer, den der Raspberry darstellt, wesentlich komfortablere und zugleich komplexere Programmiermöglichkeiten zur Verfügung.

Das Berry-Modul enthält zudem einen integrierten DC/DC Wandler für die Spannungsversorgung des RPi, der mit einem weiten Spannungsbreich von 6,5 - 30 Volt umgehen kann. Dadurch können z.B. auch LiPo-Akkus etc. verwendet werden. Über einen (leider nicht enthaltenen und nur optionalen) 2. DC/DC-Wandler kann aus dem Berry-Akku auch der NIBObee mit Strom versorgt werden.

Der Rasperry Pi ist durch eine serielle Schnittstelle mit dem NIBObee verbunden.

Der Mikrocontroller im NIBObee kann dabei aus "ausführendes" Organ verstanden werden, während der Raspberry die Befehle erteilt.

Dadurch kann ggf. das neue eeprom-Flashen auf dem NIBObee bei Programmänderungen entfallen. Allerdings ist die Geschwindigkeit der Datenübertragung über die serielle Schnittstelle begrenzt, so dass die "reflexartigen" Funktionen ggf. besser "fest" im NIBObee-Controller verankert und die komplexen Funktionen im Raspberry umgesetzt werden sollten.




Fehlersuche, wenn es nach dem Zusammenbauen nicht klappt

nachgelötete Batterieclips

Sowohl beim NIBObee, als auch beim Berry-AddOn sind vereinzelt Probleme bei den Batterieclips bekannt. Die verklemmten Bereiche an den Enden sind in manchen Fällen nicht stromführend verquetscht, so dass die Geräte nicht mit Strom versorgt werden.

Dies lässt sich einfach nachmessen, in dem man die anliegenden Spannungen prüft.

  • beim NIBObee sollte an X8 bei eingelegten Batterien ca. 5V anliegen. Auch im ausgeschalteten Zustand.
  • bei der Berry-Platine sollte an X10 zwischen 1 und 4 eine Spannung von ca. 8V anliegen. Auch im ausgeschalteten Zustand.

Ein Nachlöten hilft hier leicht ab.

Aber Vorsicht! Auf jeden Fall die Akkus vorher entfernen, sonst werden die Clips durch den Federdruck und die Hitze beim Löten schnell irreparabel beschädigt!


Vorbereiten des Raspberry für die Kommunikation mit dem NIBObee

Der Raspberry wird typischerweise mit Raspberian betrieben, einer speziell angepassten Debian-Version für den Raspberry.

Die Grundinstallation des Raspberrys ist im Internet, z.B. hier, hinreichend beschrieben.

Es empfiehlt sich, ein Edimax-Nano-USB-WLAN-Stick gleich von Anfang an mit zu integrieren. Die Treiber bringt Raspberian bereits mit.

Die folgenden Arbeiten führen wir auf dem Raspberry aus, nachdem wir uns typischerweise mit einem SSH-Program (Linux: ssh, Windows: putty) nach der Grundeinrichtung mit dem Raspberry verbunden haben.

Wir werden im Folgenden mit Linux als unserem Hauptsystem arbeiten; die Beispiele sind dementsprechend aus Linux-Sicht.

Damit wir vollen Zugriff auf alle Funktionen und Rechte haben, werden wir mit dem root-Benutzer arbeiten.

Verbinden von unserem lokalen Rechner aus mit dem Raspberry:

user@localmachine:~# ssh root@[IP-ADRESSE-RASPBERRY]

Sollte das Login trotz korrektem Passwort nicht möglich sein, ist vermutlich das Verbinden als root nicht gestattet. Wir melden uns dann als pi, dem Standardbenutzer, an und verwandeln uns mit sudo su zu root:

user@localmachine:~# ssh pi@[IP-ADRESSE-RASPBERRY]    (defaultpasswort: raspberry)
root@nibo:~# sudo su
root@nibo:~#

Wir werden der Ordnung halber gleich unter dem Ordner /opt einen eigenen Ordner für unsere Projekte anlegen:

root@nibo:~# mkdir /opt/niboberry


Installation WiringPi / GPIO

Damit wir einfach die Ein- und Ausgänge des Rapsberry ansprechen können, installieren wir WiringPi, was nützliche Tools (gpio) und diverse Bibliotheken in C, C++, Python, Java und PHP mitbringt.

root@nibo:~# apt-get update
root@nibo:~# apt-get install git-core
root@nibo:~# cd /opt
root@nibo:/opt# git clone git://git.drogon.net/wiringPi
root@nibo:/opt# cd WiringPi
root@nibo:/opt/WiringPi# ./build


Test der Grundfunktion

Mit einem kleinen Script testen wir die Grundfunktionen der Raspberry-Addon-Platine.

Die Verdrahtung der Platine ist wie folgt:

Taster A: Pin 15 (wPi: 3)
Taster B: Pin 16 (wPi: 4)
LED grün: Pin 18 (wPi: 5)
LED  rot: Pin 22 (wPi: 6)

Da die Taster das Signal auf GND legen, benötigen wir als "Gegenstück" (quasi im ungedrückten Zustand) ein High-Signal. Wir stellen daher den internen Pull-Up-Wiederstand für die Eingänge ein.

gpio mode 3 up
gpio mode 4 up

Siehe Schaltplan Berry-Erweiterung.

Mit

root@nibo:~# gpio readall

bekommen wir alle Ports, Ein- und Ausgänge, derzeitige Zustände und die unterschiedlichen Namen angezeigt:

+-----+-----+---------+------+---+-Model B2-+---+------+---------+-----+-----+
| BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
|     |     |    3.3v |      |   |  1 || 2  |   |      | 5v      |     |     |
|   2 |   8 |   SDA.1 | ALT0 | 1 |  3 || 4  |   |      | 5V      |     |     |
|   3 |   9 |   SCL.1 | ALT0 | 1 |  5 || 6  |   |      | 0v      |     |     |
|   4 |   7 | GPIO. 7 |   IN | 1 |  7 || 8  | 1 | ALT0 | TxD     | 15  | 14  |
|     |     |      0v |      |   |  9 || 10 | 0 | ALT0 | RxD     | 16  | 15  |
|  17 |   0 | GPIO. 0 |   IN | 0 | 11 || 12 | 0 | IN   | GPIO. 1 | 1   | 18  |
|  27 |   2 | GPIO. 2 |   IN | 0 | 13 || 14 |   |      | 0v      |     |     |
|  22 |   3 | GPIO. 3 |   IN | 0 | 15 || 16 | 0 | IN   | GPIO. 4 | 4   | 23  |
|     |     |    3.3v |      |   | 17 || 18 | 0 | IN   | GPIO. 5 | 5   | 24  |
|  10 |  12 |    MOSI |   IN | 0 | 19 || 20 |   |      | 0v      |     |     |
|   9 |  13 |    MISO |   IN | 0 | 21 || 22 | 0 | IN   | GPIO. 6 | 6   | 25  |
|  11 |  14 |    SCLK |   IN | 0 | 23 || 24 | 1 | IN   | CE0     | 10  | 8   |
|     |     |      0v |      |   | 25 || 26 | 1 | IN   | CE1     | 11  | 7   |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
|  28 |  17 | GPIO.17 |   IN | 0 | 51 || 52 | 0 | IN   | GPIO.18 | 18  | 29  |
|  30 |  19 | GPIO.19 |   IN | 0 | 53 || 54 | 0 | IN   | GPIO.20 | 20  | 31  |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
| BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
+-----+-----+---------+------+---+-Model B2-+---+------+---------+-----+-----+

Dort erkennen wir auch, dass z.B. der physikalische Pin (Physical) 15 die WiringPi-(wPi)-Nummer 3 hat.

Wir legen das Skript in unserem neuen Ordner an:

root@nibo:~# cd /opt/niboberry
root@nibo:~# nano test.sh

Folgenden Code einfügen und mit [STRG-X] den Editor beenden und speichern:

#!/bin/sh

# Einstellen der Ports als Ein- bzw. Ausgang
gpio mode 3 in
gpio mode 3 up
gpio mode 4 in
gpio mode 4 up
gpio mode 5 out
gpio mode 6 out

# Abwechselndes Blinken der beiden LEDs
gpio write 5 0
gpio write 6 0
gpio write 5 1
sleep 0.5
gpio write 5 0
sleep 0.5
gpio write 6 1
sleep 0.5
gpio write 6 0

# Endlosschleife für Hauptfunktion
while [ True ]
 do
  if [ $(gpio read 3) = 0 ]
  # Taste 1 gedrückt
  then
    echo "Taster A"
    # LED 1 an
    gpio write 5 1
  else
    # LED 1 aus
    gpio write 5 0
  fi

  if [ $(gpio read 4) = 0 ]
  # Taste 2 gedrückt
  then
    echo "Taster B"
    # LED 2 an
    gpio write 6 1
  else
    # LED 2 aus
    gpio write 6 0
  fi

done

# Programmende (wird nie erreicht, da Endlosschleife)
exit 0

Dann die Datei ausführbar machen und starten:

root@nibo:~# chmod +x test.sh
root@nibo:~# ./test.sh

Die LED sollten nacheinander kurz aufleuchten, dann wartet das Script auf das Drücken der Taster.

Bei Druck auf Taster A, sollte nun die grüne LED leuchten. Bei Druck auf Taster B die rote LED.

Sollte das nicht funktionieren, je nach Problem die Platine und das Programm überprüfen.

Mit [STRG-C] beenden wir das Testprogramm.


Aufbau der seriellen Verbindung zum NIBObee

Auf der Raspberry-GPIO-Leiste sind die Pins 8 (TX, senden) und 10 (RX, empfangen) für die serielle Kommunikation vorgesehen.

Siehe Schaltplan Berry-Erweiterung.

Die serielle Schnittstelle wird vom Raspberry standardmäßig zur Bootprotokollierung verwendet.

Diese Funktion müssen wir daher zunächst deaktivieren.

In

/boot/cdmline.txt

muss diese Zeile angepasst werden:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Der Parameter mit Verweis auf ttyAMA0 muss entfernt werden.

Ergebnis:

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

In

/etc/inittab

müssen wir verhindern, dass eine Login-Konsole auf die serielle Schnittstelle gesetzt wird. Dazu muss der entsprechende Eintrag (in der Regel die letzte Zeile) mit einer # auskommentiert werden.

Hier das Ergebnis:

# T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Nach einem Reboot sollte uns die Schnittstelle nun zur Verfügung stehen.


Test

Um mit dem NiboBEE zu "sprechen" benötigen wir ein Terminalprogramm.

Viele stehen nach Belieben zur Verfügung. Für die Befehlszeile z.B.:

  • minicom
  • microcom
  • picocom

Installation von z.B. microcom mit:

apt-get update
apt-get install microcom

Nun können wir zum ersten Mal vom Raspberry aus mit den NiboBEE die Verbindung aufnehmen. Vorausgesetzt, alle Module sind betriebsbereit, miteinander verbunden und eingeschaltet.

microcom -p /dev/ttyAMA0 -s 9600

Wenn auf dem NiboBEE noch das bei der Auslieferung aufgespielte Testprogramm im Flash-Speicher ist, sendet er laufend auf der seriellen Schnittstelle Werte der optischen Sensoren. z.B.:

1a:1f:1a
21:26:22
21:26:22

Hält man nun den Finger rechts oder links unter den Sensor, ändern sich die Werte entsprechend.

Vorbereiten des Bees für die Kommunikation mit dem Rasp

Damit der Bee von dem Rasp über die serielle Schnittstelle Befehle annehmen und Daten senden kann, müssen diese miteinander kommunizieren und über eine "abgestimmten" Befehlssatz verfügen.

Der NIBObee ist bereits dementsprechend vorbereitet.

Dieser Befehlssatz nennt sich: Nibo Serial Protocol.


Programmierbeispiele

Wenn wir schon einen Linux-Computer auf dem NIBObee haben, wollen wir ihn natürlich auf möglichst umfassend nutzen.

Die Kommunikation mit dem NIBObee und dem Programmiercomputer erfolgt über die USB-Schnittstelle an der Frontseite des NIBObee. Hier können wir natürlich auch eine Verbindung mit unserem Raspberry herstellen.

Allerdings reagiert der Raspberry sehr empfindlich auf die Spannungsschwankungen, die beim Einstecken von USB-Geräten entstehen können. Am besten schaltet man daher beide Geräte, insbesondere aber den Raspberry, vor dem Zusammenstecken über USB aus.

Steht die Verbindung, haben wir die Möglichkeit, uns via WLAN und SSH auf den Raspberry zu schalten und dort direkt den verbundenen NiboBEE zu Programmieren.

Ob die USB-Verbindung steht, kann mit

lsusb

auf dem Raspberry festgestellt werden.

Der NIBObee wird wie folgt angezeigt:

Bus 001 Device 007: ID 16c0:05dc Van Ooijen Technische Informatica shared ID for use with libusb


Backup

Bevor wir eigene Programme auf den NIBObee aufspielen, sollten wir ggf. vorhandene Programme sichern.

Dazu benötigen wir, ebenso wie für das Übertragen unseres eigenen C-Codes, das Tool

avrdude

Dies installieren wir mit:

apt-get update
apt-get install avrdude


EEPROM

Hier befindet sich das vorinstallierte Betriebssystem des NIBObee, der alle wesentlichen Funktionen steuert und auch die serielle Kommunikation organisiert

Mit diesem Befehl kann ein Backup erstellt werden.

avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U eeprom:r:"BACKUPFILENAME.eeprom":i


Flash

Hier befinden sich die von uns Anwendern übertragenen Programme.

Die Sicherung erfolgt mit diesem Befehl:

avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U flash:r:"BACKUPFILENAME.flash":i


Fuses

In den "Fuses" verwaltet der ATMEL-Prozessor diverse Einstellungen. Diese sollten wir im Normalfall nicht ändern. Aber ein Backup kann auch hier nicht schaden. Es gibt "high"-, "low"- und die E-Fuses, die getrennt verwaltet und auch gesichert werden.

avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U hfuse:r:"BACKUPFILENAME.hfuse":b
avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U lfuse:r:"BACKUPFILENAME.lfuse":b
avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U efuse:r:"BACKUPFILENAME.efuse":b


Programmierumgebung gcc-avr

Bevor wir mit unserem ersten Programm loslegen können, benötigen wir den passenden C-Compiler für den AVR-Microcontroller.

Diesen installieren wir mit:

root@nibo:~# apt-get install gcc-avr avr-libc

Alternativ kann auch die [original Atmel-Toolchain] für 8-Bit-Prozessoren (der ATmega16A ist ein 8-Bit Microprozessor) verwenden. Z.B.:

Atmel AVR 8-bit Toolchain 3.5.1 - Linux 64-bit

Als Library habe ich die von [Stefan Frings] dem Original vorgezogen.

Testen ob alles soweit funktioniert, können wir mit dem Beispielcode, den Stefan mit seiner SFLIB beistellt.

Einfach in dem Ordner in dem auch die Datei Makefile liegt, den Befehl

make

absetzen. Die Ausgabe sollte ähnlich der folgenden sein.

[SFLIB_FOLDER]# make
[SFLIB_FOLDER]# avr-gcc -std=c99 -Os -Wall -mmcu=atmega16 -DF_CPU=15000000  -DUSE_SERIAL=1 -DBAUD=19200 -DTERMINAL_MODE=1 -DSERIAL_ECHO=0   -c -o prg_demo.o prg_demo.c
[SFLIB_FOLDER]# avr-gcc -std=c99 -Os -Wall -mmcu=atmega16 -DF_CPU=15000000  -DUSE_SERIAL=1 -DBAUD=19200 -DTERMINAL_MODE=1 -DSERIAL_ECHO=0   -c -o nibobee.o nibobee.c
[SFLIB_FOLDER]# avr-gcc -std=c99 -Os -Wall -mmcu=atmega16 -DF_CPU=15000000  -DUSE_SERIAL=1 -DBAUD=19200 -DTERMINAL_MODE=1 -DSERIAL_ECHO=0   -c -o fahren.o fahren.c
[SFLIB_FOLDER]# avr-gcc -std=c99 -Os -Wall -mmcu=atmega16 -DF_CPU=15000000  -DUSE_SERIAL=1 -DBAUD=19200 -DTERMINAL_MODE=1 -DSERIAL_ECHO=0   -c -o servo.o servo.c
[SFLIB_FOLDER]# avr-gcc -std=c99 -Os -Wall -mmcu=atmega16 -DF_CPU=15000000  -DUSE_SERIAL=1 -DBAUD=19200 -DTERMINAL_MODE=1 -DSERIAL_ECHO=0 -Wl,-Map,nibobee.map  -Wl,-u,vfprintf  [SFLIB_FOLDER]# -lprintf_min -lm -o nibobee.elf prg_demo.o nibobee.o fahren.o servo.o 
[SFLIB_FOLDER]# avr-objcopy -j .text -j .data -O ihex nibobee.elf nibobee.hex
[SFLIB_FOLDER]# avr-size nibobee.elf
[SFLIB_FOLDER]#    text    data     bss     dec     hex filename
[SFLIB_FOLDER]#    7314      16      97    7427    1d03 nibobee.elf
[SFLIB_FOLDER]#

Kommt es zu einer Fehlerbeldung bitte zunächst prüfen, ob die nötige avr-libc installiert ist.

Mit

make program

könnten wir das Programm in den Flash-Speicher unseres NiboBEEs übertragen lassen, wenn dieser per USB angebunden ist.

Mit

make clean

können wir die kompilierten Programme wieder löschen.

Hello World

Für unser 1. eigenes Programm legen wir einen eigenen Ordner an und kopieren die folgenden Daten der SFLIB hinein:

Makefile  nibobee.c  nibobee.h

Unser erstes eigene Programm legen wir in der Datei test1.c ab:


Nun müssen wir noch das Makefile dementsprechend anpassen:

Zeile 12 bitte ändern zu:

SRC = test1.c nibobee.c

Damit werden wir make mitteilen, welche Dateien es kompilieren soll.

Nun mit einem

make

testen, ob alles funktioniert. Anschließend kann das Programm mit

make program

auf den NiboBEE übertragen werden.


---Work in progress---

Nutzen der Spannungsüberwachung

---Idee---

Ein 1kHz-PWM-Signal mit 14% duty cycle erzeugt an GPIO18 (RP_PWM) ca. 0,6V. Diese Spannung vergleicht die Op-Amp-Schaltung mit einem 10tel der Batteriespannung. Sinkt die Spannung also unter 6V, reagiert unsere Schaltung mit einem auf HIGH gesetzten GPIO4.

---Work in progress---


Linienverfolger mit Fotofunktion

---Work in progress---