Mikrocontroller.net - Benutzerbeiträge [de]

Datei:SC 4AOS1.JPG

2013-06-22T21:53:39Z

Mknot9: hat eine neue Version von „Datei:SC 4AOS1.JPG“ hochgeladen: smaller file

picture of arduino running 4aOS, using the command line to navigate through the folders

Datei:SC 4AOS1.JPG

2013-06-22T20:14:07Z

Mknot9: picture of arduino running 4aOS, using the command line to navigate through the folders

picture of arduino running 4aOS, using the command line to navigate through the folders

Arduino

2013-03-25T00:34:34Z

Mknot9: /* 8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin */

{{Wettbewerb Header}}

Das Arduino-Projekt ist ein 2006 gestartetes Projekt aus Italien. Arduino
ist eine Zusammenstellung aus verschiedenen Boards und einer IDE. Die Boards basieren auf der Atmel-AVR Serie. Die einzige ausnahme bildet der Arduino Due, dieser basiert auf einem ARM-Chip von Atmel. Das Gesamt Projekt ist quelloffen,
also Open-Source. Der Unterschied zu anderen Atmel-Boards sind der Bootloader und die IDE. Der Bootloader wird durch das Arduino-Projekt entwickelt und ist für die einzelnen Boards spezifisch.

==Die IDE==
Die Arduino-IDE ist eine in JAVA programmierte grafische Obrfläche. Dadurch das sie in JAVA programiert wurde, ist sie plattfomunabhägig und auf Windows, Linux, MacOS X und Solaris verfügbar.
Die Grafischeoberfläche compiliert die Sketche(so heißt ein Arduino-Programm offiziel) nicht, sondern ruft verschiedene Programme auf. Dies sind in der Regel der Compiler avr-g++(und zugehörige Programme, z.B. ein Linker) und avrdude,
ein Programm zum übertragen des compilierten Sketch als *.hex File auf den Flashspeicher des Arduino. Die IDE basiert auf der Processing IDE und Wiring.

==Die Boards==
Die Arduino-Boards sind Atmel AVR/ARM Chips basierende Mikrocontrollerplatinen,
welche zur Steuerung von I/O-Pins gedacht sind. Im Gegensatz zu anderen Boards sind die Arduino-Boards nicht gedacht um als "Computer" mit Betriebssystem zu dienen, wie etwa der Raspberry Pi, sondern um die I/O Pins zu steuern. Es gibt insgesamt 14 Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meisten ein USB-Aschluß(USB-B bzw. USB-Mini) oder eine Schnitstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip intigriert,
meist ein FTDI-Chip bei älteren Boards oder ein 8U2/16U2 bei neueren Boards.Eine Ausnahme bildet hier der Arduino Leonardo: Dieser besitzt einen Atmel-AVR 32U4 Mikrocontroller, welcher auch die Funktionen eines FTDI-Chips besitzt. Es ist also kein weiterer Konverter nötig.

===Arduino Uno===
Der Arduino Uno R3 ist der Standard-Arduino. In den meisten Anfänger-Bücher und Tutorials wird dieser Arduino verwendet. Auch sind die meisten Libaries für ihn geschrieben. Er ist der neuste der am längsten weiterentwickleten Arduino-Reihe.
So ist eine frühere Version des Arduino Uno (Arduino USB) das Board gewesen, welches als erstes ''Arduino'' gennant wurde. In der aktuellen Revision (Version) 3 besitzt der Uno 14 Digitale I/O Pins sowie 6 analoge Eingänge. Er wird bei 5V betrieben und besitzt folgende Speicherkapazitäten:
* 32K Flash(0,5 werden vom Bootloader verwendet.)
* 2K SRAM
* 1K EEPROM
* 16 MHz (Prozessortakt)
Neben dem USB-B Anschluß verfügt der Uno noch über folgende Anschlüsse:
* Klinkenbuchse (2.1mm , 6-20 V möglich)
* SPI
* I²C
* ICSP

====Arduino Duemilanove====
Der Arduino Duemilanove ist der Vorgänger des Arduino Uno. Er besitzt den
ATmega168 (seit 2009 328p) statt dem 328 wie beim Uno. Als Konverter verwendet der Duemilianove eine FTDI-Chip anstelle eines 16U2. Sonst ist von der Pin anzahlen und den Maßen des Boards identisch mit denen des Uno.

====Arduino Diecimila====
====Arduino NG====
====Arduino Usb====

===Arduino Mega===
====Arduino Mega ADK====
===Arduino Due===

===Arduino Ethernet===
===Arduino LilyPad===
===Arduino Leonardo===
===Arduino Nano===
===Arduino Micro===
===Arduino Fio===
===Arduino Pro Mini===
====Arduino Mini====
===Arduino Pro===

==Shields(Erweiterungsplatinen)==
Sogennante Shields sind Erweiterungsplatinen, die die Funktionen eines Arduino-Boards um neue Funktionen erweitern. So gibt es z.B. Shields die den Arduino um eine Ethernet-Schnittstelle erweitern, einen VGA-Aschluß besitzen oder einfach leere Platinen sind, auf die eine Chip eingesetzt werden kann, ohne zu Löten. Für das letztere Bsp. wäre eine solche Platine die XBEE-Antenne.

===8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin===

Seit ca. Herbst 2012 werden einige LCD-Shields mit Touch-Controller angeboten, die den IRQ-Pin nicht mehr durchschleifen.

Damit läuft auch die U-Touch Bibliothek von Henning Carlsen nicht mehr. Alle Sample-Codes im Web funktionieren auch nicht. Das Problem besteht darin herauszufinden, mit welchem Arduino-Pin das CS-Signal verbunden ist. Hier hilft nur: Sheets studieren.

Beim Austesten des Touch-Shields ergab sich bei mir zusätzlich ein y-Basiswert des Touchcontrollers von 4095 ('kein Touch') und eine Differenz der Widerstandswerte zwischen 'Touch' und 'keine Touch' von 180 (x) bzw. 240 (y), siehe Code-Kommentare.

Bei mir lief schließlich folgender Code (das CS-Signal lag auf Pin 10):
<c>
#define LCD_RS 19
#define LCD_WR 18
#define LCD_CS 17
#define LCD_REST 16

#define DCLK 15
#define DIN 14
#define CS 10
#define DOUT 8

//#define IRQ 7

unsigned int TP_X,TP_Y,x0,y0;
unsigned int l3=0;
int lx,ly, l2, ry,rx,x3=65,y3=318;
int k=3, vh2=0x84,vl2=0xFF;

void spistar() //SPI Start
{
digitalWrite(CS,LOW);
digitalWrite(DCLK,HIGH);
digitalWrite(DIN,HIGH);
digitalWrite(DCLK,HIGH);

}
//**********************************************************
void WriteCharTo7843(unsigned char num) //SPI Write Data
{
unsigned char count=0;
unsigned char temp;
unsigned nop;
temp=num;
digitalWrite(DCLK,LOW);
for(count=0;count<8;count++)
{
if(temp&0x80)
digitalWrite(DIN,HIGH);
else
digitalWrite(DIN,LOW);

temp=temp<<1;

digitalWrite(DCLK,LOW);
nop++;
nop++;
digitalWrite(DCLK,HIGH);
nop++;
nop++;
}
}

//**********************************************************
unsigned int ReadFromCharFrom7843() //SPI Read Data
{
unsigned nop;
unsigned char count=0;
unsigned int Num=0;
for(count=0;count<12;count++)
{
Num<<=1;
digitalWrite(DCLK,HIGH);//DCLK=1; _nop_();_nop_();_nop_();
nop++;
digitalWrite(DCLK,LOW);//DCLK=0; _nop_();_nop_();_nop_();
nop++;
if(digitalRead(DOUT)) Num++;
}
return(Num);
}

void LCD_Writ_Bus(char VH,char VL)
{
PORTD = VH;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
PORTD = VL;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
}

void LCD_Write_COM(char VH,char VL)
{
digitalWrite(LCD_RS,LOW);
LCD_Writ_Bus(VH,VL);
}

void LCD_Write_DATA(char VH,char VL)
{
digitalWrite(LCD_RS,HIGH);
LCD_Writ_Bus(VH,VL);
}

void Lcd_Write_Com_Data(int com,int val)
{
LCD_Write_COM(com>>8,com);
LCD_Write_DATA(val>>8,val);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
LCD_Write_COM(0x00,0x46);LCD_Write_DATA(x2,x1);
LCD_Write_COM(0x00,0x47);LCD_Write_DATA(y2>>8,y2);
LCD_Write_COM(0x00,0x48);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x20);LCD_Write_DATA(x1>>8,x1);
LCD_Write_COM(0x00,0x21);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x22);
}

void LCD_Init(void)
{

digitalWrite(LCD_REST,HIGH);
delay(5);
digitalWrite(LCD_REST,LOW);
delay(5);
digitalWrite(LCD_REST,HIGH);
delay(5);

digitalWrite(LCD_CS,LOW);
Lcd_Write_Com_Data(0x11,0x2004);
Lcd_Write_Com_Data(0x13,0xCC00);
Lcd_Write_Com_Data(0x15,0x2600);
Lcd_Write_Com_Data(0x14,0x252A);
Lcd_Write_Com_Data(0x12,0x0033);
Lcd_Write_Com_Data(0x13,0xCC04);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC06);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC4F);
delay(1);
Lcd_Write_Com_Data(0x13,0x674F);
Lcd_Write_Com_Data(0x11,0x2003);
delay(1);
Lcd_Write_Com_Data(0x30,0x2609);
Lcd_Write_Com_Data(0x31,0x242C);
Lcd_Write_Com_Data(0x32,0x1F23);
Lcd_Write_Com_Data(0x33,0x2425);
Lcd_Write_Com_Data(0x34,0x2226);
Lcd_Write_Com_Data(0x35,0x2523);
Lcd_Write_Com_Data(0x36,0x1C1A);
Lcd_Write_Com_Data(0x37,0x131D);
Lcd_Write_Com_Data(0x38,0x0B11);
Lcd_Write_Com_Data(0x39,0x1210);
Lcd_Write_Com_Data(0x3A,0x1315);
Lcd_Write_Com_Data(0x3B,0x3619);
Lcd_Write_Com_Data(0x3C,0x0D00);
Lcd_Write_Com_Data(0x3D,0x000D);
Lcd_Write_Com_Data(0x16,0x0007);
Lcd_Write_Com_Data(0x02,0x0013);
Lcd_Write_Com_Data(0x03,0x0003);
Lcd_Write_Com_Data(0x01,0x0127);
delay(1);
Lcd_Write_Com_Data(0x08,0x0303);
Lcd_Write_Com_Data(0x0A,0x000B);
Lcd_Write_Com_Data(0x0B,0x0003);
Lcd_Write_Com_Data(0x0C,0x0000);
Lcd_Write_Com_Data(0x41,0x0000);
Lcd_Write_Com_Data(0x50,0x0000);
Lcd_Write_Com_Data(0x60,0x0005);
Lcd_Write_Com_Data(0x70,0x000B);
Lcd_Write_Com_Data(0x71,0x0000);
Lcd_Write_Com_Data(0x78,0x0000);
Lcd_Write_Com_Data(0x7A,0x0000);
Lcd_Write_Com_Data(0x79,0x0007);
Lcd_Write_Com_Data(0x07,0x0051);
delay(1);
Lcd_Write_Com_Data(0x07,0x0053);
Lcd_Write_Com_Data(0x79,0x0000);

LCD_Write_COM(0x00,0x22);
digitalWrite(LCD_CS,HIGH);

}

void Pant(char VH,char VL)
{
int i,j;
Address_set(0,0,240,320);
for(i=0;i<=320;i++)
{
for (j=0;j<=240;j++)
{
LCD_Write_DATA(VH,VL);
}
}
}

void digi(int z3)
{
unsigned char p;
int x2, y2, z2, i,h2=1000;
digitalWrite(LCD_CS,LOW);
for(i=0;i<3;i++)
{
y2=y3;
x2=x3+(10*i);
Address_set(x2+6,y2-15,x2+7,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+7,y2-14);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-1,x2+7,y2);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-8,x2+7,y2-7);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+1,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);

h2=h2/10;
z2=z3/h2;
z3=z3-z2*h2;
if (z2==0) {
Address_set(x2+2,y2-8,x2+5,y2-7);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==1) {
Address_set(x2,y2-15,x2+5,y2);
for(p=0; p<96; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==2) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+6,y2-6,x2+7,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==3) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==4) {
Address_set(x2,y2-6,x2+5,y2);
for(p=0; p<42; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+2,y2-15,x2+5,y2-14);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==5) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==6) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==7) {
Address_set(x2,y2-13,x2+5,y2);
for(p=0; p<84; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==9) {
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
}

digitalWrite(LCD_CS,HIGH);
}

void newpa(void)
{
unsigned char p;
digitalWrite(LCD_CS,LOW);
Pant(0x00,0x00);

Address_set(0,319,240,319);
for(p=0; p<240; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,0,240,0);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,300,240,300);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,0,0,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,255,0,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,0,239,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,255,239,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(50,308,59,311);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(53,305,56,314);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(215,305,239,314);
for(p=0; p<250; p++) LCD_Write_DATA(0xF8,0x00);
digitalWrite(LCD_CS,HIGH);

}

void recan(void)
{
int i,j;
// unsigned int m;
digitalWrite(LCD_CS,LOW);
for(i=0;i<7;i++)
{
// m=i*3;
Address_set(i*5,305,i*5+3,314);
for(j=0; j<40; j++)
{
if (1+i*2<= k) LCD_Write_DATA(0xFF,0xE0); else LCD_Write_DATA(0x00,0x00);
}
}
Address_set(100,305,124,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
Address_set(125,305,149,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}

void AD7843(void)
{
digitalWrite(CS,LOW);
WriteCharTo7843(0x90);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_Y=ReadFromCharFrom7843();
WriteCharTo7843(0xD0);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_X=ReadFromCharFrom7843();
digitalWrite(CS,HIGH);

}

void setup()
{

unsigned char p;

for(p=0;p<20;p++)
{
pinMode(p,OUTPUT);
}
pinMode(DOUT,INPUT);
x0=1;
y0=1;

LCD_Init();
newpa();
recan();
digi(vh2);
x3=x3+90;
digi(vl2);
spistar();
}

void loop()
{
rx=0;
ry=0;

for(l3=0;l3<8;l3++)
{
AD7843();

lx=0;
ly=-1*TP_Y;
ly=4095+ly; //4095=Basiswert y-Signal
if(ly > 0) lx=1*TP_X; else {lx=0;ly=0;rx=0;ry=0;l3=9; }
rx=rx+lx;
ry=ry+ly;
}
lx=(rx/8-180)/15; //180=Minimaler x-Wert bei 'Touch'
ly=(ry/8-240)/11; //240=Minimaler (über 4095) y-Wert bei 'Touch'
if(ly < 1) {lx=0;ly=0; }
if(lx < 1) lx=0;

if(ly > 309-k)
{
ly=0;
if(lx > 200) k=k-2; else if (lx > 160) k=k+2;else
if (lx > 100) vh2++; else if (lx > 40) vl2++; else newpa();
lx=0;
if (k<1) k=1;
if (k>13) k=13;
if (vh2>255) vh2=0;
if (vl2>255) vl2=0;
x3=65;
digi(vh2);
x3=x3+90;
digi(vl2);
recan();
}

if(ly > 299-k) ly=299-k;
if(ly > 0)
{
x0=240-lx;
if(x0 > 240-k) x0=240-k;
y0=ly;
l2=(k+1)*(k+1);
digitalWrite(LCD_CS,LOW);
Address_set(x0,y0,x0+k,y0+k);
for (l3=0; l3<l2; l3++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}
delay (50);
}
</c>

==Derivate==
Es gibt viele Derivate die auf dem Arduino basieren, weil
* Alle Layouts quelloffen im Internet stehen
* Der Bootloader sowohl als Quellocde und schon compillert zum Download im Internet stehen
*Man die IDE für alle Atmel-Chips verwenden kann, die einen Arduino-Bootloader besitzen
*Man auch eine Arduino-Derivat auf dem Steckbrett zusammbauen kann

==Tutorial==
===Ein erster Sketch: Blinkende LED===
Die meisten aktuellen Arduino-Boards habe einen fest verlötete
SMD-LED, welche an Pin 13 angeschloßen ist. Diese LED kann von jedem
Sketch angesteuert werden. Da diese LED meistens vorhanden ist und immer an Pin 13 ageschloßen ist, ist dieses Programm auf den meisten Boards gleich.
<c>
//Blinkende LED
void setup() {
pinMode(13,OUTPUT);
}

void loop() {
delay(1000);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
}
</c>

== Downloads ==
* [http://www.arduino.cc/en/Main/Software Download der IDE]
* [http://www.mikrocontroller.net/articles/AVR Artikel zur AVR Prozessor-Serie]

==Literatur==
* Erik Bartmann: ''Die elektronische Welt mit Arduino entdecken'', O'Reilly Verlag, 2011, ISBN 978-3-89721-319-7
* Thomas Brühlmann: ''Arduino: Praxiseinstieg'', mitp Verlag, 2010, ISBN 978-3-8266-5605-7

==Bezugsquellen(Auswahl)==

===Offiziele Boards===
* [http://www.watterott.com/de/Boards-Kits/Arduino Watterott.com]
* [http://www.reichelt.de/ Reichelt.de]
* [http://www.conrad.de/ Conrad.de]
* [http://www.tigal.com/ TIGAL.com]

===Lernpakete===
* [http://www.franzis.de/ Franzis Verlag(Lernpakete)]

== Siehe auch ==
* [http://www.arduino.cc/ Website des Arduino-Projekt]
* [http://arduino.cc/forum/index.php/board,31.0.html Deutsches Arduino-Forum(offiziel)]

[[Kategorie:AVR-Boards]]
[[Kategorie:Wettbewerb]]

Arduino

2013-03-25T00:30:57Z

Mknot9: /* 8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin */

{{Wettbewerb Header}}

Das Arduino-Projekt ist ein 2006 gestartetes Projekt aus Italien. Arduino
ist eine Zusammenstellung aus verschiedenen Boards und einer IDE. Die Boards basieren auf der Atmel-AVR Serie. Die einzige ausnahme bildet der Arduino Due, dieser basiert auf einem ARM-Chip von Atmel. Das Gesamt Projekt ist quelloffen,
also Open-Source. Der Unterschied zu anderen Atmel-Boards sind der Bootloader und die IDE. Der Bootloader wird durch das Arduino-Projekt entwickelt und ist für die einzelnen Boards spezifisch.

==Die IDE==
Die Arduino-IDE ist eine in JAVA programmierte grafische Obrfläche. Dadurch das sie in JAVA programiert wurde, ist sie plattfomunabhägig und auf Windows, Linux, MacOS X und Solaris verfügbar.
Die Grafischeoberfläche compiliert die Sketche(so heißt ein Arduino-Programm offiziel) nicht, sondern ruft verschiedene Programme auf. Dies sind in der Regel der Compiler avr-g++(und zugehörige Programme, z.B. ein Linker) und avrdude,
ein Programm zum übertragen des compilierten Sketch als *.hex File auf den Flashspeicher des Arduino. Die IDE basiert auf der Processing IDE und Wiring.

==Die Boards==
Die Arduino-Boards sind Atmel AVR/ARM Chips basierende Mikrocontrollerplatinen,
welche zur Steuerung von I/O-Pins gedacht sind. Im Gegensatz zu anderen Boards sind die Arduino-Boards nicht gedacht um als "Computer" mit Betriebssystem zu dienen, wie etwa der Raspberry Pi, sondern um die I/O Pins zu steuern. Es gibt insgesamt 14 Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meisten ein USB-Aschluß(USB-B bzw. USB-Mini) oder eine Schnitstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip intigriert,
meist ein FTDI-Chip bei älteren Boards oder ein 8U2/16U2 bei neueren Boards.Eine Ausnahme bildet hier der Arduino Leonardo: Dieser besitzt einen Atmel-AVR 32U4 Mikrocontroller, welcher auch die Funktionen eines FTDI-Chips besitzt. Es ist also kein weiterer Konverter nötig.

===Arduino Uno===
Der Arduino Uno R3 ist der Standard-Arduino. In den meisten Anfänger-Bücher und Tutorials wird dieser Arduino verwendet. Auch sind die meisten Libaries für ihn geschrieben. Er ist der neuste der am längsten weiterentwickleten Arduino-Reihe.
So ist eine frühere Version des Arduino Uno (Arduino USB) das Board gewesen, welches als erstes ''Arduino'' gennant wurde. In der aktuellen Revision (Version) 3 besitzt der Uno 14 Digitale I/O Pins sowie 6 analoge Eingänge. Er wird bei 5V betrieben und besitzt folgende Speicherkapazitäten:
* 32K Flash(0,5 werden vom Bootloader verwendet.)
* 2K SRAM
* 1K EEPROM
* 16 MHz (Prozessortakt)
Neben dem USB-B Anschluß verfügt der Uno noch über folgende Anschlüsse:
* Klinkenbuchse (2.1mm , 6-20 V möglich)
* SPI
* I²C
* ICSP

====Arduino Duemilanove====
Der Arduino Duemilanove ist der Vorgänger des Arduino Uno. Er besitzt den
ATmega168 (seit 2009 328p) statt dem 328 wie beim Uno. Als Konverter verwendet der Duemilianove eine FTDI-Chip anstelle eines 16U2. Sonst ist von der Pin anzahlen und den Maßen des Boards identisch mit denen des Uno.

====Arduino Diecimila====
====Arduino NG====
====Arduino Usb====

===Arduino Mega===
====Arduino Mega ADK====
===Arduino Due===

===Arduino Ethernet===
===Arduino LilyPad===
===Arduino Leonardo===
===Arduino Nano===
===Arduino Micro===
===Arduino Fio===
===Arduino Pro Mini===
====Arduino Mini====
===Arduino Pro===

==Shields(Erweiterungsplatinen)==
Sogennante Shields sind Erweiterungsplatinen, die die Funktionen eines Arduino-Boards um neue Funktionen erweitern. So gibt es z.B. Shields die den Arduino um eine Ethernet-Schnittstelle erweitern, einen VGA-Aschluß besitzen oder einfach leere Platinen sind, auf die eine Chip eingesetzt werden kann, ohne zu Löten. Für das letztere Bsp. wäre eine solche Platine die XBEE-Antenne.

===8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin===

Seit ca. Herbst 2012 werden einige LCD-Shields mit Touch-Controller angeboten, die den IRQ-Pin nicht mehr durchschleifen.

Damit läuft auch die U-Touch Bibliothek von Henning Carlsen nicht mehr. Alle Sample-Codes im Web funktionieren auch nicht. Das Problem besteht darin herauszufinden, mit welchem Arduino-Pin das CS-Signal verbunden ist. Hier hilft nur Sheets studieren. Beim Austesten des Touch-Shields ergab sich bei mir eine y-Basiswert des Touchcontrollers von 4095 und eine Differenz der Widerstandswerte zwischen 'Touch' und 'keine Touch' von 180 (x) bzw. 240 (y), siehe Code-Kommentare.

Bei mir lief schließlich folgender Code (das CS-Signal lag auf Pin 10):
<c>
#define LCD_RS 19
#define LCD_WR 18
#define LCD_CS 17
#define LCD_REST 16

#define DCLK 15
#define DIN 14
#define CS 10
#define DOUT 8

//#define IRQ 7

unsigned int TP_X,TP_Y,x0,y0;
unsigned int l3=0;
int lx,ly, l2, ry,rx,x3=65,y3=318;
int k=3, vh2=0x84,vl2=0xFF;

void spistar() //SPI Start
{
digitalWrite(CS,LOW);
digitalWrite(DCLK,HIGH);
digitalWrite(DIN,HIGH);
digitalWrite(DCLK,HIGH);

}
//**********************************************************
void WriteCharTo7843(unsigned char num) //SPI Write Data
{
unsigned char count=0;
unsigned char temp;
unsigned nop;
temp=num;
digitalWrite(DCLK,LOW);
for(count=0;count<8;count++)
{
if(temp&0x80)
digitalWrite(DIN,HIGH);
else
digitalWrite(DIN,LOW);

temp=temp<<1;

digitalWrite(DCLK,LOW);
nop++;
nop++;
digitalWrite(DCLK,HIGH);
nop++;
nop++;
}
}

//**********************************************************
unsigned int ReadFromCharFrom7843() //SPI Read Data
{
unsigned nop;
unsigned char count=0;
unsigned int Num=0;
for(count=0;count<12;count++)
{
Num<<=1;
digitalWrite(DCLK,HIGH);//DCLK=1; _nop_();_nop_();_nop_();
nop++;
digitalWrite(DCLK,LOW);//DCLK=0; _nop_();_nop_();_nop_();
nop++;
if(digitalRead(DOUT)) Num++;
}
return(Num);
}

void LCD_Writ_Bus(char VH,char VL)
{
PORTD = VH;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
PORTD = VL;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
}

void LCD_Write_COM(char VH,char VL)
{
digitalWrite(LCD_RS,LOW);
LCD_Writ_Bus(VH,VL);
}

void LCD_Write_DATA(char VH,char VL)
{
digitalWrite(LCD_RS,HIGH);
LCD_Writ_Bus(VH,VL);
}

void Lcd_Write_Com_Data(int com,int val)
{
LCD_Write_COM(com>>8,com);
LCD_Write_DATA(val>>8,val);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
LCD_Write_COM(0x00,0x46);LCD_Write_DATA(x2,x1);
LCD_Write_COM(0x00,0x47);LCD_Write_DATA(y2>>8,y2);
LCD_Write_COM(0x00,0x48);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x20);LCD_Write_DATA(x1>>8,x1);
LCD_Write_COM(0x00,0x21);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x22);
}

void LCD_Init(void)
{

digitalWrite(LCD_REST,HIGH);
delay(5);
digitalWrite(LCD_REST,LOW);
delay(5);
digitalWrite(LCD_REST,HIGH);
delay(5);

digitalWrite(LCD_CS,LOW);
Lcd_Write_Com_Data(0x11,0x2004);
Lcd_Write_Com_Data(0x13,0xCC00);
Lcd_Write_Com_Data(0x15,0x2600);
Lcd_Write_Com_Data(0x14,0x252A);
Lcd_Write_Com_Data(0x12,0x0033);
Lcd_Write_Com_Data(0x13,0xCC04);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC06);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC4F);
delay(1);
Lcd_Write_Com_Data(0x13,0x674F);
Lcd_Write_Com_Data(0x11,0x2003);
delay(1);
Lcd_Write_Com_Data(0x30,0x2609);
Lcd_Write_Com_Data(0x31,0x242C);
Lcd_Write_Com_Data(0x32,0x1F23);
Lcd_Write_Com_Data(0x33,0x2425);
Lcd_Write_Com_Data(0x34,0x2226);
Lcd_Write_Com_Data(0x35,0x2523);
Lcd_Write_Com_Data(0x36,0x1C1A);
Lcd_Write_Com_Data(0x37,0x131D);
Lcd_Write_Com_Data(0x38,0x0B11);
Lcd_Write_Com_Data(0x39,0x1210);
Lcd_Write_Com_Data(0x3A,0x1315);
Lcd_Write_Com_Data(0x3B,0x3619);
Lcd_Write_Com_Data(0x3C,0x0D00);
Lcd_Write_Com_Data(0x3D,0x000D);
Lcd_Write_Com_Data(0x16,0x0007);
Lcd_Write_Com_Data(0x02,0x0013);
Lcd_Write_Com_Data(0x03,0x0003);
Lcd_Write_Com_Data(0x01,0x0127);
delay(1);
Lcd_Write_Com_Data(0x08,0x0303);
Lcd_Write_Com_Data(0x0A,0x000B);
Lcd_Write_Com_Data(0x0B,0x0003);
Lcd_Write_Com_Data(0x0C,0x0000);
Lcd_Write_Com_Data(0x41,0x0000);
Lcd_Write_Com_Data(0x50,0x0000);
Lcd_Write_Com_Data(0x60,0x0005);
Lcd_Write_Com_Data(0x70,0x000B);
Lcd_Write_Com_Data(0x71,0x0000);
Lcd_Write_Com_Data(0x78,0x0000);
Lcd_Write_Com_Data(0x7A,0x0000);
Lcd_Write_Com_Data(0x79,0x0007);
Lcd_Write_Com_Data(0x07,0x0051);
delay(1);
Lcd_Write_Com_Data(0x07,0x0053);
Lcd_Write_Com_Data(0x79,0x0000);

LCD_Write_COM(0x00,0x22);
digitalWrite(LCD_CS,HIGH);

}

void Pant(char VH,char VL)
{
int i,j;
Address_set(0,0,240,320);
for(i=0;i<=320;i++)
{
for (j=0;j<=240;j++)
{
LCD_Write_DATA(VH,VL);
}
}
}

void digi(int z3)
{
unsigned char p;
int x2, y2, z2, i,h2=1000;
digitalWrite(LCD_CS,LOW);
for(i=0;i<3;i++)
{
y2=y3;
x2=x3+(10*i);
Address_set(x2+6,y2-15,x2+7,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+7,y2-14);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-1,x2+7,y2);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-8,x2+7,y2-7);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+1,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);

h2=h2/10;
z2=z3/h2;
z3=z3-z2*h2;
if (z2==0) {
Address_set(x2+2,y2-8,x2+5,y2-7);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==1) {
Address_set(x2,y2-15,x2+5,y2);
for(p=0; p<96; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==2) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+6,y2-6,x2+7,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==3) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==4) {
Address_set(x2,y2-6,x2+5,y2);
for(p=0; p<42; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+2,y2-15,x2+5,y2-14);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==5) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==6) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==7) {
Address_set(x2,y2-13,x2+5,y2);
for(p=0; p<84; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==9) {
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
}

digitalWrite(LCD_CS,HIGH);
}

void newpa(void)
{
unsigned char p;
digitalWrite(LCD_CS,LOW);
Pant(0x00,0x00);

Address_set(0,319,240,319);
for(p=0; p<240; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,0,240,0);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,300,240,300);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,0,0,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,255,0,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,0,239,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,255,239,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(50,308,59,311);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(53,305,56,314);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(215,305,239,314);
for(p=0; p<250; p++) LCD_Write_DATA(0xF8,0x00);
digitalWrite(LCD_CS,HIGH);

}

void recan(void)
{
int i,j;
// unsigned int m;
digitalWrite(LCD_CS,LOW);
for(i=0;i<7;i++)
{
// m=i*3;
Address_set(i*5,305,i*5+3,314);
for(j=0; j<40; j++)
{
if (1+i*2<= k) LCD_Write_DATA(0xFF,0xE0); else LCD_Write_DATA(0x00,0x00);
}
}
Address_set(100,305,124,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
Address_set(125,305,149,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}

void AD7843(void)
{
digitalWrite(CS,LOW);
WriteCharTo7843(0x90);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_Y=ReadFromCharFrom7843();
WriteCharTo7843(0xD0);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_X=ReadFromCharFrom7843();
digitalWrite(CS,HIGH);

}

void setup()
{

unsigned char p;

for(p=0;p<20;p++)
{
pinMode(p,OUTPUT);
}
pinMode(DOUT,INPUT);
x0=1;
y0=1;

LCD_Init();
newpa();
recan();
digi(vh2);
x3=x3+90;
digi(vl2);
spistar();
}

void loop()
{
rx=0;
ry=0;

for(l3=0;l3<8;l3++)
{
AD7843();

lx=0;
ly=-1*TP_Y;
ly=4095+ly; //4095=Basiswert y-Signal
if(ly > 0) lx=1*TP_X; else {lx=0;ly=0;rx=0;ry=0;l3=9; }
rx=rx+lx;
ry=ry+ly;
}
lx=(rx/8-180)/15; //180=Minimaler x-Wert bei 'Touch'
ly=(ry/8-240)/11; //240=Minimaler (über 4095) y-Wert bei 'Touch'
if(ly < 1) {lx=0;ly=0; }
if(lx < 1) lx=0;

if(ly > 309-k)
{
ly=0;
if(lx > 200) k=k-2; else if (lx > 160) k=k+2;else
if (lx > 100) vh2++; else if (lx > 40) vl2++; else newpa();
lx=0;
if (k<1) k=1;
if (k>13) k=13;
if (vh2>255) vh2=0;
if (vl2>255) vl2=0;
x3=65;
digi(vh2);
x3=x3+90;
digi(vl2);
recan();
}

if(ly > 299-k) ly=299-k;
if(ly > 0)
{
x0=240-lx;
if(x0 > 240-k) x0=240-k;
y0=ly;
l2=(k+1)*(k+1);
digitalWrite(LCD_CS,LOW);
Address_set(x0,y0,x0+k,y0+k);
for (l3=0; l3<l2; l3++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}
delay (50);
}
</c>

==Derivate==
Es gibt viele Derivate die auf dem Arduino basieren, weil
* Alle Layouts quelloffen im Internet stehen
* Der Bootloader sowohl als Quellocde und schon compillert zum Download im Internet stehen
*Man die IDE für alle Atmel-Chips verwenden kann, die einen Arduino-Bootloader besitzen
*Man auch eine Arduino-Derivat auf dem Steckbrett zusammbauen kann

==Tutorial==
===Ein erster Sketch: Blinkende LED===
Die meisten aktuellen Arduino-Boards habe einen fest verlötete
SMD-LED, welche an Pin 13 angeschloßen ist. Diese LED kann von jedem
Sketch angesteuert werden. Da diese LED meistens vorhanden ist und immer an Pin 13 ageschloßen ist, ist dieses Programm auf den meisten Boards gleich.
<c>
//Blinkende LED
void setup() {
pinMode(13,OUTPUT);
}

void loop() {
delay(1000);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
}
</c>

== Downloads ==
* [http://www.arduino.cc/en/Main/Software Download der IDE]
* [http://www.mikrocontroller.net/articles/AVR Artikel zur AVR Prozessor-Serie]

==Literatur==
* Erik Bartmann: ''Die elektronische Welt mit Arduino entdecken'', O'Reilly Verlag, 2011, ISBN 978-3-89721-319-7
* Thomas Brühlmann: ''Arduino: Praxiseinstieg'', mitp Verlag, 2010, ISBN 978-3-8266-5605-7

==Bezugsquellen(Auswahl)==

===Offiziele Boards===
* [http://www.watterott.com/de/Boards-Kits/Arduino Watterott.com]
* [http://www.reichelt.de/ Reichelt.de]
* [http://www.conrad.de/ Conrad.de]
* [http://www.tigal.com/ TIGAL.com]

===Lernpakete===
* [http://www.franzis.de/ Franzis Verlag(Lernpakete)]

== Siehe auch ==
* [http://www.arduino.cc/ Website des Arduino-Projekt]
* [http://arduino.cc/forum/index.php/board,31.0.html Deutsches Arduino-Forum(offiziel)]

[[Kategorie:AVR-Boards]]
[[Kategorie:Wettbewerb]]

Arduino

2013-03-25T00:28:38Z

Mknot9: /* 8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin */

{{Wettbewerb Header}}

Das Arduino-Projekt ist ein 2006 gestartetes Projekt aus Italien. Arduino
ist eine Zusammenstellung aus verschiedenen Boards und einer IDE. Die Boards basieren auf der Atmel-AVR Serie. Die einzige ausnahme bildet der Arduino Due, dieser basiert auf einem ARM-Chip von Atmel. Das Gesamt Projekt ist quelloffen,
also Open-Source. Der Unterschied zu anderen Atmel-Boards sind der Bootloader und die IDE. Der Bootloader wird durch das Arduino-Projekt entwickelt und ist für die einzelnen Boards spezifisch.

==Die IDE==
Die Arduino-IDE ist eine in JAVA programmierte grafische Obrfläche. Dadurch das sie in JAVA programiert wurde, ist sie plattfomunabhägig und auf Windows, Linux, MacOS X und Solaris verfügbar.
Die Grafischeoberfläche compiliert die Sketche(so heißt ein Arduino-Programm offiziel) nicht, sondern ruft verschiedene Programme auf. Dies sind in der Regel der Compiler avr-g++(und zugehörige Programme, z.B. ein Linker) und avrdude,
ein Programm zum übertragen des compilierten Sketch als *.hex File auf den Flashspeicher des Arduino. Die IDE basiert auf der Processing IDE und Wiring.

==Die Boards==
Die Arduino-Boards sind Atmel AVR/ARM Chips basierende Mikrocontrollerplatinen,
welche zur Steuerung von I/O-Pins gedacht sind. Im Gegensatz zu anderen Boards sind die Arduino-Boards nicht gedacht um als "Computer" mit Betriebssystem zu dienen, wie etwa der Raspberry Pi, sondern um die I/O Pins zu steuern. Es gibt insgesamt 14 Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meisten ein USB-Aschluß(USB-B bzw. USB-Mini) oder eine Schnitstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip intigriert,
meist ein FTDI-Chip bei älteren Boards oder ein 8U2/16U2 bei neueren Boards.Eine Ausnahme bildet hier der Arduino Leonardo: Dieser besitzt einen Atmel-AVR 32U4 Mikrocontroller, welcher auch die Funktionen eines FTDI-Chips besitzt. Es ist also kein weiterer Konverter nötig.

===Arduino Uno===
Der Arduino Uno R3 ist der Standard-Arduino. In den meisten Anfänger-Bücher und Tutorials wird dieser Arduino verwendet. Auch sind die meisten Libaries für ihn geschrieben. Er ist der neuste der am längsten weiterentwickleten Arduino-Reihe.
So ist eine frühere Version des Arduino Uno (Arduino USB) das Board gewesen, welches als erstes ''Arduino'' gennant wurde. In der aktuellen Revision (Version) 3 besitzt der Uno 14 Digitale I/O Pins sowie 6 analoge Eingänge. Er wird bei 5V betrieben und besitzt folgende Speicherkapazitäten:
* 32K Flash(0,5 werden vom Bootloader verwendet.)
* 2K SRAM
* 1K EEPROM
* 16 MHz (Prozessortakt)
Neben dem USB-B Anschluß verfügt der Uno noch über folgende Anschlüsse:
* Klinkenbuchse (2.1mm , 6-20 V möglich)
* SPI
* I²C
* ICSP

====Arduino Duemilanove====
Der Arduino Duemilanove ist der Vorgänger des Arduino Uno. Er besitzt den
ATmega168 (seit 2009 328p) statt dem 328 wie beim Uno. Als Konverter verwendet der Duemilianove eine FTDI-Chip anstelle eines 16U2. Sonst ist von der Pin anzahlen und den Maßen des Boards identisch mit denen des Uno.

====Arduino Diecimila====
====Arduino NG====
====Arduino Usb====

===Arduino Mega===
====Arduino Mega ADK====
===Arduino Due===

===Arduino Ethernet===
===Arduino LilyPad===
===Arduino Leonardo===
===Arduino Nano===
===Arduino Micro===
===Arduino Fio===
===Arduino Pro Mini===
====Arduino Mini====
===Arduino Pro===

==Shields(Erweiterungsplatinen)==
Sogennante Shields sind Erweiterungsplatinen, die die Funktionen eines Arduino-Boards um neue Funktionen erweitern. So gibt es z.B. Shields die den Arduino um eine Ethernet-Schnittstelle erweitern, einen VGA-Aschluß besitzen oder einfach leere Platinen sind, auf die eine Chip eingesetzt werden kann, ohne zu Löten. Für das letztere Bsp. wäre eine solche Platine die XBEE-Antenne.

===8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin===

Seit ca. Herbst 2012 werden einige LCD-Shields mit Touch-Controller angeboten, die den IRQ-Pin nicht mehr durchschleifen.

Damit läuft auch die U-Touch Bibliothek von Henning Carlsen nicht mehr. Alle Sample-Codes im Web funktionieren auch nicht. Das Problem besteht darin herauszufinden, an welchen Arduino-Pin die das CS-Signal geleitet wird. Hier hilft nur Sheets studieren. Beim Austesten des Touch-Shields ergab sich bei mir eine y-Basiswert des Touchcontrollers von 4095 und eine Differenz der Widerstandswerte zwischen 'Touch' und 'keine Touch' von 180 (x) bzw. 240 (y), siehe Code-Kommentare.

Bei mir lief schließlich folgender Code (das CS-Signal lag auf Pin 10):
<c>
#define LCD_RS 19
#define LCD_WR 18
#define LCD_CS 17
#define LCD_REST 16

#define DCLK 15
#define DIN 14
#define CS 10
#define DOUT 8

//#define IRQ 7

unsigned int TP_X,TP_Y,x0,y0;
unsigned int l3=0;
int lx,ly, l2, ry,rx,x3=65,y3=318;
int k=3, vh2=0x84,vl2=0xFF;

void spistar() //SPI Start
{
digitalWrite(CS,LOW);
digitalWrite(DCLK,HIGH);
digitalWrite(DIN,HIGH);
digitalWrite(DCLK,HIGH);

}
//**********************************************************
void WriteCharTo7843(unsigned char num) //SPI Write Data
{
unsigned char count=0;
unsigned char temp;
unsigned nop;
temp=num;
digitalWrite(DCLK,LOW);
for(count=0;count<8;count++)
{
if(temp&0x80)
digitalWrite(DIN,HIGH);
else
digitalWrite(DIN,LOW);

temp=temp<<1;

digitalWrite(DCLK,LOW);
nop++;
nop++;
digitalWrite(DCLK,HIGH);
nop++;
nop++;
}
}

//**********************************************************
unsigned int ReadFromCharFrom7843() //SPI Read Data
{
unsigned nop;
unsigned char count=0;
unsigned int Num=0;
for(count=0;count<12;count++)
{
Num<<=1;
digitalWrite(DCLK,HIGH);//DCLK=1; _nop_();_nop_();_nop_();
nop++;
digitalWrite(DCLK,LOW);//DCLK=0; _nop_();_nop_();_nop_();
nop++;
if(digitalRead(DOUT)) Num++;
}
return(Num);
}

void LCD_Writ_Bus(char VH,char VL)
{
PORTD = VH;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
PORTD = VL;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
}

void LCD_Write_COM(char VH,char VL)
{
digitalWrite(LCD_RS,LOW);
LCD_Writ_Bus(VH,VL);
}

void LCD_Write_DATA(char VH,char VL)
{
digitalWrite(LCD_RS,HIGH);
LCD_Writ_Bus(VH,VL);
}

void Lcd_Write_Com_Data(int com,int val)
{
LCD_Write_COM(com>>8,com);
LCD_Write_DATA(val>>8,val);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
LCD_Write_COM(0x00,0x46);LCD_Write_DATA(x2,x1);
LCD_Write_COM(0x00,0x47);LCD_Write_DATA(y2>>8,y2);
LCD_Write_COM(0x00,0x48);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x20);LCD_Write_DATA(x1>>8,x1);
LCD_Write_COM(0x00,0x21);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x22);
}

void LCD_Init(void)
{

digitalWrite(LCD_REST,HIGH);
delay(5);
digitalWrite(LCD_REST,LOW);
delay(5);
digitalWrite(LCD_REST,HIGH);
delay(5);

digitalWrite(LCD_CS,LOW);
Lcd_Write_Com_Data(0x11,0x2004);
Lcd_Write_Com_Data(0x13,0xCC00);
Lcd_Write_Com_Data(0x15,0x2600);
Lcd_Write_Com_Data(0x14,0x252A);
Lcd_Write_Com_Data(0x12,0x0033);
Lcd_Write_Com_Data(0x13,0xCC04);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC06);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC4F);
delay(1);
Lcd_Write_Com_Data(0x13,0x674F);
Lcd_Write_Com_Data(0x11,0x2003);
delay(1);
Lcd_Write_Com_Data(0x30,0x2609);
Lcd_Write_Com_Data(0x31,0x242C);
Lcd_Write_Com_Data(0x32,0x1F23);
Lcd_Write_Com_Data(0x33,0x2425);
Lcd_Write_Com_Data(0x34,0x2226);
Lcd_Write_Com_Data(0x35,0x2523);
Lcd_Write_Com_Data(0x36,0x1C1A);
Lcd_Write_Com_Data(0x37,0x131D);
Lcd_Write_Com_Data(0x38,0x0B11);
Lcd_Write_Com_Data(0x39,0x1210);
Lcd_Write_Com_Data(0x3A,0x1315);
Lcd_Write_Com_Data(0x3B,0x3619);
Lcd_Write_Com_Data(0x3C,0x0D00);
Lcd_Write_Com_Data(0x3D,0x000D);
Lcd_Write_Com_Data(0x16,0x0007);
Lcd_Write_Com_Data(0x02,0x0013);
Lcd_Write_Com_Data(0x03,0x0003);
Lcd_Write_Com_Data(0x01,0x0127);
delay(1);
Lcd_Write_Com_Data(0x08,0x0303);
Lcd_Write_Com_Data(0x0A,0x000B);
Lcd_Write_Com_Data(0x0B,0x0003);
Lcd_Write_Com_Data(0x0C,0x0000);
Lcd_Write_Com_Data(0x41,0x0000);
Lcd_Write_Com_Data(0x50,0x0000);
Lcd_Write_Com_Data(0x60,0x0005);
Lcd_Write_Com_Data(0x70,0x000B);
Lcd_Write_Com_Data(0x71,0x0000);
Lcd_Write_Com_Data(0x78,0x0000);
Lcd_Write_Com_Data(0x7A,0x0000);
Lcd_Write_Com_Data(0x79,0x0007);
Lcd_Write_Com_Data(0x07,0x0051);
delay(1);
Lcd_Write_Com_Data(0x07,0x0053);
Lcd_Write_Com_Data(0x79,0x0000);

LCD_Write_COM(0x00,0x22);
digitalWrite(LCD_CS,HIGH);

}

void Pant(char VH,char VL)
{
int i,j;
Address_set(0,0,240,320);
for(i=0;i<=320;i++)
{
for (j=0;j<=240;j++)
{
LCD_Write_DATA(VH,VL);
}
}
}

void digi(int z3)
{
unsigned char p;
int x2, y2, z2, i,h2=1000;
digitalWrite(LCD_CS,LOW);
for(i=0;i<3;i++)
{
y2=y3;
x2=x3+(10*i);
Address_set(x2+6,y2-15,x2+7,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+7,y2-14);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-1,x2+7,y2);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-8,x2+7,y2-7);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+1,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);

h2=h2/10;
z2=z3/h2;
z3=z3-z2*h2;
if (z2==0) {
Address_set(x2+2,y2-8,x2+5,y2-7);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==1) {
Address_set(x2,y2-15,x2+5,y2);
for(p=0; p<96; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==2) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+6,y2-6,x2+7,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==3) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==4) {
Address_set(x2,y2-6,x2+5,y2);
for(p=0; p<42; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+2,y2-15,x2+5,y2-14);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==5) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==6) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==7) {
Address_set(x2,y2-13,x2+5,y2);
for(p=0; p<84; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==9) {
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
}

digitalWrite(LCD_CS,HIGH);
}

void newpa(void)
{
unsigned char p;
digitalWrite(LCD_CS,LOW);
Pant(0x00,0x00);

Address_set(0,319,240,319);
for(p=0; p<240; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,0,240,0);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,300,240,300);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,0,0,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,255,0,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,0,239,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,255,239,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(50,308,59,311);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(53,305,56,314);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(215,305,239,314);
for(p=0; p<250; p++) LCD_Write_DATA(0xF8,0x00);
digitalWrite(LCD_CS,HIGH);

}

void recan(void)
{
int i,j;
// unsigned int m;
digitalWrite(LCD_CS,LOW);
for(i=0;i<7;i++)
{
// m=i*3;
Address_set(i*5,305,i*5+3,314);
for(j=0; j<40; j++)
{
if (1+i*2<= k) LCD_Write_DATA(0xFF,0xE0); else LCD_Write_DATA(0x00,0x00);
}
}
Address_set(100,305,124,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
Address_set(125,305,149,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}

void AD7843(void)
{
digitalWrite(CS,LOW);
WriteCharTo7843(0x90);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_Y=ReadFromCharFrom7843();
WriteCharTo7843(0xD0);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_X=ReadFromCharFrom7843();
digitalWrite(CS,HIGH);

}

void setup()
{

unsigned char p;

for(p=0;p<20;p++)
{
pinMode(p,OUTPUT);
}
pinMode(DOUT,INPUT);
x0=1;
y0=1;

LCD_Init();
newpa();
recan();
digi(vh2);
x3=x3+90;
digi(vl2);
spistar();
}

void loop()
{
rx=0;
ry=0;

for(l3=0;l3<8;l3++)
{
AD7843();

lx=0;
ly=-1*TP_Y;
ly=4095+ly; //4095=Basiswert y-Signal
if(ly > 0) lx=1*TP_X; else {lx=0;ly=0;rx=0;ry=0;l3=9; }
rx=rx+lx;
ry=ry+ly;
}
lx=(rx/8-180)/15; //180=Minimaler x-Wert bei 'Touch'
ly=(ry/8-240)/11; //240=Minimaler (über 4095) y-Wert bei 'Touch'
if(ly < 1) {lx=0;ly=0; }
if(lx < 1) lx=0;

if(ly > 309-k)
{
ly=0;
if(lx > 200) k=k-2; else if (lx > 160) k=k+2;else
if (lx > 100) vh2++; else if (lx > 40) vl2++; else newpa();
lx=0;
if (k<1) k=1;
if (k>13) k=13;
if (vh2>255) vh2=0;
if (vl2>255) vl2=0;
x3=65;
digi(vh2);
x3=x3+90;
digi(vl2);
recan();
}

if(ly > 299-k) ly=299-k;
if(ly > 0)
{
x0=240-lx;
if(x0 > 240-k) x0=240-k;
y0=ly;
l2=(k+1)*(k+1);
digitalWrite(LCD_CS,LOW);
Address_set(x0,y0,x0+k,y0+k);
for (l3=0; l3<l2; l3++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}
delay (50);
}
</c>

==Derivate==
Es gibt viele Derivate die auf dem Arduino basieren, weil
* Alle Layouts quelloffen im Internet stehen
* Der Bootloader sowohl als Quellocde und schon compillert zum Download im Internet stehen
*Man die IDE für alle Atmel-Chips verwenden kann, die einen Arduino-Bootloader besitzen
*Man auch eine Arduino-Derivat auf dem Steckbrett zusammbauen kann

==Tutorial==
===Ein erster Sketch: Blinkende LED===
Die meisten aktuellen Arduino-Boards habe einen fest verlötete
SMD-LED, welche an Pin 13 angeschloßen ist. Diese LED kann von jedem
Sketch angesteuert werden. Da diese LED meistens vorhanden ist und immer an Pin 13 ageschloßen ist, ist dieses Programm auf den meisten Boards gleich.
<c>
//Blinkende LED
void setup() {
pinMode(13,OUTPUT);
}

void loop() {
delay(1000);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
}
</c>

== Downloads ==
* [http://www.arduino.cc/en/Main/Software Download der IDE]
* [http://www.mikrocontroller.net/articles/AVR Artikel zur AVR Prozessor-Serie]

==Literatur==
* Erik Bartmann: ''Die elektronische Welt mit Arduino entdecken'', O'Reilly Verlag, 2011, ISBN 978-3-89721-319-7
* Thomas Brühlmann: ''Arduino: Praxiseinstieg'', mitp Verlag, 2010, ISBN 978-3-8266-5605-7

==Bezugsquellen(Auswahl)==

===Offiziele Boards===
* [http://www.watterott.com/de/Boards-Kits/Arduino Watterott.com]
* [http://www.reichelt.de/ Reichelt.de]
* [http://www.conrad.de/ Conrad.de]
* [http://www.tigal.com/ TIGAL.com]

===Lernpakete===
* [http://www.franzis.de/ Franzis Verlag(Lernpakete)]

== Siehe auch ==
* [http://www.arduino.cc/ Website des Arduino-Projekt]
* [http://arduino.cc/forum/index.php/board,31.0.html Deutsches Arduino-Forum(offiziel)]

[[Kategorie:AVR-Boards]]
[[Kategorie:Wettbewerb]]

Arduino

2013-03-25T00:21:21Z

Mknot9: /* 8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin */

{{Wettbewerb Header}}

Das Arduino-Projekt ist ein 2006 gestartetes Projekt aus Italien. Arduino
ist eine Zusammenstellung aus verschiedenen Boards und einer IDE. Die Boards basieren auf der Atmel-AVR Serie. Die einzige ausnahme bildet der Arduino Due, dieser basiert auf einem ARM-Chip von Atmel. Das Gesamt Projekt ist quelloffen,
also Open-Source. Der Unterschied zu anderen Atmel-Boards sind der Bootloader und die IDE. Der Bootloader wird durch das Arduino-Projekt entwickelt und ist für die einzelnen Boards spezifisch.

==Die IDE==
Die Arduino-IDE ist eine in JAVA programmierte grafische Obrfläche. Dadurch das sie in JAVA programiert wurde, ist sie plattfomunabhägig und auf Windows, Linux, MacOS X und Solaris verfügbar.
Die Grafischeoberfläche compiliert die Sketche(so heißt ein Arduino-Programm offiziel) nicht, sondern ruft verschiedene Programme auf. Dies sind in der Regel der Compiler avr-g++(und zugehörige Programme, z.B. ein Linker) und avrdude,
ein Programm zum übertragen des compilierten Sketch als *.hex File auf den Flashspeicher des Arduino. Die IDE basiert auf der Processing IDE und Wiring.

==Die Boards==
Die Arduino-Boards sind Atmel AVR/ARM Chips basierende Mikrocontrollerplatinen,
welche zur Steuerung von I/O-Pins gedacht sind. Im Gegensatz zu anderen Boards sind die Arduino-Boards nicht gedacht um als "Computer" mit Betriebssystem zu dienen, wie etwa der Raspberry Pi, sondern um die I/O Pins zu steuern. Es gibt insgesamt 14 Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meisten ein USB-Aschluß(USB-B bzw. USB-Mini) oder eine Schnitstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip intigriert,
meist ein FTDI-Chip bei älteren Boards oder ein 8U2/16U2 bei neueren Boards.Eine Ausnahme bildet hier der Arduino Leonardo: Dieser besitzt einen Atmel-AVR 32U4 Mikrocontroller, welcher auch die Funktionen eines FTDI-Chips besitzt. Es ist also kein weiterer Konverter nötig.

===Arduino Uno===
Der Arduino Uno R3 ist der Standard-Arduino. In den meisten Anfänger-Bücher und Tutorials wird dieser Arduino verwendet. Auch sind die meisten Libaries für ihn geschrieben. Er ist der neuste der am längsten weiterentwickleten Arduino-Reihe.
So ist eine frühere Version des Arduino Uno (Arduino USB) das Board gewesen, welches als erstes ''Arduino'' gennant wurde. In der aktuellen Revision (Version) 3 besitzt der Uno 14 Digitale I/O Pins sowie 6 analoge Eingänge. Er wird bei 5V betrieben und besitzt folgende Speicherkapazitäten:
* 32K Flash(0,5 werden vom Bootloader verwendet.)
* 2K SRAM
* 1K EEPROM
* 16 MHz (Prozessortakt)
Neben dem USB-B Anschluß verfügt der Uno noch über folgende Anschlüsse:
* Klinkenbuchse (2.1mm , 6-20 V möglich)
* SPI
* I²C
* ICSP

====Arduino Duemilanove====
Der Arduino Duemilanove ist der Vorgänger des Arduino Uno. Er besitzt den
ATmega168 (seit 2009 328p) statt dem 328 wie beim Uno. Als Konverter verwendet der Duemilianove eine FTDI-Chip anstelle eines 16U2. Sonst ist von der Pin anzahlen und den Maßen des Boards identisch mit denen des Uno.

====Arduino Diecimila====
====Arduino NG====
====Arduino Usb====

===Arduino Mega===
====Arduino Mega ADK====
===Arduino Due===

===Arduino Ethernet===
===Arduino LilyPad===
===Arduino Leonardo===
===Arduino Nano===
===Arduino Micro===
===Arduino Fio===
===Arduino Pro Mini===
====Arduino Mini====
===Arduino Pro===

==Shields(Erweiterungsplatinen)==
Sogennante Shields sind Erweiterungsplatinen, die die Funktionen eines Arduino-Boards um neue Funktionen erweitern. So gibt es z.B. Shields die den Arduino um eine Ethernet-Schnittstelle erweitern, einen VGA-Aschluß besitzen oder einfach leere Platinen sind, auf die eine Chip eingesetzt werden kann, ohne zu Löten. Für das letztere Bsp. wäre eine solche Platine die XBEE-Antenne.

===8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin===

Seit ca. Herbst 2012 werden einige LCD-Shields mit Touch-Controller angeboten, die den IRQ-Pin nicht mehr durchschleifen.

Damit läuft auch die U-Touch Bibliothek von Henning Carlsen nicht mehr. Alle Sample-Codes im Web funktionieren auch nicht. Das Problem besteht darin herauszufinden, an welchen Arduino-Pin die das CS-Signal geleitet wird. Hier hilft nur Sheets studieren.

Bei mir lief schließlich folgender Code (das CS-Signal lag auf Pin 10):
<c>
#define LCD_RS 19
#define LCD_WR 18
#define LCD_CS 17
#define LCD_REST 16

#define DCLK 15
#define DIN 14
#define CS 10
#define DOUT 8

//#define IRQ 7

unsigned int TP_X,TP_Y,x0,y0;
unsigned int l3=0;
int lx,ly, l2, ry,rx,x3=65,y3=318;
int k=3, vh2=0x84,vl2=0xFF;

void spistar() //SPI Start
{
digitalWrite(CS,LOW);
digitalWrite(DCLK,HIGH);
digitalWrite(DIN,HIGH);
digitalWrite(DCLK,HIGH);

}
//**********************************************************
void WriteCharTo7843(unsigned char num) //SPI Write Data
{
unsigned char count=0;
unsigned char temp;
unsigned nop;
temp=num;
digitalWrite(DCLK,LOW);
for(count=0;count<8;count++)
{
if(temp&0x80)
digitalWrite(DIN,HIGH);
else
digitalWrite(DIN,LOW);

temp=temp<<1;

digitalWrite(DCLK,LOW);
nop++;
nop++;
digitalWrite(DCLK,HIGH);
nop++;
nop++;
}
}

//**********************************************************
unsigned int ReadFromCharFrom7843() //SPI Read Data
{
unsigned nop;
unsigned char count=0;
unsigned int Num=0;
for(count=0;count<12;count++)
{
Num<<=1;
digitalWrite(DCLK,HIGH);//DCLK=1; _nop_();_nop_();_nop_();
nop++;
digitalWrite(DCLK,LOW);//DCLK=0; _nop_();_nop_();_nop_();
nop++;
if(digitalRead(DOUT)) Num++;
}
return(Num);
}

void LCD_Writ_Bus(char VH,char VL)
{
PORTD = VH;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
PORTD = VL;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
}

void LCD_Write_COM(char VH,char VL)
{
digitalWrite(LCD_RS,LOW);
LCD_Writ_Bus(VH,VL);
}

void LCD_Write_DATA(char VH,char VL)
{
digitalWrite(LCD_RS,HIGH);
LCD_Writ_Bus(VH,VL);
}

void Lcd_Write_Com_Data(int com,int val)
{
LCD_Write_COM(com>>8,com);
LCD_Write_DATA(val>>8,val);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
LCD_Write_COM(0x00,0x46);LCD_Write_DATA(x2,x1);
LCD_Write_COM(0x00,0x47);LCD_Write_DATA(y2>>8,y2);
LCD_Write_COM(0x00,0x48);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x20);LCD_Write_DATA(x1>>8,x1);
LCD_Write_COM(0x00,0x21);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x22);
}

void LCD_Init(void)
{

digitalWrite(LCD_REST,HIGH);
delay(5);
digitalWrite(LCD_REST,LOW);
delay(5);
digitalWrite(LCD_REST,HIGH);
delay(5);

digitalWrite(LCD_CS,LOW);
Lcd_Write_Com_Data(0x11,0x2004);
Lcd_Write_Com_Data(0x13,0xCC00);
Lcd_Write_Com_Data(0x15,0x2600);
Lcd_Write_Com_Data(0x14,0x252A);
Lcd_Write_Com_Data(0x12,0x0033);
Lcd_Write_Com_Data(0x13,0xCC04);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC06);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC4F);
delay(1);
Lcd_Write_Com_Data(0x13,0x674F);
Lcd_Write_Com_Data(0x11,0x2003);
delay(1);
Lcd_Write_Com_Data(0x30,0x2609);
Lcd_Write_Com_Data(0x31,0x242C);
Lcd_Write_Com_Data(0x32,0x1F23);
Lcd_Write_Com_Data(0x33,0x2425);
Lcd_Write_Com_Data(0x34,0x2226);
Lcd_Write_Com_Data(0x35,0x2523);
Lcd_Write_Com_Data(0x36,0x1C1A);
Lcd_Write_Com_Data(0x37,0x131D);
Lcd_Write_Com_Data(0x38,0x0B11);
Lcd_Write_Com_Data(0x39,0x1210);
Lcd_Write_Com_Data(0x3A,0x1315);
Lcd_Write_Com_Data(0x3B,0x3619);
Lcd_Write_Com_Data(0x3C,0x0D00);
Lcd_Write_Com_Data(0x3D,0x000D);
Lcd_Write_Com_Data(0x16,0x0007);
Lcd_Write_Com_Data(0x02,0x0013);
Lcd_Write_Com_Data(0x03,0x0003);
Lcd_Write_Com_Data(0x01,0x0127);
delay(1);
Lcd_Write_Com_Data(0x08,0x0303);
Lcd_Write_Com_Data(0x0A,0x000B);
Lcd_Write_Com_Data(0x0B,0x0003);
Lcd_Write_Com_Data(0x0C,0x0000);
Lcd_Write_Com_Data(0x41,0x0000);
Lcd_Write_Com_Data(0x50,0x0000);
Lcd_Write_Com_Data(0x60,0x0005);
Lcd_Write_Com_Data(0x70,0x000B);
Lcd_Write_Com_Data(0x71,0x0000);
Lcd_Write_Com_Data(0x78,0x0000);
Lcd_Write_Com_Data(0x7A,0x0000);
Lcd_Write_Com_Data(0x79,0x0007);
Lcd_Write_Com_Data(0x07,0x0051);
delay(1);
Lcd_Write_Com_Data(0x07,0x0053);
Lcd_Write_Com_Data(0x79,0x0000);

LCD_Write_COM(0x00,0x22);
digitalWrite(LCD_CS,HIGH);

}

void Pant(char VH,char VL)
{
int i,j;
Address_set(0,0,240,320);
for(i=0;i<=320;i++)
{
for (j=0;j<=240;j++)
{
LCD_Write_DATA(VH,VL);
}
}
}

void digi(int z3)
{
unsigned char p;
int x2, y2, z2, i,h2=1000;
digitalWrite(LCD_CS,LOW);
for(i=0;i<3;i++)
{
y2=y3;
x2=x3+(10*i);
Address_set(x2+6,y2-15,x2+7,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+7,y2-14);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-1,x2+7,y2);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-8,x2+7,y2-7);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+1,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);

h2=h2/10;
z2=z3/h2;
z3=z3-z2*h2;
if (z2==0) {
Address_set(x2+2,y2-8,x2+5,y2-7);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==1) {
Address_set(x2,y2-15,x2+5,y2);
for(p=0; p<96; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==2) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+6,y2-6,x2+7,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==3) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==4) {
Address_set(x2,y2-6,x2+5,y2);
for(p=0; p<42; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+2,y2-15,x2+5,y2-14);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==5) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==6) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==7) {
Address_set(x2,y2-13,x2+5,y2);
for(p=0; p<84; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==9) {
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
}

digitalWrite(LCD_CS,HIGH);
}

void newpa(void)
{
unsigned char p;
digitalWrite(LCD_CS,LOW);
Pant(0x00,0x00);

Address_set(0,319,240,319);
for(p=0; p<240; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,0,240,0);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,300,240,300);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,0,0,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,255,0,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,0,239,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,255,239,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(50,308,59,311);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(53,305,56,314);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(215,305,239,314);
for(p=0; p<250; p++) LCD_Write_DATA(0xF8,0x00);
digitalWrite(LCD_CS,HIGH);

}

void recan(void)
{
int i,j;
// unsigned int m;
digitalWrite(LCD_CS,LOW);
for(i=0;i<7;i++)
{
// m=i*3;
Address_set(i*5,305,i*5+3,314);
for(j=0; j<40; j++)
{
if (1+i*2<= k) LCD_Write_DATA(0xFF,0xE0); else LCD_Write_DATA(0x00,0x00);
}
}
Address_set(100,305,124,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
Address_set(125,305,149,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}

void AD7843(void)
{
digitalWrite(CS,LOW);
WriteCharTo7843(0x90);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_Y=ReadFromCharFrom7843();
WriteCharTo7843(0xD0);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_X=ReadFromCharFrom7843();
digitalWrite(CS,HIGH);

}

void setup()
{

unsigned char p;

for(p=0;p<20;p++)
{
pinMode(p,OUTPUT);
}
pinMode(DOUT,INPUT);
x0=1;
y0=1;

LCD_Init();
newpa();
recan();
digi(vh2);
x3=x3+90;
digi(vl2);
spistar();
}

void loop()
{
rx=0;
ry=0;

for(l3=0;l3<8;l3++)
{
AD7843();

lx=0;
ly=-1*TP_Y;
ly=4095+ly;
if(ly > 0) lx=1*TP_X; else {lx=0;ly=0;rx=0;ry=0;l3=9; }
rx=rx+lx;
ry=ry+ly;
}
lx=(rx/8-180)/15;
ly=(ry/8-240)/11;
if(ly < 1) {lx=0;ly=0; }
if(lx < 1) lx=0;

if(ly > 309-k)
{
ly=0;
if(lx > 200) k=k-2; else if (lx > 160) k=k+2;else
if (lx > 100) vh2++; else if (lx > 40) vl2++; else newpa();
lx=0;
if (k<1) k=1;
if (k>13) k=13;
if (vh2>255) vh2=0;
if (vl2>255) vl2=0;
x3=65;
digi(vh2);
x3=x3+90;
digi(vl2);
recan();
}

if(ly > 299-k) ly=299-k;
if(ly > 0)
{
x0=240-lx;
if(x0 > 240-k) x0=240-k;
y0=ly;
l2=(k+1)*(k+1);
digitalWrite(LCD_CS,LOW);
Address_set(x0,y0,x0+k,y0+k);
for (l3=0; l3<l2; l3++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}
delay (50);
}
</c>

==Derivate==
Es gibt viele Derivate die auf dem Arduino basieren, weil
* Alle Layouts quelloffen im Internet stehen
* Der Bootloader sowohl als Quellocde und schon compillert zum Download im Internet stehen
*Man die IDE für alle Atmel-Chips verwenden kann, die einen Arduino-Bootloader besitzen
*Man auch eine Arduino-Derivat auf dem Steckbrett zusammbauen kann

==Tutorial==
===Ein erster Sketch: Blinkende LED===
Die meisten aktuellen Arduino-Boards habe einen fest verlötete
SMD-LED, welche an Pin 13 angeschloßen ist. Diese LED kann von jedem
Sketch angesteuert werden. Da diese LED meistens vorhanden ist und immer an Pin 13 ageschloßen ist, ist dieses Programm auf den meisten Boards gleich.
<c>
//Blinkende LED
void setup() {
pinMode(13,OUTPUT);
}

void loop() {
delay(1000);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
}
</c>

== Downloads ==
* [http://www.arduino.cc/en/Main/Software Download der IDE]
* [http://www.mikrocontroller.net/articles/AVR Artikel zur AVR Prozessor-Serie]

==Literatur==
* Erik Bartmann: ''Die elektronische Welt mit Arduino entdecken'', O'Reilly Verlag, 2011, ISBN 978-3-89721-319-7
* Thomas Brühlmann: ''Arduino: Praxiseinstieg'', mitp Verlag, 2010, ISBN 978-3-8266-5605-7

==Bezugsquellen(Auswahl)==

===Offiziele Boards===
* [http://www.watterott.com/de/Boards-Kits/Arduino Watterott.com]
* [http://www.reichelt.de/ Reichelt.de]
* [http://www.conrad.de/ Conrad.de]
* [http://www.tigal.com/ TIGAL.com]

===Lernpakete===
* [http://www.franzis.de/ Franzis Verlag(Lernpakete)]

== Siehe auch ==
* [http://www.arduino.cc/ Website des Arduino-Projekt]
* [http://arduino.cc/forum/index.php/board,31.0.html Deutsches Arduino-Forum(offiziel)]

[[Kategorie:AVR-Boards]]
[[Kategorie:Wettbewerb]]

Arduino

2013-03-25T00:18:23Z

Mknot9: /* 8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin */

{{Wettbewerb Header}}

Das Arduino-Projekt ist ein 2006 gestartetes Projekt aus Italien. Arduino
ist eine Zusammenstellung aus verschiedenen Boards und einer IDE. Die Boards basieren auf der Atmel-AVR Serie. Die einzige ausnahme bildet der Arduino Due, dieser basiert auf einem ARM-Chip von Atmel. Das Gesamt Projekt ist quelloffen,
also Open-Source. Der Unterschied zu anderen Atmel-Boards sind der Bootloader und die IDE. Der Bootloader wird durch das Arduino-Projekt entwickelt und ist für die einzelnen Boards spezifisch.

==Die IDE==
Die Arduino-IDE ist eine in JAVA programmierte grafische Obrfläche. Dadurch das sie in JAVA programiert wurde, ist sie plattfomunabhägig und auf Windows, Linux, MacOS X und Solaris verfügbar.
Die Grafischeoberfläche compiliert die Sketche(so heißt ein Arduino-Programm offiziel) nicht, sondern ruft verschiedene Programme auf. Dies sind in der Regel der Compiler avr-g++(und zugehörige Programme, z.B. ein Linker) und avrdude,
ein Programm zum übertragen des compilierten Sketch als *.hex File auf den Flashspeicher des Arduino. Die IDE basiert auf der Processing IDE und Wiring.

==Die Boards==
Die Arduino-Boards sind Atmel AVR/ARM Chips basierende Mikrocontrollerplatinen,
welche zur Steuerung von I/O-Pins gedacht sind. Im Gegensatz zu anderen Boards sind die Arduino-Boards nicht gedacht um als "Computer" mit Betriebssystem zu dienen, wie etwa der Raspberry Pi, sondern um die I/O Pins zu steuern. Es gibt insgesamt 14 Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meisten ein USB-Aschluß(USB-B bzw. USB-Mini) oder eine Schnitstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip intigriert,
meist ein FTDI-Chip bei älteren Boards oder ein 8U2/16U2 bei neueren Boards.Eine Ausnahme bildet hier der Arduino Leonardo: Dieser besitzt einen Atmel-AVR 32U4 Mikrocontroller, welcher auch die Funktionen eines FTDI-Chips besitzt. Es ist also kein weiterer Konverter nötig.

===Arduino Uno===
Der Arduino Uno R3 ist der Standard-Arduino. In den meisten Anfänger-Bücher und Tutorials wird dieser Arduino verwendet. Auch sind die meisten Libaries für ihn geschrieben. Er ist der neuste der am längsten weiterentwickleten Arduino-Reihe.
So ist eine frühere Version des Arduino Uno (Arduino USB) das Board gewesen, welches als erstes ''Arduino'' gennant wurde. In der aktuellen Revision (Version) 3 besitzt der Uno 14 Digitale I/O Pins sowie 6 analoge Eingänge. Er wird bei 5V betrieben und besitzt folgende Speicherkapazitäten:
* 32K Flash(0,5 werden vom Bootloader verwendet.)
* 2K SRAM
* 1K EEPROM
* 16 MHz (Prozessortakt)
Neben dem USB-B Anschluß verfügt der Uno noch über folgende Anschlüsse:
* Klinkenbuchse (2.1mm , 6-20 V möglich)
* SPI
* I²C
* ICSP

====Arduino Duemilanove====
Der Arduino Duemilanove ist der Vorgänger des Arduino Uno. Er besitzt den
ATmega168 (seit 2009 328p) statt dem 328 wie beim Uno. Als Konverter verwendet der Duemilianove eine FTDI-Chip anstelle eines 16U2. Sonst ist von der Pin anzahlen und den Maßen des Boards identisch mit denen des Uno.

====Arduino Diecimila====
====Arduino NG====
====Arduino Usb====

===Arduino Mega===
====Arduino Mega ADK====
===Arduino Due===

===Arduino Ethernet===
===Arduino LilyPad===
===Arduino Leonardo===
===Arduino Nano===
===Arduino Micro===
===Arduino Fio===
===Arduino Pro Mini===
====Arduino Mini====
===Arduino Pro===

==Shields(Erweiterungsplatinen)==
Sogennante Shields sind Erweiterungsplatinen, die die Funktionen eines Arduino-Boards um neue Funktionen erweitern. So gibt es z.B. Shields die den Arduino um eine Ethernet-Schnittstelle erweitern, einen VGA-Aschluß besitzen oder einfach leere Platinen sind, auf die eine Chip eingesetzt werden kann, ohne zu Löten. Für das letztere Bsp. wäre eine solche Platine die XBEE-Antenne.

===8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin===

Seit ca. Herbst 2012 werden einige LCD-Shields mit Touch-Controller angeboten, die den IRQ-Pin nicht mehr durchschleifen.

Damit läuft auch die U-Touch Bibliothek von Henning Carlsen nicht mehr. Alle Sample-Codes im Web funktionieren auch nicht. Das Problem besteht darin herauszufinden, an welchen Arduino-Pin die das CS-Signal geleitet wird. Hier hilft nur Sheets studieren.

Bei mir lief schließlich folgender Code:
<c>
#define LCD_RS 19
#define LCD_WR 18
#define LCD_CS 17
#define LCD_REST 16

#define DCLK 15
#define DIN 14
#define CS 10
#define DOUT 8
//#define IRQ 7

unsigned int TP_X,TP_Y,x0,y0;
unsigned int l3=0;
int lx,ly, l2, ry,rx,x3=65,y3=318;
int k=3, vh2=0x84,vl2=0xFF;

void spistar() //SPI Start
{
digitalWrite(CS,LOW);
digitalWrite(DCLK,HIGH);
digitalWrite(DIN,HIGH);
digitalWrite(DCLK,HIGH);

}
//**********************************************************
void WriteCharTo7843(unsigned char num) //SPI Write Data
{
unsigned char count=0;
unsigned char temp;
unsigned nop;
temp=num;
digitalWrite(DCLK,LOW);
for(count=0;count<8;count++)
{
if(temp&0x80)
digitalWrite(DIN,HIGH);
else
digitalWrite(DIN,LOW);

temp=temp<<1;

digitalWrite(DCLK,LOW);
nop++;
nop++;
digitalWrite(DCLK,HIGH);
nop++;
nop++;
}
}

//**********************************************************
unsigned int ReadFromCharFrom7843() //SPI Read Data
{
unsigned nop;
unsigned char count=0;
unsigned int Num=0;
for(count=0;count<12;count++)
{
Num<<=1;
digitalWrite(DCLK,HIGH);//DCLK=1; _nop_();_nop_();_nop_();
nop++;
digitalWrite(DCLK,LOW);//DCLK=0; _nop_();_nop_();_nop_();
nop++;
if(digitalRead(DOUT)) Num++;
}
return(Num);
}

void LCD_Writ_Bus(char VH,char VL)
{
PORTD = VH;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
PORTD = VL;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
}

void LCD_Write_COM(char VH,char VL)
{
digitalWrite(LCD_RS,LOW);
LCD_Writ_Bus(VH,VL);
}

void LCD_Write_DATA(char VH,char VL)
{
digitalWrite(LCD_RS,HIGH);
LCD_Writ_Bus(VH,VL);
}

void Lcd_Write_Com_Data(int com,int val)
{
LCD_Write_COM(com>>8,com);
LCD_Write_DATA(val>>8,val);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
LCD_Write_COM(0x00,0x46);LCD_Write_DATA(x2,x1);
LCD_Write_COM(0x00,0x47);LCD_Write_DATA(y2>>8,y2);
LCD_Write_COM(0x00,0x48);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x20);LCD_Write_DATA(x1>>8,x1);
LCD_Write_COM(0x00,0x21);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x22);
}

void LCD_Init(void)
{

digitalWrite(LCD_REST,HIGH);
delay(5);
digitalWrite(LCD_REST,LOW);
delay(5);
digitalWrite(LCD_REST,HIGH);
delay(5);

digitalWrite(LCD_CS,LOW);
Lcd_Write_Com_Data(0x11,0x2004);
Lcd_Write_Com_Data(0x13,0xCC00);
Lcd_Write_Com_Data(0x15,0x2600);
Lcd_Write_Com_Data(0x14,0x252A);
Lcd_Write_Com_Data(0x12,0x0033);
Lcd_Write_Com_Data(0x13,0xCC04);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC06);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC4F);
delay(1);
Lcd_Write_Com_Data(0x13,0x674F);
Lcd_Write_Com_Data(0x11,0x2003);
delay(1);
Lcd_Write_Com_Data(0x30,0x2609);
Lcd_Write_Com_Data(0x31,0x242C);
Lcd_Write_Com_Data(0x32,0x1F23);
Lcd_Write_Com_Data(0x33,0x2425);
Lcd_Write_Com_Data(0x34,0x2226);
Lcd_Write_Com_Data(0x35,0x2523);
Lcd_Write_Com_Data(0x36,0x1C1A);
Lcd_Write_Com_Data(0x37,0x131D);
Lcd_Write_Com_Data(0x38,0x0B11);
Lcd_Write_Com_Data(0x39,0x1210);
Lcd_Write_Com_Data(0x3A,0x1315);
Lcd_Write_Com_Data(0x3B,0x3619);
Lcd_Write_Com_Data(0x3C,0x0D00);
Lcd_Write_Com_Data(0x3D,0x000D);
Lcd_Write_Com_Data(0x16,0x0007);
Lcd_Write_Com_Data(0x02,0x0013);
Lcd_Write_Com_Data(0x03,0x0003);
Lcd_Write_Com_Data(0x01,0x0127);
delay(1);
Lcd_Write_Com_Data(0x08,0x0303);
Lcd_Write_Com_Data(0x0A,0x000B);
Lcd_Write_Com_Data(0x0B,0x0003);
Lcd_Write_Com_Data(0x0C,0x0000);
Lcd_Write_Com_Data(0x41,0x0000);
Lcd_Write_Com_Data(0x50,0x0000);
Lcd_Write_Com_Data(0x60,0x0005);
Lcd_Write_Com_Data(0x70,0x000B);
Lcd_Write_Com_Data(0x71,0x0000);
Lcd_Write_Com_Data(0x78,0x0000);
Lcd_Write_Com_Data(0x7A,0x0000);
Lcd_Write_Com_Data(0x79,0x0007);
Lcd_Write_Com_Data(0x07,0x0051);
delay(1);
Lcd_Write_Com_Data(0x07,0x0053);
Lcd_Write_Com_Data(0x79,0x0000);

LCD_Write_COM(0x00,0x22);
digitalWrite(LCD_CS,HIGH);

}

void Pant(char VH,char VL)
{
int i,j;
Address_set(0,0,240,320);
for(i=0;i<=320;i++)
{
for (j=0;j<=240;j++)
{
LCD_Write_DATA(VH,VL);
}
}
}

void digi(int z3)
{
unsigned char p;
int x2, y2, z2, i,h2=1000;
digitalWrite(LCD_CS,LOW);
for(i=0;i<3;i++)
{
y2=y3;
x2=x3+(10*i);
Address_set(x2+6,y2-15,x2+7,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+7,y2-14);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-1,x2+7,y2);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-8,x2+7,y2-7);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+1,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);

h2=h2/10;
z2=z3/h2;
z3=z3-z2*h2;
if (z2==0) {
Address_set(x2+2,y2-8,x2+5,y2-7);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==1) {
Address_set(x2,y2-15,x2+5,y2);
for(p=0; p<96; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==2) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+6,y2-6,x2+7,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==3) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==4) {
Address_set(x2,y2-6,x2+5,y2);
for(p=0; p<42; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+2,y2-15,x2+5,y2-14);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==5) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==6) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==7) {
Address_set(x2,y2-13,x2+5,y2);
for(p=0; p<84; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==9) {
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
}

digitalWrite(LCD_CS,HIGH);
}

void newpa(void)
{
unsigned char p;
digitalWrite(LCD_CS,LOW);
Pant(0x00,0x00);

Address_set(0,319,240,319);
for(p=0; p<240; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,0,240,0);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,300,240,300);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,0,0,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,255,0,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,0,239,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,255,239,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(50,308,59,311);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(53,305,56,314);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(215,305,239,314);
for(p=0; p<250; p++) LCD_Write_DATA(0xF8,0x00);
digitalWrite(LCD_CS,HIGH);

}

void recan(void)
{
int i,j;
// unsigned int m;
digitalWrite(LCD_CS,LOW);
for(i=0;i<7;i++)
{
// m=i*3;
Address_set(i*5,305,i*5+3,314);
for(j=0; j<40; j++)
{
if (1+i*2<= k) LCD_Write_DATA(0xFF,0xE0); else LCD_Write_DATA(0x00,0x00);
}
}
Address_set(100,305,124,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
Address_set(125,305,149,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}

void AD7843(void)
{
digitalWrite(CS,LOW);
WriteCharTo7843(0x90);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_Y=ReadFromCharFrom7843();
WriteCharTo7843(0xD0);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_X=ReadFromCharFrom7843();
digitalWrite(CS,HIGH);

}

void setup()
{

unsigned char p;

for(p=0;p<20;p++)
{
pinMode(p,OUTPUT);
}
pinMode(DOUT,INPUT);
x0=1;
y0=1;

LCD_Init();
newpa();
recan();
digi(vh2);
x3=x3+90;
digi(vl2);
spistar();
}

void loop()
{
rx=0;
ry=0;

for(l3=0;l3<8;l3++)
{
AD7843();

lx=0;
ly=-1*TP_Y;
ly=4095+ly;
if(ly > 0) lx=1*TP_X; else {lx=0;ly=0;rx=0;ry=0;l3=9; }
rx=rx+lx;
ry=ry+ly;
}
lx=(rx/8-180)/15;
ly=(ry/8-240)/11;
if(ly < 1) {lx=0;ly=0; }
if(lx < 1) lx=0;

if(ly > 309-k)
{
ly=0;
if(lx > 200) k=k-2; else if (lx > 160) k=k+2;else
if (lx > 100) vh2++; else if (lx > 40) vl2++; else newpa();
lx=0;
if (k<1) k=1;
if (k>13) k=13;
if (vh2>255) vh2=0;
if (vl2>255) vl2=0;
x3=65;
digi(vh2);
x3=x3+90;
digi(vl2);
recan();
}

if(ly > 299-k) ly=299-k;
if(ly > 0)
{
x0=240-lx;
if(x0 > 240-k) x0=240-k;
y0=ly;
l2=(k+1)*(k+1);
digitalWrite(LCD_CS,LOW);
Address_set(x0,y0,x0+k,y0+k);
for (l3=0; l3<l2; l3++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}
delay (50);
}
</c>

==Derivate==
Es gibt viele Derivate die auf dem Arduino basieren, weil
* Alle Layouts quelloffen im Internet stehen
* Der Bootloader sowohl als Quellocde und schon compillert zum Download im Internet stehen
*Man die IDE für alle Atmel-Chips verwenden kann, die einen Arduino-Bootloader besitzen
*Man auch eine Arduino-Derivat auf dem Steckbrett zusammbauen kann

==Tutorial==
===Ein erster Sketch: Blinkende LED===
Die meisten aktuellen Arduino-Boards habe einen fest verlötete
SMD-LED, welche an Pin 13 angeschloßen ist. Diese LED kann von jedem
Sketch angesteuert werden. Da diese LED meistens vorhanden ist und immer an Pin 13 ageschloßen ist, ist dieses Programm auf den meisten Boards gleich.
<c>
//Blinkende LED
void setup() {
pinMode(13,OUTPUT);
}

void loop() {
delay(1000);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
}
</c>

== Downloads ==
* [http://www.arduino.cc/en/Main/Software Download der IDE]
* [http://www.mikrocontroller.net/articles/AVR Artikel zur AVR Prozessor-Serie]

==Literatur==
* Erik Bartmann: ''Die elektronische Welt mit Arduino entdecken'', O'Reilly Verlag, 2011, ISBN 978-3-89721-319-7
* Thomas Brühlmann: ''Arduino: Praxiseinstieg'', mitp Verlag, 2010, ISBN 978-3-8266-5605-7

==Bezugsquellen(Auswahl)==

===Offiziele Boards===
* [http://www.watterott.com/de/Boards-Kits/Arduino Watterott.com]
* [http://www.reichelt.de/ Reichelt.de]
* [http://www.conrad.de/ Conrad.de]
* [http://www.tigal.com/ TIGAL.com]

===Lernpakete===
* [http://www.franzis.de/ Franzis Verlag(Lernpakete)]

== Siehe auch ==
* [http://www.arduino.cc/ Website des Arduino-Projekt]
* [http://arduino.cc/forum/index.php/board,31.0.html Deutsches Arduino-Forum(offiziel)]

[[Kategorie:AVR-Boards]]
[[Kategorie:Wettbewerb]]

Arduino

2013-03-25T00:17:13Z

Mknot9: /* 8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin */

{{Wettbewerb Header}}

Das Arduino-Projekt ist ein 2006 gestartetes Projekt aus Italien. Arduino
ist eine Zusammenstellung aus verschiedenen Boards und einer IDE. Die Boards basieren auf der Atmel-AVR Serie. Die einzige ausnahme bildet der Arduino Due, dieser basiert auf einem ARM-Chip von Atmel. Das Gesamt Projekt ist quelloffen,
also Open-Source. Der Unterschied zu anderen Atmel-Boards sind der Bootloader und die IDE. Der Bootloader wird durch das Arduino-Projekt entwickelt und ist für die einzelnen Boards spezifisch.

==Die IDE==
Die Arduino-IDE ist eine in JAVA programmierte grafische Obrfläche. Dadurch das sie in JAVA programiert wurde, ist sie plattfomunabhägig und auf Windows, Linux, MacOS X und Solaris verfügbar.
Die Grafischeoberfläche compiliert die Sketche(so heißt ein Arduino-Programm offiziel) nicht, sondern ruft verschiedene Programme auf. Dies sind in der Regel der Compiler avr-g++(und zugehörige Programme, z.B. ein Linker) und avrdude,
ein Programm zum übertragen des compilierten Sketch als *.hex File auf den Flashspeicher des Arduino. Die IDE basiert auf der Processing IDE und Wiring.

==Die Boards==
Die Arduino-Boards sind Atmel AVR/ARM Chips basierende Mikrocontrollerplatinen,
welche zur Steuerung von I/O-Pins gedacht sind. Im Gegensatz zu anderen Boards sind die Arduino-Boards nicht gedacht um als "Computer" mit Betriebssystem zu dienen, wie etwa der Raspberry Pi, sondern um die I/O Pins zu steuern. Es gibt insgesamt 14 Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meisten ein USB-Aschluß(USB-B bzw. USB-Mini) oder eine Schnitstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip intigriert,
meist ein FTDI-Chip bei älteren Boards oder ein 8U2/16U2 bei neueren Boards.Eine Ausnahme bildet hier der Arduino Leonardo: Dieser besitzt einen Atmel-AVR 32U4 Mikrocontroller, welcher auch die Funktionen eines FTDI-Chips besitzt. Es ist also kein weiterer Konverter nötig.

===Arduino Uno===
Der Arduino Uno R3 ist der Standard-Arduino. In den meisten Anfänger-Bücher und Tutorials wird dieser Arduino verwendet. Auch sind die meisten Libaries für ihn geschrieben. Er ist der neuste der am längsten weiterentwickleten Arduino-Reihe.
So ist eine frühere Version des Arduino Uno (Arduino USB) das Board gewesen, welches als erstes ''Arduino'' gennant wurde. In der aktuellen Revision (Version) 3 besitzt der Uno 14 Digitale I/O Pins sowie 6 analoge Eingänge. Er wird bei 5V betrieben und besitzt folgende Speicherkapazitäten:
* 32K Flash(0,5 werden vom Bootloader verwendet.)
* 2K SRAM
* 1K EEPROM
* 16 MHz (Prozessortakt)
Neben dem USB-B Anschluß verfügt der Uno noch über folgende Anschlüsse:
* Klinkenbuchse (2.1mm , 6-20 V möglich)
* SPI
* I²C
* ICSP

====Arduino Duemilanove====
Der Arduino Duemilanove ist der Vorgänger des Arduino Uno. Er besitzt den
ATmega168 (seit 2009 328p) statt dem 328 wie beim Uno. Als Konverter verwendet der Duemilianove eine FTDI-Chip anstelle eines 16U2. Sonst ist von der Pin anzahlen und den Maßen des Boards identisch mit denen des Uno.

====Arduino Diecimila====
====Arduino NG====
====Arduino Usb====

===Arduino Mega===
====Arduino Mega ADK====
===Arduino Due===

===Arduino Ethernet===
===Arduino LilyPad===
===Arduino Leonardo===
===Arduino Nano===
===Arduino Micro===
===Arduino Fio===
===Arduino Pro Mini===
====Arduino Mini====
===Arduino Pro===

==Shields(Erweiterungsplatinen)==
Sogennante Shields sind Erweiterungsplatinen, die die Funktionen eines Arduino-Boards um neue Funktionen erweitern. So gibt es z.B. Shields die den Arduino um eine Ethernet-Schnittstelle erweitern, einen VGA-Aschluß besitzen oder einfach leere Platinen sind, auf die eine Chip eingesetzt werden kann, ohne zu Löten. Für das letztere Bsp. wäre eine solche Platine die XBEE-Antenne.

===8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin===

Seit ca. Herbst 2012 werden einige LCD-Shields mit Touch-Controller angeboten, die den IRQ-Pin nicht mehr durchschleifen.

Damit läuft auch die U-Touch Bibliothek von Henning Carlsen nicht mehr. Alle Sample-Codes im Web funktionieren auch nicht. Das Problem besteht darin herauszufinden, an welchen Arduino-Pin die das CS-Signal geleitet wird. Hier hilft nur Sheets studieren.

Bei mir lief schließlich folgender Code:
<tt>
#define LCD_RS 19
#define LCD_WR 18
#define LCD_CS 17
#define LCD_REST 16

#define DCLK 15
#define DIN 14
#define CS 10
#define DOUT 8
//#define IRQ 7

unsigned int TP_X,TP_Y,x0,y0;
unsigned int l3=0;
int lx,ly, l2, ry,rx,x3=65,y3=318;
int k=3, vh2=0x84,vl2=0xFF;

void spistar() //SPI Start
{
digitalWrite(CS,LOW);
digitalWrite(DCLK,HIGH);
digitalWrite(DIN,HIGH);
digitalWrite(DCLK,HIGH);

}
//**********************************************************
void WriteCharTo7843(unsigned char num) //SPI Write Data
{
unsigned char count=0;
unsigned char temp;
unsigned nop;
temp=num;
digitalWrite(DCLK,LOW);
for(count=0;count<8;count++)
{
if(temp&0x80)
digitalWrite(DIN,HIGH);
else
digitalWrite(DIN,LOW);

temp=temp<<1;

digitalWrite(DCLK,LOW);
nop++;
nop++;
digitalWrite(DCLK,HIGH);
nop++;
nop++;
}
}

//**********************************************************
unsigned int ReadFromCharFrom7843() //SPI Read Data
{
unsigned nop;
unsigned char count=0;
unsigned int Num=0;
for(count=0;count<12;count++)
{
Num<<=1;
digitalWrite(DCLK,HIGH);//DCLK=1; _nop_();_nop_();_nop_();
nop++;
digitalWrite(DCLK,LOW);//DCLK=0; _nop_();_nop_();_nop_();
nop++;
if(digitalRead(DOUT)) Num++;
}
return(Num);
}

void LCD_Writ_Bus(char VH,char VL)
{
PORTD = VH;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
PORTD = VL;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
}

void LCD_Write_COM(char VH,char VL)
{
digitalWrite(LCD_RS,LOW);
LCD_Writ_Bus(VH,VL);
}

void LCD_Write_DATA(char VH,char VL)
{
digitalWrite(LCD_RS,HIGH);
LCD_Writ_Bus(VH,VL);
}

void Lcd_Write_Com_Data(int com,int val)
{
LCD_Write_COM(com>>8,com);
LCD_Write_DATA(val>>8,val);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
LCD_Write_COM(0x00,0x46);LCD_Write_DATA(x2,x1);
LCD_Write_COM(0x00,0x47);LCD_Write_DATA(y2>>8,y2);
LCD_Write_COM(0x00,0x48);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x20);LCD_Write_DATA(x1>>8,x1);
LCD_Write_COM(0x00,0x21);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x22);
}

void LCD_Init(void)
{

digitalWrite(LCD_REST,HIGH);
delay(5);
digitalWrite(LCD_REST,LOW);
delay(5);
digitalWrite(LCD_REST,HIGH);
delay(5);

digitalWrite(LCD_CS,LOW);
Lcd_Write_Com_Data(0x11,0x2004);
Lcd_Write_Com_Data(0x13,0xCC00);
Lcd_Write_Com_Data(0x15,0x2600);
Lcd_Write_Com_Data(0x14,0x252A);
Lcd_Write_Com_Data(0x12,0x0033);
Lcd_Write_Com_Data(0x13,0xCC04);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC06);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC4F);
delay(1);
Lcd_Write_Com_Data(0x13,0x674F);
Lcd_Write_Com_Data(0x11,0x2003);
delay(1);
Lcd_Write_Com_Data(0x30,0x2609);
Lcd_Write_Com_Data(0x31,0x242C);
Lcd_Write_Com_Data(0x32,0x1F23);
Lcd_Write_Com_Data(0x33,0x2425);
Lcd_Write_Com_Data(0x34,0x2226);
Lcd_Write_Com_Data(0x35,0x2523);
Lcd_Write_Com_Data(0x36,0x1C1A);
Lcd_Write_Com_Data(0x37,0x131D);
Lcd_Write_Com_Data(0x38,0x0B11);
Lcd_Write_Com_Data(0x39,0x1210);
Lcd_Write_Com_Data(0x3A,0x1315);
Lcd_Write_Com_Data(0x3B,0x3619);
Lcd_Write_Com_Data(0x3C,0x0D00);
Lcd_Write_Com_Data(0x3D,0x000D);
Lcd_Write_Com_Data(0x16,0x0007);
Lcd_Write_Com_Data(0x02,0x0013);
Lcd_Write_Com_Data(0x03,0x0003);
Lcd_Write_Com_Data(0x01,0x0127);
delay(1);
Lcd_Write_Com_Data(0x08,0x0303);
Lcd_Write_Com_Data(0x0A,0x000B);
Lcd_Write_Com_Data(0x0B,0x0003);
Lcd_Write_Com_Data(0x0C,0x0000);
Lcd_Write_Com_Data(0x41,0x0000);
Lcd_Write_Com_Data(0x50,0x0000);
Lcd_Write_Com_Data(0x60,0x0005);
Lcd_Write_Com_Data(0x70,0x000B);
Lcd_Write_Com_Data(0x71,0x0000);
Lcd_Write_Com_Data(0x78,0x0000);
Lcd_Write_Com_Data(0x7A,0x0000);
Lcd_Write_Com_Data(0x79,0x0007);
Lcd_Write_Com_Data(0x07,0x0051);
delay(1);
Lcd_Write_Com_Data(0x07,0x0053);
Lcd_Write_Com_Data(0x79,0x0000);

LCD_Write_COM(0x00,0x22);
digitalWrite(LCD_CS,HIGH);

}

void Pant(char VH,char VL)
{
int i,j;
Address_set(0,0,240,320);
for(i=0;i<=320;i++)
{
for (j=0;j<=240;j++)
{
LCD_Write_DATA(VH,VL);
}
}
}

void digi(int z3)
{
unsigned char p;
int x2, y2, z2, i,h2=1000;
digitalWrite(LCD_CS,LOW);
for(i=0;i<3;i++)
{
y2=y3;
x2=x3+(10*i);
Address_set(x2+6,y2-15,x2+7,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+7,y2-14);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-1,x2+7,y2);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-8,x2+7,y2-7);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+1,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);

h2=h2/10;
z2=z3/h2;
z3=z3-z2*h2;
if (z2==0) {
Address_set(x2+2,y2-8,x2+5,y2-7);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==1) {
Address_set(x2,y2-15,x2+5,y2);
for(p=0; p<96; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==2) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+6,y2-6,x2+7,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==3) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==4) {
Address_set(x2,y2-6,x2+5,y2);
for(p=0; p<42; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+2,y2-15,x2+5,y2-14);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==5) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==6) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==7) {
Address_set(x2,y2-13,x2+5,y2);
for(p=0; p<84; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==9) {
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
}

digitalWrite(LCD_CS,HIGH);
}

void newpa(void)
{
unsigned char p;
digitalWrite(LCD_CS,LOW);
Pant(0x00,0x00);

Address_set(0,319,240,319);
for(p=0; p<240; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,0,240,0);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,300,240,300);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,0,0,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,255,0,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,0,239,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,255,239,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(50,308,59,311);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(53,305,56,314);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(215,305,239,314);
for(p=0; p<250; p++) LCD_Write_DATA(0xF8,0x00);
digitalWrite(LCD_CS,HIGH);

}

void recan(void)
{
int i,j;
// unsigned int m;
digitalWrite(LCD_CS,LOW);
for(i=0;i<7;i++)
{
// m=i*3;
Address_set(i*5,305,i*5+3,314);
for(j=0; j<40; j++)
{
if (1+i*2<= k) LCD_Write_DATA(0xFF,0xE0); else LCD_Write_DATA(0x00,0x00);
}
}
Address_set(100,305,124,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
Address_set(125,305,149,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}

void AD7843(void)
{
digitalWrite(CS,LOW);
WriteCharTo7843(0x90);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_Y=ReadFromCharFrom7843();
WriteCharTo7843(0xD0);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_X=ReadFromCharFrom7843();
digitalWrite(CS,HIGH);

}

void setup()
{

unsigned char p;

for(p=0;p<20;p++)
{
pinMode(p,OUTPUT);
}
pinMode(DOUT,INPUT);
x0=1;
y0=1;

LCD_Init();
newpa();
recan();
digi(vh2);
x3=x3+90;
digi(vl2);
spistar();
}

void loop()
{
rx=0;
ry=0;

for(l3=0;l3<8;l3++)
{
AD7843();

lx=0;
ly=-1*TP_Y;
ly=4095+ly;
if(ly > 0) lx=1*TP_X; else {lx=0;ly=0;rx=0;ry=0;l3=9; }
rx=rx+lx;
ry=ry+ly;
}
lx=(rx/8-180)/15;
ly=(ry/8-240)/11;
if(ly < 1) {lx=0;ly=0; }
if(lx < 1) lx=0;

if(ly > 309-k)
{
ly=0;
if(lx > 200) k=k-2; else if (lx > 160) k=k+2;else
if (lx > 100) vh2++; else if (lx > 40) vl2++; else newpa();
lx=0;
if (k<1) k=1;
if (k>13) k=13;
if (vh2>255) vh2=0;
if (vl2>255) vl2=0;
x3=65;
digi(vh2);
x3=x3+90;
digi(vl2);
recan();
}

if(ly > 299-k) ly=299-k;
if(ly > 0)
{
x0=240-lx;
if(x0 > 240-k) x0=240-k;
y0=ly;
l2=(k+1)*(k+1);
digitalWrite(LCD_CS,LOW);
Address_set(x0,y0,x0+k,y0+k);
for (l3=0; l3<l2; l3++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}
delay (50);
}
</tt>

==Derivate==
Es gibt viele Derivate die auf dem Arduino basieren, weil
* Alle Layouts quelloffen im Internet stehen
* Der Bootloader sowohl als Quellocde und schon compillert zum Download im Internet stehen
*Man die IDE für alle Atmel-Chips verwenden kann, die einen Arduino-Bootloader besitzen
*Man auch eine Arduino-Derivat auf dem Steckbrett zusammbauen kann

==Tutorial==
===Ein erster Sketch: Blinkende LED===
Die meisten aktuellen Arduino-Boards habe einen fest verlötete
SMD-LED, welche an Pin 13 angeschloßen ist. Diese LED kann von jedem
Sketch angesteuert werden. Da diese LED meistens vorhanden ist und immer an Pin 13 ageschloßen ist, ist dieses Programm auf den meisten Boards gleich.
<c>
//Blinkende LED
void setup() {
pinMode(13,OUTPUT);
}

void loop() {
delay(1000);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
}
</c>

== Downloads ==
* [http://www.arduino.cc/en/Main/Software Download der IDE]
* [http://www.mikrocontroller.net/articles/AVR Artikel zur AVR Prozessor-Serie]

==Literatur==
* Erik Bartmann: ''Die elektronische Welt mit Arduino entdecken'', O'Reilly Verlag, 2011, ISBN 978-3-89721-319-7
* Thomas Brühlmann: ''Arduino: Praxiseinstieg'', mitp Verlag, 2010, ISBN 978-3-8266-5605-7

==Bezugsquellen(Auswahl)==

===Offiziele Boards===
* [http://www.watterott.com/de/Boards-Kits/Arduino Watterott.com]
* [http://www.reichelt.de/ Reichelt.de]
* [http://www.conrad.de/ Conrad.de]
* [http://www.tigal.com/ TIGAL.com]

===Lernpakete===
* [http://www.franzis.de/ Franzis Verlag(Lernpakete)]

== Siehe auch ==
* [http://www.arduino.cc/ Website des Arduino-Projekt]
* [http://arduino.cc/forum/index.php/board,31.0.html Deutsches Arduino-Forum(offiziel)]

[[Kategorie:AVR-Boards]]
[[Kategorie:Wettbewerb]]

Arduino

2013-03-25T00:16:10Z

Mknot9: /* Shields(Erweiterungsplatinen) */

{{Wettbewerb Header}}

Das Arduino-Projekt ist ein 2006 gestartetes Projekt aus Italien. Arduino
ist eine Zusammenstellung aus verschiedenen Boards und einer IDE. Die Boards basieren auf der Atmel-AVR Serie. Die einzige ausnahme bildet der Arduino Due, dieser basiert auf einem ARM-Chip von Atmel. Das Gesamt Projekt ist quelloffen,
also Open-Source. Der Unterschied zu anderen Atmel-Boards sind der Bootloader und die IDE. Der Bootloader wird durch das Arduino-Projekt entwickelt und ist für die einzelnen Boards spezifisch.

==Die IDE==
Die Arduino-IDE ist eine in JAVA programmierte grafische Obrfläche. Dadurch das sie in JAVA programiert wurde, ist sie plattfomunabhägig und auf Windows, Linux, MacOS X und Solaris verfügbar.
Die Grafischeoberfläche compiliert die Sketche(so heißt ein Arduino-Programm offiziel) nicht, sondern ruft verschiedene Programme auf. Dies sind in der Regel der Compiler avr-g++(und zugehörige Programme, z.B. ein Linker) und avrdude,
ein Programm zum übertragen des compilierten Sketch als *.hex File auf den Flashspeicher des Arduino. Die IDE basiert auf der Processing IDE und Wiring.

==Die Boards==
Die Arduino-Boards sind Atmel AVR/ARM Chips basierende Mikrocontrollerplatinen,
welche zur Steuerung von I/O-Pins gedacht sind. Im Gegensatz zu anderen Boards sind die Arduino-Boards nicht gedacht um als "Computer" mit Betriebssystem zu dienen, wie etwa der Raspberry Pi, sondern um die I/O Pins zu steuern. Es gibt insgesamt 14 Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meisten ein USB-Aschluß(USB-B bzw. USB-Mini) oder eine Schnitstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip intigriert,
meist ein FTDI-Chip bei älteren Boards oder ein 8U2/16U2 bei neueren Boards.Eine Ausnahme bildet hier der Arduino Leonardo: Dieser besitzt einen Atmel-AVR 32U4 Mikrocontroller, welcher auch die Funktionen eines FTDI-Chips besitzt. Es ist also kein weiterer Konverter nötig.

===Arduino Uno===
Der Arduino Uno R3 ist der Standard-Arduino. In den meisten Anfänger-Bücher und Tutorials wird dieser Arduino verwendet. Auch sind die meisten Libaries für ihn geschrieben. Er ist der neuste der am längsten weiterentwickleten Arduino-Reihe.
So ist eine frühere Version des Arduino Uno (Arduino USB) das Board gewesen, welches als erstes ''Arduino'' gennant wurde. In der aktuellen Revision (Version) 3 besitzt der Uno 14 Digitale I/O Pins sowie 6 analoge Eingänge. Er wird bei 5V betrieben und besitzt folgende Speicherkapazitäten:
* 32K Flash(0,5 werden vom Bootloader verwendet.)
* 2K SRAM
* 1K EEPROM
* 16 MHz (Prozessortakt)
Neben dem USB-B Anschluß verfügt der Uno noch über folgende Anschlüsse:
* Klinkenbuchse (2.1mm , 6-20 V möglich)
* SPI
* I²C
* ICSP

====Arduino Duemilanove====
Der Arduino Duemilanove ist der Vorgänger des Arduino Uno. Er besitzt den
ATmega168 (seit 2009 328p) statt dem 328 wie beim Uno. Als Konverter verwendet der Duemilianove eine FTDI-Chip anstelle eines 16U2. Sonst ist von der Pin anzahlen und den Maßen des Boards identisch mit denen des Uno.

====Arduino Diecimila====
====Arduino NG====
====Arduino Usb====

===Arduino Mega===
====Arduino Mega ADK====
===Arduino Due===

===Arduino Ethernet===
===Arduino LilyPad===
===Arduino Leonardo===
===Arduino Nano===
===Arduino Micro===
===Arduino Fio===
===Arduino Pro Mini===
====Arduino Mini====
===Arduino Pro===

==Shields(Erweiterungsplatinen)==
Sogennante Shields sind Erweiterungsplatinen, die die Funktionen eines Arduino-Boards um neue Funktionen erweitern. So gibt es z.B. Shields die den Arduino um eine Ethernet-Schnittstelle erweitern, einen VGA-Aschluß besitzen oder einfach leere Platinen sind, auf die eine Chip eingesetzt werden kann, ohne zu Löten. Für das letztere Bsp. wäre eine solche Platine die XBEE-Antenne.

===8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin===

Seit ca. Herbst 2012 werden einige LCD-Shields mit Touch-Controller angeboten, die den IRQ-Pin nicht mehr durchschleifen.

Damit läuft auch die U-Touch Bibliothek von Henning Carlsen nicht mehr. Alle Sample-Codes im Web funktionieren auch nicht. Das Problem besteht darin herauszufinden, an welchen Arduino-Pin die das CS-Signal geleitet wird. Hier hilft nur Sheets studieren.

Bei mir lief schließlich folgender Code:
<code>
#define LCD_RS 19
#define LCD_WR 18
#define LCD_CS 17
#define LCD_REST 16

#define DCLK 15
#define DIN 14
#define CS 10
#define DOUT 8
//#define IRQ 7

unsigned int TP_X,TP_Y,x0,y0;
unsigned int l3=0;
int lx,ly, l2, ry,rx,x3=65,y3=318;
int k=3, vh2=0x84,vl2=0xFF;

void spistar() //SPI Start
{
digitalWrite(CS,LOW);
digitalWrite(DCLK,HIGH);
digitalWrite(DIN,HIGH);
digitalWrite(DCLK,HIGH);

}
//**********************************************************
void WriteCharTo7843(unsigned char num) //SPI Write Data
{
unsigned char count=0;
unsigned char temp;
unsigned nop;
temp=num;
digitalWrite(DCLK,LOW);
for(count=0;count<8;count++)
{
if(temp&0x80)
digitalWrite(DIN,HIGH);
else
digitalWrite(DIN,LOW);

temp=temp<<1;

digitalWrite(DCLK,LOW);
nop++;
nop++;
digitalWrite(DCLK,HIGH);
nop++;
nop++;
}
}

//**********************************************************
unsigned int ReadFromCharFrom7843() //SPI Read Data
{
unsigned nop;
unsigned char count=0;
unsigned int Num=0;
for(count=0;count<12;count++)
{
Num<<=1;
digitalWrite(DCLK,HIGH);//DCLK=1; _nop_();_nop_();_nop_();
nop++;
digitalWrite(DCLK,LOW);//DCLK=0; _nop_();_nop_();_nop_();
nop++;
if(digitalRead(DOUT)) Num++;
}
return(Num);
}

void LCD_Writ_Bus(char VH,char VL)
{
PORTD = VH;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
PORTD = VL;
digitalWrite(LCD_WR,LOW);
digitalWrite(LCD_WR,HIGH);
}

void LCD_Write_COM(char VH,char VL)
{
digitalWrite(LCD_RS,LOW);
LCD_Writ_Bus(VH,VL);
}

void LCD_Write_DATA(char VH,char VL)
{
digitalWrite(LCD_RS,HIGH);
LCD_Writ_Bus(VH,VL);
}

void Lcd_Write_Com_Data(int com,int val)
{
LCD_Write_COM(com>>8,com);
LCD_Write_DATA(val>>8,val);
}

void Address_set(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
LCD_Write_COM(0x00,0x46);LCD_Write_DATA(x2,x1);
LCD_Write_COM(0x00,0x47);LCD_Write_DATA(y2>>8,y2);
LCD_Write_COM(0x00,0x48);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x20);LCD_Write_DATA(x1>>8,x1);
LCD_Write_COM(0x00,0x21);LCD_Write_DATA(y1>>8,y1);
LCD_Write_COM(0x00,0x22);
}

void LCD_Init(void)
{

digitalWrite(LCD_REST,HIGH);
delay(5);
digitalWrite(LCD_REST,LOW);
delay(5);
digitalWrite(LCD_REST,HIGH);
delay(5);

digitalWrite(LCD_CS,LOW);
Lcd_Write_Com_Data(0x11,0x2004);
Lcd_Write_Com_Data(0x13,0xCC00);
Lcd_Write_Com_Data(0x15,0x2600);
Lcd_Write_Com_Data(0x14,0x252A);
Lcd_Write_Com_Data(0x12,0x0033);
Lcd_Write_Com_Data(0x13,0xCC04);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC06);
delay(1);
Lcd_Write_Com_Data(0x13,0xCC4F);
delay(1);
Lcd_Write_Com_Data(0x13,0x674F);
Lcd_Write_Com_Data(0x11,0x2003);
delay(1);
Lcd_Write_Com_Data(0x30,0x2609);
Lcd_Write_Com_Data(0x31,0x242C);
Lcd_Write_Com_Data(0x32,0x1F23);
Lcd_Write_Com_Data(0x33,0x2425);
Lcd_Write_Com_Data(0x34,0x2226);
Lcd_Write_Com_Data(0x35,0x2523);
Lcd_Write_Com_Data(0x36,0x1C1A);
Lcd_Write_Com_Data(0x37,0x131D);
Lcd_Write_Com_Data(0x38,0x0B11);
Lcd_Write_Com_Data(0x39,0x1210);
Lcd_Write_Com_Data(0x3A,0x1315);
Lcd_Write_Com_Data(0x3B,0x3619);
Lcd_Write_Com_Data(0x3C,0x0D00);
Lcd_Write_Com_Data(0x3D,0x000D);
Lcd_Write_Com_Data(0x16,0x0007);
Lcd_Write_Com_Data(0x02,0x0013);
Lcd_Write_Com_Data(0x03,0x0003);
Lcd_Write_Com_Data(0x01,0x0127);
delay(1);
Lcd_Write_Com_Data(0x08,0x0303);
Lcd_Write_Com_Data(0x0A,0x000B);
Lcd_Write_Com_Data(0x0B,0x0003);
Lcd_Write_Com_Data(0x0C,0x0000);
Lcd_Write_Com_Data(0x41,0x0000);
Lcd_Write_Com_Data(0x50,0x0000);
Lcd_Write_Com_Data(0x60,0x0005);
Lcd_Write_Com_Data(0x70,0x000B);
Lcd_Write_Com_Data(0x71,0x0000);
Lcd_Write_Com_Data(0x78,0x0000);
Lcd_Write_Com_Data(0x7A,0x0000);
Lcd_Write_Com_Data(0x79,0x0007);
Lcd_Write_Com_Data(0x07,0x0051);
delay(1);
Lcd_Write_Com_Data(0x07,0x0053);
Lcd_Write_Com_Data(0x79,0x0000);

LCD_Write_COM(0x00,0x22);
digitalWrite(LCD_CS,HIGH);

}

void Pant(char VH,char VL)
{
int i,j;
Address_set(0,0,240,320);
for(i=0;i<=320;i++)
{
for (j=0;j<=240;j++)
{
LCD_Write_DATA(VH,VL);
}
}
}

void digi(int z3)
{
unsigned char p;
int x2, y2, z2, i,h2=1000;
digitalWrite(LCD_CS,LOW);
for(i=0;i<3;i++)
{
y2=y3;
x2=x3+(10*i);
Address_set(x2+6,y2-15,x2+7,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+7,y2-14);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-1,x2+7,y2);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-8,x2+7,y2-7);
for(p=0; p<16; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(x2,y2-15,x2+1,y2);
for(p=0; p<32; p++) LCD_Write_DATA(0xFF,0xFF);

h2=h2/10;
z2=z3/h2;
z3=z3-z2*h2;
if (z2==0) {
Address_set(x2+2,y2-8,x2+5,y2-7);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==1) {
Address_set(x2,y2-15,x2+5,y2);
for(p=0; p<96; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==2) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+6,y2-6,x2+7,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==3) {
Address_set(x2,y2-13,x2+1,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==4) {
Address_set(x2,y2-6,x2+5,y2);
for(p=0; p<42; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2+2,y2-15,x2+5,y2-14);
for(p=0; p<8; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==5) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==6) {
Address_set(x2+6,y2-13,x2+7,y2-9);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==7) {
Address_set(x2,y2-13,x2+5,y2);
for(p=0; p<84; p++) LCD_Write_DATA(0x00,0x00);
}
if (z2==9) {
Address_set(x2,y2-6,x2+1,y2-2);
for(p=0; p<10; p++) LCD_Write_DATA(0x00,0x00);
}
}

digitalWrite(LCD_CS,HIGH);
}

void newpa(void)
{
unsigned char p;
digitalWrite(LCD_CS,LOW);
Pant(0x00,0x00);

Address_set(0,319,240,319);
for(p=0; p<240; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,0,240,0);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,300,240,300);
for(p=0; p<240; p++) LCD_Write_DATA(0xFF,0xFF);
Address_set(0,0,0,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(0,255,0,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,0,239,255);
for(p=0; p<255; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(239,255,239,300);
for(p=0; p<45; p++) LCD_Write_DATA(0xF8,0x00);
Address_set(50,308,59,311);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(53,305,56,314);
for(p=0; p<40; p++) LCD_Write_DATA(0x07,0xE0);
Address_set(215,305,239,314);
for(p=0; p<250; p++) LCD_Write_DATA(0xF8,0x00);
digitalWrite(LCD_CS,HIGH);

}

void recan(void)
{
int i,j;
// unsigned int m;
digitalWrite(LCD_CS,LOW);
for(i=0;i<7;i++)
{
// m=i*3;
Address_set(i*5,305,i*5+3,314);
for(j=0; j<40; j++)
{
if (1+i*2<= k) LCD_Write_DATA(0xFF,0xE0); else LCD_Write_DATA(0x00,0x00);
}
}
Address_set(100,305,124,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
Address_set(125,305,149,314);
for(i=0; i<250; i++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}

void AD7843(void)
{
digitalWrite(CS,LOW);
WriteCharTo7843(0x90);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_Y=ReadFromCharFrom7843();
WriteCharTo7843(0xD0);
digitalWrite(DCLK,HIGH);
digitalWrite(DCLK,LOW);
TP_X=ReadFromCharFrom7843();
digitalWrite(CS,HIGH);

}

void setup()
{

unsigned char p;

for(p=0;p<20;p++)
{
pinMode(p,OUTPUT);
}
pinMode(DOUT,INPUT);
x0=1;
y0=1;

LCD_Init();
newpa();
recan();
digi(vh2);
x3=x3+90;
digi(vl2);
spistar();
}

void loop()
{
rx=0;
ry=0;

for(l3=0;l3<8;l3++)
{
AD7843();

lx=0;
ly=-1*TP_Y;
ly=4095+ly;
if(ly > 0) lx=1*TP_X; else {lx=0;ly=0;rx=0;ry=0;l3=9; }
rx=rx+lx;
ry=ry+ly;
}
lx=(rx/8-180)/15;
ly=(ry/8-240)/11;
if(ly < 1) {lx=0;ly=0; }
if(lx < 1) lx=0;

if(ly > 309-k)
{
ly=0;
if(lx > 200) k=k-2; else if (lx > 160) k=k+2;else
if (lx > 100) vh2++; else if (lx > 40) vl2++; else newpa();
lx=0;
if (k<1) k=1;
if (k>13) k=13;
if (vh2>255) vh2=0;
if (vl2>255) vl2=0;
x3=65;
digi(vh2);
x3=x3+90;
digi(vl2);
recan();
}

if(ly > 299-k) ly=299-k;
if(ly > 0)
{
x0=240-lx;
if(x0 > 240-k) x0=240-k;
y0=ly;
l2=(k+1)*(k+1);
digitalWrite(LCD_CS,LOW);
Address_set(x0,y0,x0+k,y0+k);
for (l3=0; l3<l2; l3++) LCD_Write_DATA(vh2,vl2);
digitalWrite(LCD_CS,HIGH);
}
delay (50);
}
</code>

==Derivate==
Es gibt viele Derivate die auf dem Arduino basieren, weil
* Alle Layouts quelloffen im Internet stehen
* Der Bootloader sowohl als Quellocde und schon compillert zum Download im Internet stehen
*Man die IDE für alle Atmel-Chips verwenden kann, die einen Arduino-Bootloader besitzen
*Man auch eine Arduino-Derivat auf dem Steckbrett zusammbauen kann

==Tutorial==
===Ein erster Sketch: Blinkende LED===
Die meisten aktuellen Arduino-Boards habe einen fest verlötete
SMD-LED, welche an Pin 13 angeschloßen ist. Diese LED kann von jedem
Sketch angesteuert werden. Da diese LED meistens vorhanden ist und immer an Pin 13 ageschloßen ist, ist dieses Programm auf den meisten Boards gleich.
<c>
//Blinkende LED
void setup() {
pinMode(13,OUTPUT);
}

void loop() {
delay(1000);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
}
</c>

== Downloads ==
* [http://www.arduino.cc/en/Main/Software Download der IDE]
* [http://www.mikrocontroller.net/articles/AVR Artikel zur AVR Prozessor-Serie]

==Literatur==
* Erik Bartmann: ''Die elektronische Welt mit Arduino entdecken'', O'Reilly Verlag, 2011, ISBN 978-3-89721-319-7
* Thomas Brühlmann: ''Arduino: Praxiseinstieg'', mitp Verlag, 2010, ISBN 978-3-8266-5605-7

==Bezugsquellen(Auswahl)==

===Offiziele Boards===
* [http://www.watterott.com/de/Boards-Kits/Arduino Watterott.com]
* [http://www.reichelt.de/ Reichelt.de]
* [http://www.conrad.de/ Conrad.de]
* [http://www.tigal.com/ TIGAL.com]

===Lernpakete===
* [http://www.franzis.de/ Franzis Verlag(Lernpakete)]

== Siehe auch ==
* [http://www.arduino.cc/ Website des Arduino-Projekt]
* [http://arduino.cc/forum/index.php/board,31.0.html Deutsches Arduino-Forum(offiziel)]

[[Kategorie:AVR-Boards]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T22:44:45Z

Mknot9: /* Hardwareseitige Ausbauvarianten */

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...) oder in 10er Potenzen. Denkbar wäre auch eine Parallelschaltung der 'zuschaltbaren' Widerstände [http://de.wikipedia.org/wiki/Digital-Analog-Umsetzer#Realisierungsverfahren] - je nach Umsetzung wären natürlich die Vorwiderstände der Transistoren anzupassen;

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und so auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ andere Variante der Ersetzung der Handregler bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T22:33:53Z

Mknot9: /* Hardwareseitige Ausbauvarianten */

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...) oder in 10er Potenzen. Denkbar wäre auch eine Parallelschaltung der 'zuschaltbaren' Widerstände - je nach Umsetzung wären natürlich die Vorwiderstände der Transistoren anzupassen;

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und so auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ andere Variante der Ersetzung der Handregler bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T22:33:24Z

Mknot9: /* Hardwareseitige Ausbauvarianten */

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...) oder in 10er Potenzen. Denkbar wäre auch eine Parallelschaltung der 'zuschaltbaren' Widerstände - je nach Umsetzung wären natürlich die [[Vorwiderstände]] der Transistoren anzupassen;

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und so auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ andere Variante der Ersetzung der Handregler bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T22:15:12Z

Mknot9: /* Hardwareseitige Ausbauvarianten */

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...) oder in 10er Potenzen;

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und so auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ andere Variante der Ersetzung der Handregler bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T22:13:54Z

Mknot9: /* Siehe auch */

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...) oder in 10er Potenzen;

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ andere Variante der Ersetzung der Handregler bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T22:13:02Z

Mknot9: /* Siehe auch */

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...) oder in 10er Potenzen;

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ andere Variante der Ersetzung der Handregler bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T21:51:45Z

Mknot9:

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...) oder in 10er Potenzen;

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T19:59:11Z

Mknot9: /* Programmgesteuerte Schaltung von 2 Relais */

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T19:57:14Z

Mknot9:

von M. Knoop

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T18:21:26Z

Mknot9:

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird an einem konkreten Beispiel schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T18:19:29Z

Mknot9: /* Umsetzung von 3 Schaltstufen mit Optokopplern */

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige Basisstrom noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T18:19:02Z

Mknot9: /* Umsetzung von 3 Schaltstufen mit Optokopplern */

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Neben dem Weglassen der Diode (was die Maximalgeschwindigkeit leicht erhöht), können auch statt der 400 Ohm Widerstände 1k-Werte oder höher gewählt werden, wenn dadurch der jeweilige [[Basisstrom]] noch hoch genug ist. Im vorliegenden Fall war erst ab 400 Ohm keine weitere Tempoerhöhung mehr feststellbar.

d. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T18:13:30Z

Mknot9: /* Siehe auch */

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung der gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T18:12:57Z

Mknot9: /* Siehe auch */

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]
* [http://www.mikrocontroller.net/articles/GhostCarProjekt Verlagerung des gesamten Steuerelektronik ins Fahrzeug]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T18:10:01Z

Mknot9: /* Hardwareseitige Ausbauvarianten */

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Entwurf einer Zusatzschaltung, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Entwurf einer Zusatzschaltung, die erkennt wie viel Strom fliesst: damit wären Rückschlüsse auf den Streckenverlauf möglich (Kurve=etwas mehr Strom, Steigung=noch mehr Strom nötig, etc.) und auch eine programmgesteuerte Optimierung der Array-Schaltzeiten dankbar;

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-08T18:01:45Z

Mknot9:

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeintlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschließen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bibliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klick" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais lässt sich auch mittels eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klickt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom im Mittel ca. 130 mA während ohne 190 mA fließen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch ließe sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so platziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek.), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Mikrocontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spaß beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T21:27:30Z

Mknot9:

''von mknot9'' (M. Knoop)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus: http://youtu.be/xQ7N-PrIULk

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spass beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T21:20:58Z

Mknot9: /* Hardwareseitige Ausbauvarianten */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spass beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T21:17:07Z

Mknot9: /* Siehe auch */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spass beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car paralleler englischsp. Bericht des Autors zum RPi mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T21:14:14Z

Mknot9: /* Siehe auch */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spass beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung der Universität Manchester (englischspr.)]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation des Autors mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T21:11:29Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

== Hardwareseitige Ausbauvarianten ==

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spass beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T20:41:20Z

Mknot9: /* Softwareseitige Ausbauvarianten */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

...in jedem Fall: viel Spass beim Basteln!

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T20:40:04Z

Mknot9: /* Optokoppler als Ersatz für Relais */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Bei diesem Projekt liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T20:36:15Z

Mknot9: /* Kaskadierung von Transistoren zur Signalverstärkung */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein [[Optokoppler]] eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Ansteuerung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T20:34:08Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung aufgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim anfänglichen Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zu Beginn eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:[http://youtu.be/xQ7N-PrIULk].

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen wäre das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T19:17:30Z

Mknot9: /* Hardwareseitige Ausbauvarianten */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Die Ausbaumöglichkeiten dieses Projektes sind vielfältig:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T19:16:11Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit Relais und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus):

[[Bild:PiF_CNY_BC_1.png|400px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|400px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|400px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T19:14:28Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung mit [[Relais]] und [[Spannungsteiler]]n nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus):

[[Bild:PiF_CNY_BC_1.png|500px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|500px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|450px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T18:09:59Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus):

[[Bild:PiF_CNY_BC_1.png|500px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|500px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.:

[[Bild:Sm3ou3t2.png|450px|Erhöhung der Schaltstufen]]

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T18:07:47Z

Mknot9: /* Umsetzung von 3 Schaltstufen mit Optokopplern */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus):

[[Bild:PiF_CNY_BC_1.png|500px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|500px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T18:07:22Z

Mknot9: /* Kaskadierung von Transistoren zur Signalverstärkung */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus):

[[Bild:PiF_CNY_BC_1.png|500px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|thumb|left|450px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T18:06:57Z

Mknot9: /* Kaskadierung von Transistoren zur Signalverstärkung */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

[[Bild:PiF_CNY_BC_1.png|450px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|thumb|left|450px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T18:06:09Z

Mknot9: /* RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace[http://elinux.org/RPi_Expansion_Boards#Piface]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

[[Bild:PiF_CNY_BC_1.png|thumb|left|450px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|thumb|left|450px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T18:05:44Z

Mknot9: /* RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der 'PiFace'[http://elinux.org/RPi_Expansion_Boards#Piface]-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

[[Bild:PiF_CNY_BC_1.png|thumb|left|450px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|thumb|left|450px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T18:02:12Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der '[[http://elinux.org/RPi_Expansion_Boards#Piface|PiFace]]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen etc. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung 'Taste 2' berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passen) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

[[Bild:PiF_CNY_BC_1.png|thumb|left|450px|Optokoppler mit Transistor]]

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

[[Bild:SmPiFu2ou2T.png|thumb|left|450px|Kombination von 2 Optokopplern]]

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch) relativieren, da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T16:32:04Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Dessen Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten wird dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der '[http://elinux.org/RPi_Expansion_Boards#Piface|PiFace]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden direkt zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen o.Ä. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung Taste 2 berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passt) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

[[Bild:PiF_CNY_BC_1.png|thumb|right|450px|Optokoppler mit Transistor]]a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

[[Bild:SmPiFu2ou2T.png|thumb|right|450px|Kombination von 2 Optokopplern]]a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch relativieren), da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T16:31:10Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Deren Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten werden dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der '[http://elinux.org/RPi_Expansion_Boards#Piface|PiFace]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|250px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden direkt zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen o.Ä. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung Taste 2 berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passt) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

[[Bild:PiF_CNY_BC_1.png|thumb|right|450px|Optokoppler mit Transistor]]a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

[[Bild:SmPiFu2ou2T.png|thumb|right|450px|Kombination von 2 Optokopplern]]a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch relativieren), da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T16:29:48Z

Mknot9: /* Kombination von 2 Relais */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Deren Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten werden dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der '[http://elinux.org/RPi_Expansion_Boards#Piface|PiFace]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:ZrelMww2.png|thumb|right|300px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden direkt zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen o.Ä. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung Taste 2 berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passt) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

[[Bild:PiF_CNY_BC_1.png|thumb|right|450px|Optokoppler mit Transistor]]a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

[[Bild:SmPiFu2ou2T.png|thumb|right|450px|Kombination von 2 Optokopplern]]a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch relativieren), da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

Datei:ZrelMww2.png

2013-03-07T16:27:52Z

Mknot9: Brückenschaltung zu Widerstand

Brückenschaltung zu Widerstand

RPi als D/A-Wandler

2013-03-07T15:48:52Z

Mknot9:

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Deren Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten werden dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der '[http://elinux.org/RPi_Expansion_Boards#Piface|PiFace]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:sm1ru50o.png|thumb|right|300px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden direkt zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen o.Ä. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung Taste 2 berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|250px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passt) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

[[Bild:PiF_CNY_BC_1.png|thumb|right|450px|Optokoppler mit Transistor]]a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

[[Bild:SmPiFu2ou2T.png|thumb|right|450px|Kombination von 2 Optokopplern]]a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|450px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch relativieren), da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]

RPi als D/A-Wandler

2013-03-07T15:46:57Z

Mknot9: /* Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern */

''von mknot9'' (in Arbeit)

{{Wettbewerb Header}}

Oft wird ein Computer 'nur' genutzt um darauf Software ablaufen zu lassen. Deren Möglichkeit zur Steuerung von elektrischen und mechanischen Geräten werden dabei leicht übersehen.

Dieser Artikel richtet sich daher an Einsteiger, die mit dem [[Raspberry Pi]] ('RPi') Grundlagen der Computersteuerung von Relais und Spannungsteilern nachvollziehen möchten. Es wird schrittweise dargestellt, wie mittels eines D/A-Wandlers (Digital/Analog-Wandler = Umwandlung von digitalen 1/0 Signale) die Steuerung einer stufenweise veränderbaren Ausgangsspannung nachgebaut werden kann.

= Verwendete Hardware =

== RPi in Kombination mit der 'PiFace'-Karte als Bastelplattform ==

Dank der einfachen Bauweise bietet sich der RPi mit seinen frei zugänglichen GPIO-Pins als ideale Bastelplattform an. Trotzdem kann es beim Experimentieren mit Schaltungen öfters zu kleinen Fehlern kommen, die schlimmstenfalls die empfindliche Elektronik des RPi dauerhaft beschädigen können.

Daher wird bei diesem Projekt zusätzlich mit der '[http://elinux.org/RPi_Expansion_Boards#Piface|PiFace]'-Karte gearbeitet, die man auf die GPIO-Pins stecken kann. Diese Erweiterungskarte verschaltet die GPIO-Pins auf je 8 digitale Ein- und Ausgänge, sowie 2 Relais, die eine galvanische Trennung von Stromkreisen ermöglichen. Damit besteht auch für Einsteiger ein gewisser Schutz für die Steuerelektronik des RPi.

Auch im weiteren Verlauf dieser Einführung soll noch auf eine Trennung der Stromkreise Wert gelegt werden, so dass für erste digitale Schaltexperimente ein Optokoppler genutzt wird. Die spätere Nutzung der 'Input Pins' des PiFace um eine Steuerung der D/A-Wandlung durch bestimmte Ereignisse zu ermöglichen, erfolgt ebenfalls passiv.

Hinweis: Auch wenn mit vermeindlich 'sicheren' Transformatoren gebastelt wird, muss stets bedacht werden, dass diese an einem 230V-Stromnetz betrieben werden und man eher einmal mehr als weniger prüfen sollte, ob man durch eventuelle Fehler mit lebensgefährlicher Spannung in Berührung kommt!

== Auswahl eines Beispielprojektes ==

Günstige Möglichkeiten ein Gerät zu finden, das mit analogen Spannungen arbeitet, bieten sich u.a. im Spielzeugbereich. Im Grunde eignet sich alles, was mit Batterien oder mit Gleichspannungen unter 24 V betrieben wird.

Da jedoch ein Ziel das Steuern von analogen Spannungen ist, bietet sich insbesondere alles an, bei dem [[Potentiometer]] eingesetzt werden. Einen dieser 'Handregler' sollte man übrig haben, da er von seinem Anschlusskabel abgetrennt werden muss, um den oft proprietären Steckanschluss nutzen zu können. In diesem Sinne wird hier eine handelsübliche Spielzeug-Autorennbahn mit Potentiometer-Handreglern genutzt.

== Sonstige Bauteile ==

Für die ersten Grundlagen (s. Teile 2 & 3) genügen bereits rund 2 m isolierter Draht, der nicht aus verdrillten feinen Adern (Litze) bestehen sollte, 50 cm nicht-isolierter Draht, einige niederohmige Widerstände (z.B. je 2 mal 100 Ohm, 80, 60, sowie 20) und ein 'Experimentierbrett' (engl. [[Breadboard]]).

= Grundlagen und Vorbereitung des Projekts =

== Umwandlung von 1/0 zu Ein/Aus mit einem Relais ==

Vom Prinzip her ist jede Umwandlung eines digitalen 0 oder 1 Signals (das über eine bestimmte Spannungsdifferenz festgelegt ist) in eine (nutzbare) Spannung bereits eine D/A-Wandlung. Dies wird schlicht so realisiert, dass mit einer Eingabe am RPi die Nutzspannung des 'Verbrauchers' zunächst einfach an- und ausgeschaltet wird.

== Vorbereitung der zu steuernden Hardware ==

a. Um Fehlerquellen auszuschliessen sollte zunächst (und ggf. auch später!) kurz getestet werden, ob der vorhandene Regler wie erwartet funktioniert.

[[Bild:Pif_Con9.jpg|thumb|right|400px|Fixierung der Reglerkabel]]
b. Nach dem Trennen des Reglers von der Einspeisung (und ggf. Ziehen des Netzsteckers) muss das Regler-Kabel abgeschnitten werden (eher nahe beim Regler, da das Kabel bald bis zum Breadboard reichen soll). Die neuen Enden des Einspeiseteils werden abisoliert und auf dem Breadboard diagonal zueinander mit einigen Spalten Abstand fixiert. Auch können bereits die Drähte, die später zum RPi führen, jeweils in den passenden kontaktführenden Spalten eingesteckt werden, z. B. wie rechts zu sehen (die nicht beschrifteten Drähte können vorerst ignoriert werden):

c. Nun bietet sich eine gute Gelegenheit die maximale Spannung am Nutzgerät zu messen. Man verbindet das Regler-Kabel (nun ohne Regler) wieder mit der Einspeisung und die offenen Enden der Drähte mit dem Messgerät, bei dem zunächst ein Messbereich von ca. 10-50 Volt gewählt werden sollte. Dies sollte dann z.B. 14,8 V anzeigen. Natürlich können auch die beiden offenen Enden einen kleinen Moment kurz geschlossen werden, man sollte aber bedenken, dass das zu regelnde Nutzgerät dann die maximal vorgesehene Spannung erhält (hier: maximales Tempo).

== Vorbereitung des RPi ==

Es wird davon ausgegangen, dass entsprechend des zugehörigen 'manual' das PiFace bereits auf den RPi gesteckt ist, die nötigen python-Bilbliotheken installiert sind und man sich im Terminal-Arbeitsverzeichnis 'pi' befindet.

a. Zunächst wird der PiFace-Emulator (im Terminal direkt aus dem Arbeitsverzeichnis) gestartet: <tt>piface/scripts/piface-emulator</tt>

b. Wenn alles richtig installiert wurde, erscheint ein Fenster (unten links), bei dem die vorerst wichtigen blauen Signale am rechten Rand wie folgt angezeigt werden sollten:

[[Datei:RPi_PiF_em-scs.jpg|400px|Piface-Emulator im default-Zustand]] [[Datei:RPi_PiF_em_scs1.jpg|400px|Piface-Relais 1 auf '1' geschaltet]]

c. Das rechte Fenster ergibt sich, wenn man nun im Fenster auf "Override Enable" und dann "Output Pin 1" klickt. Es müsste ein "Klack" vom Relais 1 zu hören sein sowie der Schaltzustand des unteren Relais 1 (das an den Output Pin 1 gekoppelt ist) auf die Verbindung der beiden unteren Anschlüsse wechseln. Zugleich wird das erste LED-Icon beim Output Pin 1 rot sowie das zugehörige LED-Icon blau.

[[Bild:Pif_rel2.png|thumb|right|250px|Schema der Piface-Relais]]
d. Rechts ist der Schaltzustand der Relais, die zu Beginn genutzt werden, im Grundzustand dargestellt (jeweils der mittlere und obere Kontakt sind kurzgeschlossen, der jeweils untere Kontakt ist frei):

e. Ein weiterer Klick auf "Output Pin 1" versetzt das Relais in den Ausgangszustand, der vor dem nächsten Schritt wieder eingestellt werden sollte.

f. Das Relais läßt sich auch mittel eines Python-Scripts vom RPi aus ansteuern. Dazu wird folgende Textdatei "wandler.py" im Arbeitsverzeichnis abgespeichert und mit dem Befehl "<tt>python wandler.py</tt>" gestartet:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler.py

from time import sleep
import piface.pfio as pfio

pfio.init()

pfio.digital_write(1,1)
print "Strom an"

sleep(2)

pfio.digital_write(1,0)
print "Strom aus"

Nach dem Absetzen des Befehls wechselt nun das blaue Signal an Relais 1 für 2 Sekunden und das Relais klackt entsprechend.

== Einsatz eines Relais' zur Umsetzung von Spannungsänderungen ==

a. Ist das Relais wieder im Ausgangszustand, befestigt man nun einen der vom Breadboard führenden Drähte am unteren und einen am mittleren Relaiseingang (im Moment ist die Polarität noch egal). Zunächst sollte nichts passieren (das Relais hält diesen ja Stromkreis noch offen).

b. Startet man aber das Script wieder (<tt>python wandler.py</tt>) oder klickt auf 'Output Pin 1' wird der Nutzstromkreis geschlossen. Nochmals aufgepasst: unser Nutzer erhält wieder die maximal vorgesehene Spannung - also besser vorher im Script "<tt>sleep(0.3)</tt>" setzen und speichern.

c. Im Prinzip ist damit die programmgesteuerte Umsetzung eines 0/1 Signals in z.B. eine 0V/15V Spannung erreicht.

d. Da wir bald verschiedene Steuerspannungen schalten wollen, geht es jetzt darum herauszufinden, bei welcher Spannung unser Nutzgerät gerade noch bewegt wird. Dies probiert man aus - mit dem kleinsten Widerstand beginnend: indem einer der Drähte in eine freie Breadboardspalte gesteckt wird und aus dieser Spalte der Widerstand zu dem 'alten' Steckplatz des Drahtes geführt wird. Nun startet man jeweils das Script bis der Widerstand so hoch ist, dass die Anlaufspannung beim Nutzgerätes gut ausreicht, eine Reaktion des Nutzgerät (Fahrzeug bewegt sich) zu bewirken (z.B. bei 50 Ohm beträgt der Strom ca. 130 mA während ohne 190 mA fliessen).

= Ansteuerung von 3 Schaltstufen =

== Kombination von 2 Relais ==

[[Bild:sm1ru50o.png|thumb|right|300px|Beschaltung der Relais]] a. Die einfachste Stufe der weiteren Verschaltung erreicht man, indem der Widerstand mit einem 2. Relais überbrückt wird. Relais 1 kann dann als 'Hauptschalter', Relais 2 als Spannungsumschalter genutzt werden:

b. Diese Beschaltung kann sogleich mit dem PiFace-Emulator ausprobiert werden. Damit können wir bereits 3 Schaltstufen steuern: keine, verminderte und volle Spannung.

c. Theoretisch liesse sich auch noch eine 4. Spannungsstufe erzeugen, da mit 2 'Bits' (Ein/Aus bei 2 Relais) bereits 4 verschiedene Signale darstellbar sind. Beim jetzigen Aufbau werden aber lediglich die (pin1,pin2)-Signale (0,0), (1,0) und (1,1) 'genutzt', da Relais 1 als Hauptschalter vorgesehen ist und die Kombination (0,1) so nicht ausgewertet wird.

== Programmgesteuerte Schaltung von 2 Relais ==

a. Mit einem veränderten python-Script "wandler2.py" ist auch die programmgesteuerte Schaltung möglich. Dabei werden direkt zusätzlich die Tasten 1 und 2 des PiFace genutzt, um nach dem Start des Scripts (<tt>python wandler2.py</tt>) den Hauptschalter (Relais 1) zu steuern:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler2.py

from time import sleep
import piface.pfio as pfio
pfio.init()

taste_1=0
taste_2=0
intervall_a=0.1
intervall_b=0.5
# Die Intervalle bestimmen die Schaltzeit für volle/verminderte Spannung

print "Zum Start Taste 1 drücken, zum Stoppen Taste 2"
pfio.digital_write(1,0)
pfio.digital_write(2,0)
while taste_1 == 0:
sleep(intervall_a)
taste_1=pfio.digital_read(1)

# Der o.g. 'sleep'-Befehl bestimmt die Abfragepausen für Taste 1

pfio.digital_write(1,1)
print "Strom an!"

while taste_2 == 0:
pfio.digital_write(2,1)
sleep(intervall_a)
pfio.digital_write(2,0)
sleep(intervall_b)
taste_2=pfio.digital_read(2)

pfio.digital_write(1,0)
print "Strom aus!"

b. Falls beim Ausprobieren von Script-Änderungen mal was schief geht, kann das Script stets auch mit der Tastenkombination (CNTRL-C) gestoppt werden. U.U. muss dann noch zusätzlich Relais 1 und/oder 2 via Emulator zurückgesetzt werden.

c. Beim Verändern des Scripts fällt bald auf, dass die bisherige Programmsteuerung keine direkte Möglichkeit vorsieht, auf Ereignisse zu reagieren. Immerhin wird ein mechanisches Gerät gesteuert, bei dem mit Ausfällen, Fertigungstoleranzen, Umwelteinflüssen o.Ä. zu rechnen ist (im Script wird dies bislang 'nur' durch die Abbruchbedingung Taste 2 berücksichtigt).

== Einfache Sensor-Signale als steuernde Elemente eines Programms ==

a. Eine wichtige Anwendung von D/A-Steuerungen ist die mögliche Reaktion dieser Steuerung auf 'äußere' Ereignisse, die z.B. mit Hilfe von Sensoren leistbar ist.

[[Datei:Einf_Sens.jpg|thumb|right|300px|einfacher Sensor]]b. Für unsere Zwecke genügt zunächst ein sehr einfacher Sensor, der ein 0- oder 1-Signal liefert und idealerweise direkt am 'Input Pin 1' des PiFace angeschlossen werden kann. So liegt beim Input Pin 1 das Signal '1' an, wenn eine Verbindung zu 'Input GND' besteht.
Z.B. können 2 unisolierte Drähte so plaziert werden, dass ein vorbeifahrendes Fahrzeug einen von ihnen genügend bewegt um den Kontakt kurze Zeit zu öffnen. Genau dann liefert dieser 'Sensor' das Signal '0'. Eine - die Schwerkraft nutzende - mögliche Bauform ist rechts abgebildet ;-)

c. Natürlich werden zusätzlich 2 isolierte Drähte benötigt, um jeden der beiden offenen Drähte geschützt mit Input Pin 1 und Input GND zu verbinden.

d. Bei jeder Durchfahrt liefert der Sensor nun ein '0'-Signal, was im Script sowohl für eine Zeitmessung als auch für ein 'Schaltintervall-Array' genutzt werden kann. Dort können abwechselnd für beide Spannungen Zeiten (die in etwa zum jeweiligen Streckenabschnitt passt) 'programmiert' werden. Statt Taste 1 wird nun der Sensor ausgewertet (wobei Taste 1 als Sensor-Ersatz insoweit genutzt werden kann, dass sie gedrückt bleiben bzw. kurz losgelassen werden muss). Zur genaueren Zeitmessung wird noch das modul 'clock' benötigt. "<tt>wandler3.py</tt>" könnte also so aussehen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# wandler3.py

from time import clock
import piface.pfio as pfio
sensor_1=1
sensor_2=0
rundenzahl=0
v_wechsel=0
vorrunde=0
index_zaehler=1

zeit_array=[0,0.2,0.4,0.2,0.4,0.2,0.4,0.2,5,0.2,6]
# dieses array enthält die sek. bis zum Spannungswechsel

array_laenge=9
# legt fest, wie viel Werte des arrays genutzt werden sollen

sensor_aus=1.3
# bis der Sensor sicher in die Ruhestellung kippt, wird er nicht ausgelesen

pfio.init()
pfio.digital_write(2,0)
pfio.digital_write(1,1)

# das Fahrzeug wird langsam zum Start (=Sensor) bewegt
while sensor_1 == 1 :
sensor_1=pfio.digital_read(1)

print "fliegender Start... zum Beenden Taste 2 drücken"
print "Runde Nr., Ges.Zeit, Rundenzeit, mittlere Rundenzeit"
start_zeit=clock()
runden_start=start_zeit

while sensor_2 == 0 :
sensor_2=pfio.digital_read(2)
v_wechsel=1-v_wechsel
pfio.digital_write(2,v_wechsel)
sensor_zeit=clock()

while zeit_array[index_zaehler]+sensor_zeit > clock() :
if runden_start+sensor_aus < clock() :

sensor_1=pfio.digital_read(1)
if sensor_1 == 0 :
rundenzahl=rundenzahl+1
runden_start=clock()
zeit=runden_start-start_zeit
print rundenzahl, zeit, zeit-vorrunde, zeit/rundenzahl
vorrunde=zeit
sensor_zeit=0
index_zaehler=0
v_wechsel=0

index_zaehler=index_zaehler+1
if index_zaehler > array_laenge :
sensor_2=1
print "array-Ende erreicht!"

pfio.digital_write(2,0)
pfio.digital_write(1,0)
print "Outp 1 & 2 auf 0!"

Wird das Array-Ende erreicht, wurden entweder zu wenige Einträge vorgesehen oder es befindet sich kein Fahrzeug (mehr) auf der Strecke, das den Sensor und damit des Zurücksetzen des Arrays auslösen konnte.

e. Das Array ist an die jeweilige Strecke anzupassen, wobei der vorderste Eintrag ungenutzt bleibt und dann mit der Dauer für maximale Spannung begonnen wird. Solange man mit Relais arbeitet, sollten die Schaltzeiten nicht zu kurz sein (>0.1 sek), da diese eine gewisse mechanische Trägheit besitzen.

f. Eben diese mechanische Beschaffenheit der Relais (Verschleiß) ist auch ein guter Grund, auf 'volle' digitale Signalumwandlung umzustellen.

= Optokoppler als Ersatz für Relais =

Ähnlich wie ein Relais dient ein [[Optokoppler]] dazu, eine Signalübertragung zwischen zwei getrennten Stromkreisen zu ermöglichen. Hier liegt der Einsatz von Optokopplern nahe, da sie schneller schalten und keine beweglichen Teile besitzen. Für unsere Zwecke benötigen wir nun als zusätzliche Elemente: Optokoppler (CNY 17-4), npn-[[Transistor]]en (BC 337-40) zur Signalverstärkung sowie einige Widerstände im Bereich von 2k und 400 Ohm.

== Kaskadierung von Transistoren zur Signalverstärkung ==

[[Bild:PiF_CNY_BC_1.png|thumb|right|500px|Optokoppler mit Transistor]]a. Entsprechend Schritt 2.4.d. (ein Relais bei 50 Ohm) wird zunächst ein Optokoppler eingesetzt, dessen Signal durch einen Transistor verstärkt wird, um die 'Grundspannung' zu schalten (Pin 3 und 6 beim Optokoppler sollten unbeschaltet bleiben, allein der 'Lichtstrom' reicht für eine Durchschaltung aus).

b. Da immer mit einer gewissen Toleranz bei allen Komponenten zu rechnen ist, kann es sein, dass u.U. die Widerstände etwas größer oder kleiner gewählt werden müssen. Beim Ausprobieren sollte man hier in 10% Schritten variieren.

c. Bei Austesten mit Emulator oder Script ist auch zu beachten, dass nun 'Output Pin 8' genutzt wird, da dieser nicht mit den Relais verschaltet ist.

== Umsetzung von 3 Schaltstufen mit Optokopplern ==

[[Bild:SmPiFu2ou2T.png|thumb|right|500px|Kombination von 2 Optokopplern]]a. Entsprechend dem Vorgehen beim Relais kann nun auch der kleine Widerstand zusätzlich beschaltet werden um seine gesteuerte Überbrückung zu ermöglichen. Da hier eine relativ geringe Spannung aufgeschaltet wird, kann zusätzlich eine Diode eingesetzt werden, die die Schaltstufe 'maximale Spannung' anzeigt.

b. Vor dem Testen ist wieder zu beachten, dass nun zusätzlich 'Output Pin 7' genutzt wird (statt Output Pin 2).

c. Eine mögliche Realisierung sieht so aus:...

== Zusätzliche Erhöhung der Schaltstufen bei D/A-Wandlern ==

[[Bild:Sm3ou3t2.png|thumb|right|500px|Erhöhung der Schaltstufen]]a. Zwar benötigen wir in unserem speziellen Beispiel eine 'Grundspannung', die sich dahingehend auswirkt, dass - wie unter 3.1.c. erwähnt - eine Signalkombination nicht ausgewertet wird, aber mit jeder weiteren Schaltstufe würde sich dieses Problem (theoretisch relativieren), da bei geschickter Auswahl der Widerstände (z.B. im Verhältnis 1 zu 2) jeweils eine Verdoppelung der Kombinationsmöglichkeiten erreichbar ist.

b. Wird hier der 50 Ohm Widerstand asymmetrisch geteilt (z.B. 15 + 35 Ohm, s.a. [[Spannungsteiler]]) um dort ein weiteres Signal umsetzen zu können, ergeben sich direkt folgende 5 Schaltstufen (aus, 50, 35, 15 und 0 Ohm) u.s.w.

c. Zur Ansteuerung dieser Schaltstufen ist das Script so zu ändern, dass nun zwischen mehr als 2 Stufen gewechselt werden kann und im Array entsprechende Zusatzdaten vorgegeben und ausgelesen werden. Mehr als diese Stufen sind im konkreten Fall aber nicht sinnvoll, da die entstehende Verlustleistung in der Schaltung die maximal verfügbare Leistung reduziert.

= Weiterführende Ideen =

== Hardwareseitige Ausbauvarianten ==

Dem Ausbau dieses Ansatzes sind kaum Grenzen gesetzt:

- beispielhafte Umsetzung einer differenzierten Abstufung mittels mittels einer logarithmischen Einteilung oder eines möglichst oft durch 2 teilbaren Anfangswertes und der Teiler (640 Ohm, 320, 160...);

- Nachbau des Projekts mit einem Microcontroller (ggf. mit LCD-Anzeige);

- Umbau der Steuerung mit dem Ziel, sie direkt an die GPIO-Pins des RPi anzuschließen;

- Ergänzung um eine Sensorik, die in diesem Beispiel eine Rückmeldung liefert, ob ein Verbraucher aktiv ist oder nicht (Fahrzeug noch auf der Strecke?);

- Einsatz anderer Sensortechniken und/oder mehrerer Sensoren zur Optimierung der Schnelligkeit oder parallelen Steuerung eines 2. Fahrzeuges;

== Softwareseitige Ausbauvarianten ==

- Optimierung des Scripts, indem die Sensor-Abfrage über einen 'Listener' umgesetzt wird;

- Erweiterung des Scripts um eine GUI mit Hilfe der python-lib Tkinter, um einen Nutzerzugriff auf das Steuerarray und/oder eine 'Verwaltung' mehrerer Fahrzeuge;

- Einbindung eines Web-Interface um eine 'Fernsteuerung' zu ermöglichen...

== Siehe auch ==

* [http://hackaday.com/2013/01/23/replacement-controllers-for-slot-car-racing/ ähnliches Projekt bei 'hackaday']
* [https://docs.google.com/folder/d/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg/edit?pli=1&docId=0B-UAZ9CyJCLGNmpMeVpyYlZJUWc Relaisschaltung mit pädagogischer Erweiterung d. Universität Manchester]
* [http://elinux.org/RPi_Projects/PiFace_controlling_a_slot-car parallele englischsp. Dokumentation dieses Projekts mit anderem Schwerpunkt]
* [http://elinux.org/RPi_Projects englischsp. Projektliste zum RPi]

[[Kategorie:Raspberry Pi]]
[[Kategorie:Wettbewerb]]