Arduino

Wechseln zu: Navigation, Suche

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. Was nicht nur die Entwicklungsumgebung betrifft, sondern auch die Projektdateien für die Platinen. Die Unterschiede 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.

Zielgruppe[Bearbeiten]

Arduinos richten sich an Mikrocontroller-Einsteiger und kleinere bis mittlere Projekte. Es sind fertig aufgebaute Boards mit zahlreichen Anschlüssen und aufgelöteten Buchsenleisten. Die Programmierung ist zuverlässig und die Kompatibilität mit Shields und die Portabilität zwischen den einzelnen Boards wird weitestgehend gewährleistet. Eine obere Grenze für die verfügbare Rechenleistung sind Ausgaben auf große Anzeigen wie XVGA-Monitore (1024x768 Pixel). Ein PAL-Signal für Fernseher ist möglich. Die meisten Boards verfügen über relativ wenig Speicher, womit sie schon mit Bibliotheken für Ein-/ Ausgabe auf SD-Karten (16kByte) ausgereizt sind. Eine LED blinken zu lassen wird im u.a. Tutorial gezeigt.

Projekte aus den Startpaketen benutzen bspw. 3 lichtempfindliche Widerstände um eine 3-farbige LED anzusteuern. Eine Lichtschranke oder ein Mikrofon regeln die Stellung eines Servomotor. Dem offiziellen Arduino Starterkit liegen sogar Optokoppler bei, um die Tasten anderer Geräte zu hacken und per Arduino fernzusteuern. Der sog. Playground [1] ist ein Wiki, in dem eine Vielzahl von Ideen mit Schaltungsbeispielen die Möglichkeiten eines Mikrocontrollers aufzeigen.

Wer dem Arduino dann entwachsen ist, muss ihn nicht zum alten Eisen legen. Einige Boards haben einen ISP-Port (In System Programming=Programmierung in der Schaltung) vorgesehen und sogar mit einem 6pol. Steckverbinder bestückt. Damit sind diese Arduinos über einen passenden Programmieradapter gemäß Chip-Datenblatt vollständig programmierbar – auch was für Profis, die das teure Atmel-Board scheuen.

Die IDE und Schaltpläne[Bearbeiten]

Bildschirmfoto Arduino-IDE
Die Arduino-IDE ist eine in JAVA programmierte grafische Oberfläche. Dadurch ist sie plattfomunabhängig, folglich mit gleichem Erscheinungsbild auf Windows, Linux, MacOS X und Solaris verfügbar. Der Funktionsumfang ist deutlich geringer als etwa das Atmel Studio oder Eclipse-basierte Entwicklungsumgebungen. So gibt es keine gesonderte Verwaltung von Bibliotheken (libraries/ Header-Dateien). Jedes Projekt ist abgeschlossen und enthält alle notwendigen Abhängigkeiten, statt sie aus einer gemeinsamen Ablage zu beziehen. Diese Arbeitsweise entspricht eher dem ad-hoc-Charakter des Arduino. Es sollen schnell Ergebnisse sichtbar sein, ohne allzu tief in die Materie eintauchen zu müssen.

Die Grafische Oberfläche compiliert die Sketche (engl. für Skizze, so heißt ein Arduino-Programm offiziell) 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.

Für die Einsteiger-freundliche virtuelle Verkabelung kann Fritzing benutzt werden. Wie für die Arduino IDE zählt auch hier nicht die technische Genauigkeit. Wer aber sein Arduino-Projekt schnell zeichnen möchte, so dass andere es schnell nachbauen können, ist damit bestens beraten.

Die Boards[Bearbeiten]

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 mehr als 10 echte Arduino Boards mit 13 - 70 I/O Pins. Die Platinen besitzen meistens einen USB-Aschluß (USB-B, USB-Mini oder USB-Micro) oder eine Schnittstelle für einen USB-Serial-Konverterchip. Die Platinen mit USB-Anschluß haben einen solchen Chip integriert. Ältere Boards nutzen dafür einen FTDI-Chip, oder einen 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. Neben den von Arduino selbst hergestellten Boards gibt es eine Vielzahl von Sprösslingen, die von anderen Firmen auf der Arduino-Architektur aufgesetzt werden. Dieser Artikel beschäftigt sich der Einfachheit wegen nur mit den echten Arduinos. Es lohnt sich aber auch die anderen Boards zu studieren, um noch kleinere, noch sparsamere oder noch leistungsfähigere zu finden.

Wer wenig Erfahrung mit Elektronik hat muss darauf achten, einen Arduino mit einem austauschbaren Chip zu kaufen. Dazu gehört der Uno (mittlerweile R3). Alle anderen Boards haben fest verlötete Prozessoren und ein Fehler im eigenen Projekt mit anschließendem Kurzschluss, Spannungs- oder Stromspitzen entwertet so die gesamte Platine. Da die anderen Varianten zudem oft in Oberflächenmontage und mit vielen Beinchen gelötet werden, ist ein Austausch für den Anfänger ausgeschlossen. Einen neuen ATMega328P (PDIP/ Plastikinsekt mit 32 Beinen) gibt es im Elektronikhandel für ca. 3 Euro im Gegensatz zu 25 Euro für ein komplettes Board. (Den blanken Chip kann man aus der IDE mit dem Bootloader flashen.)

Es ist generell ratsam mit einem kleinen Arduino einzusteigen. Wer noch keine Bastelkiste mit Elektronikteilen hat, dem seien die Startpakete ans Herz gelegt. Neben den wichtigsten Bauteilen enthalten sie ein kleines Steckbrett, ein paar Drahtbrücken und ein Buch mit ca. 10 Projekten. Wenn man dann dem Speicher des Uno entwachsen ist und die Anschlüsse nicht mehr reichen, lohnt sich der Umstieg auf die größeren Varianten. Wer es dann elektronischer haben möchte, der schaut sich die gesamte Atmel-Palette an, in die Kataloge der anderen Hersteller oder rüstet gleich auf einen vollwertigen Mini-PC um.

Arduino Uno[Bearbeiten]

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 weiterentwickelten 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 besitzt eine Spannungsregelung und darf mit 12V über einen Hohlstecker versorgt werden, kann aber auch an bereits geregelte 5V angeschlossen werden und besitzt folgende Speicherkapazitäten:

  • 32K Flash(0,5 werden vom Bootloader verwendet.)
  • 2K SRAM
  • 1K EEPROM
  • 16 MHz (Prozessortakt)

Neben dem USB-B Anschluss verfügt der Uno noch über folgende Anschlüsse:

  • Hohlstecker-Buchse (2.1mm , 6-20 V möglich)
  • SPI
  • I²C
  • ICSP

Arduino Mega[Bearbeiten]

Hinsichtlich der Ein- und Ausgänge sowie dem verfügbaren Speicher ist der Mega der große Bruder von allen AVR-basierten Arduinos. Die aktuellen Versionen sind der Mega 2560 und der Mega ADK. Neben 16 analogen Eingängen gibt es 54 digitale Kanäle von denen 15 mit PWM steuern können. Zur seriellen Kommunikation, sog. UARTs, können 4 Kanäle genutzt werden. Der Flash-Speicher ist mit 256kByte 8mal größer als der des Uno. So passen eine Menge Bibliotheken in eigene Programme.

Arduino Due[Bearbeiten]

Im Gegensatz zu den übrigen Boards wird für den Due ein ARM Cortex-M3-Chip (Atmel SAM3X8E) verbaut. Das bringt den größten Flash-Speicher mit 512kByte und zum Mega vergleichbare Ein- und Ausgänge. Die drei wichtigsten Unterscheidungsmerkmale sind die deutlich höhere Taktfrequenz von 84MHz (statt 16MHz), 32bit-Verarbeitung (statt 8bit) und 2 analoge Ausgänge. Zudem darf der Due nur mit 3.3V betrieben und angesteuert werden, d.h. alle I/O-Pins müssen an 5V-Logik angepasst werden, sollen sie mit 5V genutzt werden.

Andere Boards[Bearbeiten]

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. Das Board des Ethernet verfügt über einen RJ45-Anschluss sowie einen microSD-Karten-Slot. Wenn man einen Arduino als USB-Gerät benutzen möchte, dann bietet sich der Leonardo an. Der verbaute Mikrocontroller (ATmega32u4) besitzt eine in Hardware implementierte USB-Schnittstelle. Den übrigen Boards fehlt dafür der Programmieranschluss für den separaten USB-Controller oder es muss ein Programmieradapter statt des USB-Kabels benutzt werden, die Firmware entsprechend zu aktualisieren.

Alle o.a. Boards sind groß und so gibt es etwa die Lilipads, deren runde Platine und niedrige Bauhöhe den Einsatz in Textilien erleichtert. Sie sind nicht mehr kompatibel zu den Shields. Wer es dennoch niedrig und Shield-kompatibel wünscht, der kann die Pro-Modelle nutzen. Sie haben eine feste Spannungsreglung und müssen mit 3.3V oder 5V betrieben werden. Die Buchsenleisten sind nicht vorgelötet. Die kleinsten Boards sind die Pro Mini-Varianten. Sie haben nur noch die Größe eines Kaugummi-Streifens. Diese Miniaturisierung fordert auch ihren Tribut und die höchstzulässige Verlustleistung des verbauten Chips ist geringer als bei den großen Boards.

Tutorial[Bearbeiten]

Ein erster Sketch: Blinkende LED[Bearbeiten]

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.

//Blinkende LED
void setup() {
    pinMode(13,OUTPUT);
}

void loop() {
    delay(1000);
    digitalWrite(13,HIGH);
    delay(1000);
    digitalWrite(13,LOW);
}


Arduino Display[Bearbeiten]

Mit dem Arduino kann man ein Display ansteuern.

Materialien:

Arduino, Display, Kabel, 1k Poti

  1. Man verkabelt die Schaltung.
  2. Der Sketch wird hochgeladen.
  3. Der Kontrast wird mit Hilfe des Potis eingestellt.
Weitere Informationen auf:[Bearbeiten]

https://www.youtube.com/watch?v=7tDDVJuO5dM

Dort wird noch mal alles genau beschrieben

Shields(Erweiterungsplatinen)[Bearbeiten]

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 ein Chip eingesetzt werden kann, ohne zu Löten. Für den letzteren Fall wäre ein Beispiel die XBEE-Antennen-Platine. Es gibt eine eigene Datenbank [2] nur für Shields.

8-bit LCD-Shield mit Touch-Controller ohne IRQ-Pin[Bearbeiten]

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):

#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);
}

Downloads[Bearbeiten]

Literatur[Bearbeiten]

Bezugsquellen(Auswahl)[Bearbeiten]

Offiziele Boards[Bearbeiten]

Lernpakete[Bearbeiten]

Siehe auch[Bearbeiten]

  1. [1] Arduino Playground Wiki
  2. [2] Shieldlist für Arduino