Die Bezeichnung Starterpaket ist irreführend, da ohne Elektronik-Bauteile

Bei einem Starterpaket gehe ich davon aus das ich die im Paket beschriebenen Programmbeispiele auch machen kann.
In Wirklichkeit wurde das 7,8x5,6x2cm Board nur in einer aufwendigen und kostspielig gemachten fast DINA4 großen Kassette (200x250x30mm) neu verpackt.

In der Kassette hätten 17 dieser Boards Platz. Man könnte auch von einer riesen großen Mogelpackung sprechen.

Auf Grund der schönen Verpackung würde sich das STARTERPAKET als Geschenk eignen,
doch der Beschenkte kann mit den Geschenk nichts anfangen da wesentliche Teile Fehlen.

Die im Starterpaket fehlenden  Teile.

1x USB 2.0 Verbindungskabel A/B   € 2.10

1x Steckboard (BreadBoard) SYB-46 € 1,95

2x 1,5k (br.gn.rt.) Widerstände   € 0,02

1x 10k (br.sw.or.)  Widerstand    € 0,01

1x LED rot 2mA (low current)      € 0,35

1x Miniatur Drucktaster (7x7mm)   € 0,28

1x LDR GL5528 Fotowiderstand / Foto lichtabhängiger Widerstand 50R bis 200k 80mW  € 1,49
Kupfer Schaltdraht Dm 0,64 (Jumper-Kabel-Draht / Einzelleiter)                    € 1,40

0,5m Verbindungs-Draht rot    
0,5m Verbindungs-Draht blau   
0,5m Verbindungs-Draht schwarz
0,5m Verbindungs-Draht gelb   
0,5m Verbindungs-Draht grün   
                                                                     Zusatzkosten € 7,59
Arduino kompatibles ATmega UNO R3 Board (mit DIL-28 Fassung)
USB Kabel enthalten - Simpleduino von Simple Development  € 13,90
http://physicalcomputing.at/

Fazit:
Das FRANZIS Starterpaket ARDUINO UNO kostet € 49,95 + € 8,00 Versandkosten

Das ARDUINO UNO SMD Rev3 Board kostet mit Kabel € 11,90

die unnötige Verpackung kostet daher € 38,05

und die notwendigen Bauteile kosten nur € 5,49 - die mitzuliefern ist nicht möglich ?

Wer die Bauteile hat  braucht die € 38,00 teure Verpackung nicht

und wenn das Starterpaket ein Geschenk sein soll müssen die Bauteile enthalten sein.

Startepaket besteht nur aus einer kostspieligen und unnötig großen massiven Karton-Kassette.

MfG

fritz prenninger

P.S.

Mein Tipp:

Kaufen Sie ein Arduino kompatibles ATmega UNO R3 Board (mit DIL-28 Fassung)

Und obige Bauteile alles zusammen um € 19,39

Das Handbuch dazu kostenlos im Internet oder von www.schaltungen.at downloaden.

Meine Seite http://sites.schaltungen.at/arduino-uno-r3/home/franzis-starterpaket genügt aber auch.

3-fach Starterpaket Arduino  € 69,95  + € 8,00 Versandkosten   vorhanden
Leonardo + Uno + Mega 2560

Der Name Arduino steht für eine ganze Familie unterschiedlich komplexer Mikrocontroller-Systeme mit passender Zusatzhardware in Form aufsteckbarer Platinen (Shields).
Werden Sie Teil der Arduino-Gemeinde und erleben Sie die schier endlosen Möglichkeiten, die Arduino bietet.
Für jede Aufgabe findet sich das passende Board oder das optimale ARDUINO Shield.
Mit diesem exklusiven 3er-Starterpaket erhalten Sie einen optimalen Einstieg in die Arduino-Welt mit drei unterschiedlichen Platinen
(Gesamtwert der puren Shields liegt alleine bei € 92,- )  für Ihre Programmier-Experimente!

ISBN: 978-3-645-40019-0

Wir werden Ihre Bestellung mit der Nummer 154880727 schnellstmöglich bearbeiten.

Details der FRANZIS Starterpakete siehe auch

http://sites.schaltungen.at/arduino-uno-r3/buecher/elo-buecher

ORIGINAL ARDUINO UNO UND HANDBUCH FÜR DEN SCHNELLEINSTIEG

Arduino — Feel the difference!
Der Name „Arduino steht für eine ganze Familie unterschiedlich komplexer Mikrocontroller-Systeme mit passender Zusatzhardware in Form aufsteckbarer Platinen (Shields).
Werden Sie Teil der Arduino-""-Gemeinde und erleben Sie die schier endlosen Möglichkeiten, die ArduinoT' bietet.
Für jede Aufgabe findet sich das passende Board oder das optimale Shield.

Arduino — Your powerful partneri
Das Starterpaket ArduinoT' Uno enthält das beliebte Board, basierend auf dem ATmega328.
Die Verbindung zum Computer und die Stromversorgung sind dank USB kein Problem.
14 digitale Ein- und Ausgänge (6 davon können als PWM-Kanäle genutzt werden), 6 analoge Eingänge, ein 16MHz Quartz, eine USB-Schnittstelle,
ein 6-poliger ISP-Anschluss und ein Reset-Button machen das Board zum perfekten Begleiter für Ihre ArduinoT'-Experience.

Arduino — Play it again!
Das Starterpaket garantiert Experimentierspaß und praktische Aha-Effekte:
Egal ob Sie ein eigenes Programm (Sketch) schreiben, die Experimente nachvollziehen oder sich Hintergrundwissen aneignen wollen

ISBN: 978-3-645-65203-2
Mehr Elektronik, Software, Bücher & Downloads unter www.elo-web.de 2013

Franzis Verlag GmbH
Richard-Reitzner-Allee 2
D-85540 Haar bei München

Programme & Aufbaupläne downloadbar von Fabian Kainka

http://fkainka.de/Arduino/Beispiele
http://fkainka.de/Arduino/Linkliste

Befehlsliste
http://fkainka.de/Arduino/Befehlsliste

http://arduino.cc/en/Reference/HomePage

ORIGINAL aus Italien  ARDUINO UNO SMD Rev3    A000073    vorhanden
Manufactured by ARDUINO S r .l . Via Romano 12 I-10010 Scarmagno / Italy

Information & Tutorials

ORIGINAL - Made in Italy

www.arduino.org   (Italien)

Mikrocontroller ATMEL   ATmega328P
USB-Controller  ATMEL   ATmega16U2

Arduino LLC    www.arduino.cc

https://store.arduino.cc/product/A000073   (USA)
http://www.arduino.cc/en/Main/Software

Virtuelle Steckboards Fritzing

fritzing-Sketche  *.fzz

http://fritzing.org/download/

Processing

http://www.processing.org/download

1. Das FRANZIS Starterpaket ARDUINO UNO  € 49,95 + € 8,00 Versandkosten   vorhanden

ARDUINO UNO Rev3  € 20,95

ISBN: 978-3-645-65203-2
Lieferumfang:
Schutzkarton,
64-Seiten Handbuch,
Platine: ARDUINO Uno

Das Starterpaket Arduino Uno enthält das beliebte Board, basierend auf dem ATmega328.
Die Verbindung zum Computer und die Stromversorgung sind dank USB kein Problem.
14 digitale Ein- und Ausgänge (6 davon können als PWM-Kanäle genutzt werden),
6 analoge Eingänge,
ein 16MHz-Quartz, eine USB-Schnittstelle, ein 6-poliger ISP-Anschluss
und ein Reset-Button machen das Board zum perfekten Begleiter für Ihre Arduino-Experience.

Das Starterpaket garantiert Experimentierspaß und praktische Aha-Effekte:
Egal ob Sie ein eigenes Programm (Sketch) schreiben, die Experimente nachvollziehen oder sich Hintergrundwissen aneignen wollen
... es unterstützt Sie bei der mühelosen Verwirklichung Ihrer Ideen.

Nur für absolute Anfänger mit einfachsten Sketchen und minimalen Bauteilen

	Bauteile	Seite	ARDUINO-Sketche
0. Vorwort		3
1. Schnet[start		6
Starthilfe		8	blink.ino
Drei Beispiele		9
Button		10	DigitalInputPullup.ino
Spannung messen		10	ReadAnalogVoltage.ino
Blinkfrequenz steuern		11	AnalogInput.ino
2. Hintergrundwissen		12
Einleitung		14
Die Hardware		15
Die Elemente des Boards		18
Mikrocontroller		18
USB-Controller		18
Spannungsregler		18
USB-Anschluss		18
Netzteil-Anschluss		18
ICSP-Anschlüsse		19
Reset-Button		19
LEDs		19
Quarz		19
Power-Pins		20
Optionale Zusatz-Pins		20
20 I/0-Pins   ( MEGA    54 I/O-Pins)		21
Die Software		22
Installieren und verbinden		22
Die Programmierumgebung		24	blink.ino
Grundstruktur eines Programms		34
3. Do it Yourself		38
Vorbereitungen		40
Projekte zum Nachbauen	§ 1,5k LED2mA	42
Die erste LED		42
Schalter	§ 1,5k LED2mA	45	LED1.ino
		46	Schalter1.ino
		47	Schalter2.ino
		48	Schalter3.ino
PWM	§ 1,5k LED2mA	49	PWM1.ino
Senden über die serielle Schnittstelle		51	Seriell1.ino
Analog einlesen	§ LDR07 1,5k 10k LED2mA	53	AnalogIn1.ino
Tipps und Hilfestellungen		56
Zusatzprogramme		56
Liste der Befehle		59
Problemlösungen		62
Linkliste		64

715_d_FRANZIS-x_65203-2 Starterpaket ARDUINO UNO - Sketche_1a.zip

ARDUINO IDE 1.0.5  (2013-01-01)

ARDUINO IDE 1.6.4  (2015)

ARDUINO-IDE MENU > Datei > Beispiel > 01 Basics  > Blink.ino
                                                                     02 Digital  >
                                                                     03 Analog >

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  Most Arduinos have an on-board LED you can control. On the Uno and
  Leonardo, it is attached to digital pin 13. If you're unsure what
  pin the on-board LED is connected to on your Arduino model, check
  the documentation at http://arduino.cc

  This example code is in the public domain.

  modified 8 May 2014
  by Scott Fitzgerald
 */

// Blink.ino

                            // the setup function runs once when you press reset or power the board
void setup() {
                            // initialize digital pin-13 as an output.
  pinMode(13, OUTPUT);
}

                            // the loop function runs over and over again forever
void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);              // wait for a second
}

// DigitalInputPullup.ino

void setup() {
                            // start serial connection
  Serial.begin(9600);
                            // configure pin2 as an input and enable the internal pull-up resistor
  pinMode(2, INPUT_PULLUP);
  pinMode(13, OUTPUT);

}

void loop() {
                            // read the pushbutton value into a variable
  int sensorVal = digitalRead(2);
                            // print out the value of the pushbutton
  Serial.println(sensorVal);

                            // Keep in mind the pullup means the pushbutton's
                            // logic is inverted. It goes HIGH when it's open,
                            // and LOW when it's pressed. Turn on pin 13 when the
                            // button's pressed, and off when it's not:
  if (sensorVal == HIGH) {
    digitalWrite(13, LOW);
  }
  else {
    digitalWrite(13, HIGH);
  }
}

// ReadAnalogVoltage.ino

/*
  ReadAnalogVoltage
  Reads an analog input on pin 0, converts it to voltage, and prints the result to the serial monitor.
  Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.

 This example code is in the public domain.
 */

                     // the setup routine runs once when you press reset:
void setup() {
                     // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
}

                     // the loop routine runs over and over again forever:
void loop() {
                     // read the input on analog pin 0:
  int sensorValue = analogRead(A0);
                     // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
  float voltage = sensorValue * (5.0 / 1023.0);
                     // print out the value you read:
  Serial.println(voltage);
}

// AnalogInput.ino

 // By Tom Igoe
 // This example code is in the public domain.
 // http://arduino.cc/en/Tutorial/AnalogInput

int sensorPin = A0;    // select the input pin for the potentiometer
int ledPin = 13;       // select the pin for the LED
int sensorValue = 0;   // variable to store the value coming from the sensor

void setup() {
                       // declare the ledPin as an OUTPUT:
  pinMode(ledPin, OUTPUT);
}

void loop() {
                       // read the value from the sensor:
  sensorValue = analogRead(sensorPin);
                       // turn the LED-pin on
  digitalWrite(ledPin, HIGH);
                       // stop the program for <sensorValue> milliseconds:
  delay(sensorValue);
                       // turn the LED-pin off:
  digitalWrite(ledPin, LOW);
                       // stop the program for for <sensorValue> milliseconds:
  delay(sensorValue);
}

// AnalogIn.ino

int led = 3;             // ab nun bedeutet LED=3
int LDR = A0;            // ab nun bedeutet LDR=0
byte helligkeit = 0;     // Zustandsvariable der Helligkeit

void setup() {
  pinMode (led, OUTPUT); // pin-0 als Ausgang definieren
  Serial.begin (9600);   // Serielle Schnittstelle initialisieren
}

void loop() {
  helligkeit = analogRead(LDR)/4;  // Messbereich an Ausgabebereich anpassen
  analogWrite(led, helligkeit);    // Helligkeit an LED ausgeben
 
  Serial.println(analogRead(LDR)); // Messergebnis an PC senden
  delay(10);                       // Wartezeit 10ms
}

// AnalogIn1.ino

int led = 3;             // ab nun bedeutet LED=3
int LDR = A0;            // ab nun bedeutet LDR=0
byte helligkeit = 0;     // Zustandsvariable der Helligkeit

void setup() {
  pinMode (led, OUTPUT); // pin-0 als Ausgang definieren
  Serial.begin (9600);   // Serielle Schnittstelle initialisieren
}

void loop() {
  helligkeit = analogRead(LDR);   // Messen
  Serial.println(helligkeit);     // Messergebnis an PC senden
  analogWrite(led, helligkeit/4); // angepasste Helligkeit an LED ausgeben
  delay(10);                      // Wartezeit 10ms
}

// AnalogIn2.ino

int led = 3;             // ab nun bedeutet LED=3
int LDR = A0;            // ab nun bedeutet LDR=0
byte helligkeit = 0;     // Zustandsvariable der Helligkeit

void setup() {
  pinMode (led, OUTPUT); // pin-0 als Ausgang definieren
  Serial.begin (9600);   // Serielle Schnittstelle initialisieren
}

void loop() {
  helligkeit = analogRead(LDR);                       // Messen
  Serial.println(helligkeit);                         // Messergebnis an PC senden
  analogWrite(led, map(helligkeit, 0, 1023, 0, 255)); // angepasste Helligkeit an LED ausgeben
  delay(10);                                          // Wartezeit 10ms
}

// LED0.ino

void setup() {
  pinMode (0, OUTPUT);  // pin-0 als Ausgang definieren
}

void loop() {
  digitalWrite(0,HIGH); // pin-0 auf HIGH setzen
}

// LED1.ino

int led = 0;              // ab nun bedeutet LED=0

void setup() {
  pinMode (led, OUTPUT);  // pin-0 als Ausgang definieren
}

void loop() {
  digitalWrite(led,HIGH); // pin-0 auf HIGH setzen
}

// LichtAuto.ino

int led = 3;             // ab nun bedeutet LED=0
int ledrot =11 ;
int ledgruen =10;
int ledblau = 9;

int schalter = 5;        // ab nun bedeutet Schalter=5
byte helligkeit = 0;

void setup() {
  pinMode (led, OUTPUT); // pin-0 als Ausgang definieren
  pinMode (ledrot, OUTPUT);
  pinMode (ledgruen, OUTPUT);
  pinMode (ledblau, OUTPUT); 
  pinMode (schalter, INPUT);     // pin-5 als Eingang definieren
  digitalWrite (schalter, HIGH); // pin-5 HIGH setzen für internen Interrupt
  Serial.begin(9600);
}

void loop() {
   Serial.println("Hallo was geht alter");
    analogWrite (ledblau,255);
//  if (digitalRead (schalter)  == LOW) {
//    helligkeit = helligkeit +25;
//    analogWrite(led, helligkeit);
//    delay(100);                 // Wartezeit 100ms

// }
while(true); 
}

// PWM1.ino

int led = 3;                            // ab nun bedeutet LED=3
int schalter = 6;                       // ab nun bedeutet Schalter=6
byte helligkeit = 0;                    // Zustandsvariable der Helligkeit

void setup() {
  pinMode (led, OUTPUT);                // pin-0 als Ausgang definieren
  pinMode (schalter, INPUT_PULLUP);     // pin-6 als Eingang definieren
 }

void loop() {
  if (digitalRead (schalter)  == LOW) { // WENN Schalter gedrückt DANN {...}
      helligkeit = helligkeit +1;       // Helligkeitsvariable um 1 erhöhen
      analogWrite(led, helligkeit);     // Helligkeit an LED ausgeben
      delay(5);                         // Wartezeit 5ms
     }
}

// Schalter1.ino

int led = 0;                 //ab nun bedeutet LED=0
int schalter = 6;            //ab nun bedeutet Schalter=6
 
void setup() {
  pinMode (led, OUTPUT);     //pin-0 als Ausgang definieren
  pinMode (schalter, INPUT); //pin-6 als Eingang definieren
}

void loop() {
  digitalWrite(led,digitalRead(schalter)); // pin-0 auf den Wert von pin-6 setzen
}

// Schalter2.ino

int led = 0;                     //ab nun bedeutet LED=0
int schalter = 6;                //ab nun bedeutet Schalter=6
 
void setup() {
  pinMode (led, OUTPUT);         //pin-0 als Ausgang definieren
  pinMode (schalter, INPUT);     //pin-6 als Eingang definieren
  digitalWrite (schalter, HIGH); //pin-6 HIGH setzen für internen Pullup
}

void loop() {
  digitalWrite(led,digitalRead(schalter)); // pin-0 auf den Wert von pin-5 setzen
}

// Schalter3.ino

int led = 0;                         // ab nun bedeutet LED=0x
int schalter = 6;                    // ab nun bedeutet Schalter=6
 
void setup() {
  pinMode (led, OUTPUT);             // pin-0 als Ausgang definieren
  pinMode (schalter, INPUT_PULLUP);  // pin-6 als Eingang mit internen PullUp definieren
}

void loop() {
  digitalWrite(led,!digitalRead(schalter)); // pin-0 auf den Wert von pin-5 setzen
}

// Seriell1.ino

int led = 3;           // ab nun bedeutet led=3
int schalter = 6;      // ab nun bedeutet schalter=6
byte helligkeit = 0;   // Zustandsvariable der Helligkeit

void setup() {
  pinMode (led, OUTPUT);            // pin-0 als Ausgang definieren
  pinMode (schalter, INPUT_PULLUP); // pin-6 als Eingang definieren
   Serial.begin (9600);             // Serielle Schnittstelle initialisieren
}

void loop() {
  if (digitalRead (schalter)  == LOW) { // WENN Schalter gedrückt DANN {...}
    helligkeit = helligkeit +1;         // Helligkeitsvariable um 1 erhöhen
    Serial.print ("Helligkeit: " );     // Helligkeit ausgeben (Text)
    Serial.println (helligkeit);        // Helligkeit ausgeben (Wert)
    analogWrite(led, helligkeit);       // Helligkeit an LED ausgeben
    delay(5);                           // Wartezeit 5ms
  }
}

Franzis Starterpaket Arduino UNO.zip
x715_d_FRANZIS-x_65203-2 Starterpaket ARDUINO UNO - Das Handbuch (65 Seiten)_1a.pdf
http://www.elo-web.de/elektronik-lernpakete/bauteile/das-franzis-starterpaket-arduino-uno
http://www.franzis.de/elektronik/arduino-platinen/das-franzis-starterpaket-arduino-uno

2. Das FRANZIS Starterpaket ARDUINO Leonardo  € 49,95 + € 8,00 Versandkosten   vorhanden

ARDUINO LEONARDO  € 21,95

ATMEL ATmega32u4


ISBN: 978-3-645-65163-9
https://store.arduino.cc/product/A000057   (USA)


ISBN: 978-3-645-65202-5
Lieferumfang:
Schutzkarton,
64-Seiten Handbuch,
Platine: ARDUINO Leonardo

Das Starterpaket Arduino Leonardo enthält das beliebte Board, basierend auf dem ATmega32U4.
Es bietet größere Flexibilität in der Kommunikation mit dem Computer. Leonardo ist Arduinos erstes Entwicklungs-Board für die Nutzung eines Mikrocontrollers mit integriertem USB.
Der ATmega32U4 in Verbindung mit fertigen Code-Bibliotheken erweitert die Möglichkeiten des Boards.
Damit kann das Board Computertastatur, Maus und andere Geräte, die das USB-HID-Protokoll verwenden, nachahmen.

Original Arduino Leonardo und Handbuch für den Schnelleinstieg.
Für jede Aufgabe findet sich das passende Board oder das optimale Shield. Arduino.

Franzis Starterpaket Arduino Leonardo-Micro.zip
x715_d_FRANZIS-x_65202-5 Starterpaket ARDUINO Leonardo - Das Handbuch (65 Seiten)_1a.pdf
http://www.elo-web.de/elektronik-lernpakete/bauteile/das-franzis-starterpaket-arduino-leonardo
http://www.franzis.de/elektronik/arduino-platinen/das-franzis-starterpaket-arduino-leonardo

 

3. Das FRANZIS Starterpaket ARDUINO Mega 2560  € 69,95 + € 8,00 Versandkosten   vorhanden

ARDUINO MEGA  € 49,95


ATMEL ATmega2560
 
ISBN: 978-3-645-65144-8
https://store.arduino.cc/product/A000069   (USA)



ISBN: 978-3-645-65204-9
Lieferumfang:
Schutzkarton,
64-Seiten Handbuch,
Platine: ARDUINO Mega 2560

Das Starterpaket Arduino Mega 2560 enthält das beliebte Board, basierend auf dem ATmega2560.
Das Board besitzt
54 digitale I/O-Pins (von denen 14 als PWM-Ausgänge verwendet werden können),
16 analoge Eingänge,
 4 UARTs (serielle Hardware-Schnittstellen),
 1 16-MHz-Kristalloszillator,
eine USB-Schnittstelle, einen Stromanschluss, einen ICSP-Header und einen Rückstellknopf.
Das Mega-Board ist kompatibel mit den meisten Shields, die für ARDUINO Due, Duemilanove oder Diecimila entwickelt wurden.

Das Starterpaket garantiert Experimentierspaß und praktische Aha-Effekte:
Egal ob Sie ein eigenes Programm (Sketch) schreiben, die Experimente nachvollziehen oder sich Hintergrundwissen aneignen wollen
... es unterstützt Sie bei der mühelosen Verwirklichung Ihrer Ideen.

Franzis Starterpaket Arduino Mega 2560.zip
x715_d_FRANZIS-x_65204-9 Starterpaket ARDUINO Mega 2560 - Das Handbuch (65 Seiten)_1a.pdf
http://www.elo-web.de/elektronik-lernpakete/bauteile/das-franzis-starterpaket-arduino-mega-2560
http://www.franzis.de/elektronik/arduino-platinen/das-franzis-starterpaket-arduino-mega-2560

Befehlsliste ARDUINO-IDE

Oft ist es so, dass man plötzlich vergisst, wie man jetzt gerade in dieser Programmiersprache einen Bestimmten Befehl formulieren muss.
Deswegen steht hier eine Auflistung der wichtigsten Befehle.
Benutzen Sie Stg+F um in der Seite nach etwas bestimmten zu suchen.

Befehl	Schreibweise
Grundlegendes
Grundstruktur	void setup() {   } void loop()  {   }
Variable deklarieren (Typ Integer, Wert = 0)	int led  = 0;
Konstante deklarieren (Typ Integer, Wert = A0)	const int analogInPin = A0;
Array deklarieren (Typ Integer, 6 Werte)	int Arrayname[6] = {2, 4, -8, 3, 2};
Pin-Funktion festlegen	pinMode(led, OUTPUT);
Library einbinden	#include <libX.h>
Ausgaben/Eigaben
Pin auf HIGH schalten	digitalWrite(led,HIGH);
PWM-Pin auf maximal Wert setzen	analogWrite(led, 255);
Digitalen Zustand von Pin schalter lesen	digitalRead(schalter)
Funktion: Analog Pin A0 auslesen	analogRead(A0)
Ton Ausgabe an Pin8, Frequenz x, länge y	tone(8, x, y)
Ton Ausgabe an Pin8 stoppen	noTone(8)
Serielle Schnittstelle
Serielle Schnittstelle initialisieren	Serial.begin(9600);
Text seriell Ausgeben	Serial.print(“Hallo”);
Text seriell Ausgeben + neue Zeile	Serial.println(“Hallo”);
Byte seriell Ausgeben	Serial.write(val)
Funktion: Anzahl von auslesbaren Bytes	Serial.available()
Funktion: seriell Einlesen	Serial.read();
Funktion: Text im Buffer finden (true/false)	Serial.find(„TEXT“)
Funktion: Text i. Buffer finden bis Endetext	Serial.findUntil(“TEXT“,“ENDE TEXT“)
Speichert Anzahl Bytes in Buffer	Serial.readBytes(buffer, length)
Speichert Bytes in Buffern bis lenght oder Ende-chracter erreicht	Serial.readBytesUntil(character, buffer, length)
Funktion: Findet nächste Integerzahl	Serial.parseInt()
Prozedur aufgerufen wenn Daten vorhanden	void serialEvent()
Abfragen/Schleifen
If-Abfrage mit Else	if (button == HIGH){    }else{   }
Switch-Abfrage	switch (x) {    case 1:       case 2:       default:
Wartezeit (500 ms)	delay(500);
For-Schleife	for (x = 2; x < 7; x++) {      }
While-Schleife	while (schalter== HIGH) {  }ODER: do{} while (schalter==HIGH);
Schleife vorzeitig verlassen	break;
Überspringt ausführbaren Quelltext in Schleife	continue;
Mathematisches
Sinus, Cosinus, Tangens	sin(),cos(),tan()
Wurzel aus X	sqrt(x)
X hoch Y : xy	pow(x, y)
Absolut Wert einer Zahl (Betrag von x)	abs(x)
Zufällige Zahl	random()
Vergleiche
gleich	==
ungleich	!=
größer, kleiner	<, >
Größer oder gleich, kleiner oder gleich	<= , >=
Funktion: kleinere Zahl von x und y	min(x, y)
Funktion: größere Zahl von x und y	max(x, y)
Boolsche Operatoren
Und	&&
Oder	||
Nicht	!
Datentypen	Boolean; char; unsigned char; byte; int; unsigned int; word; long; unsigned long; short; float; double; string; String;
Datentypkonvertierungen	char(); byte(); int(); word(); long(); float()
Interrupts
Interrupts verbieten	noInterrupts()
Interrupts erlauben	nterrupts()
Interrupt an Pin mit Funktion verknüpfen	attachInterrupt(interrupt, function, mode)
Interrupt Verbindung aufheben	detachInterrupt(interrupt)
Sonstiges
Kommentar eine Zeile	//
Kommentar längerer Bereich	/*                */
Array definieren
Funktion: Wertebereich transformieren (z.B. 10bit Sensor auf 8bit PWM)	map(sensorWert, 0, 1024, 0, 255);
Funktion Wertgrenzen bestimmen(alles darüber/darunter wird abgeschnitten)	constrain(sensorWert, 0, 255);
Bein Funktionen: Wert zurückgeben	return x;
Zum Sprungpunk hier springen	goto hier;
Prozedur	Void Prozedurname() {   }
Funktion mit Integer-Rückgabewert und Byte-Parameter	int Funktionsname (byte Parameter) {return 13;}

Eine komplette Befehlsliste auf Englisch und mit erweiterten Erklärungen finden Sie auch unter http://arduino.cc/en/Reference/HomePage.

Quelle:
http://wp.fkainka.de/befehlsliste-arduino/

ARDUINO Linkliste

Link	Beschreibung	Sprache
http://arduino.cc/forum/	Offizielles Arduino Forum	Viel in Englisch aber auch auf Deutsch
http://playground.arduino.cc/	Tutorials, Anleitungen und mehr.	Auf Englisch mit deutscher Unterseite (z.Z. noch im Aufbau)
http://www.mikrocontroller.net	Immer eine gute Wahl, wenn es um Mikrocontroller geht	Komplett auf Deutsch mit unzähligen, strukturierten Themen
http://arduino.cc/en/Reference/HomePage	Komplette Befehlsliste	Auf Englisch
http://www.arduino-tutorial.de/	Gutes Tutorial mit vielen Erklärungen für Einsteiger	Deutsch
http://playground.arduino.cc/ interfacing/processing	Hilfe zum Thema Arduino und Processing	Englisch
http://shieldlist.org/	Liste aller Arduino-Shields	Englisch
http://www.golem.de/specials/arduino/	Interessante Projekte mit ausführlichen Artikeln	Deutsch
http://www.arduinoforum.de/	Projekte und Hilfe	Deutsch
http://fff2.at/drupal/content/arduino-projekte	Projekte und Code-Beispiele	Deutsch
http://www.ladyada.net/make/	Projekte	Englisch
http://wiring.org.co/ learning/basics/index.html	Code-Beispiele	Englisch
http://playground.arduino.cc/Projects/Ideas	Projekt Ideen	Englisch
http://hacknmod.com/hack/ top-40-arduino-projects-of-the-web/	Top 40 Arduino Projekte	Englisch
http://practicalarduino.com/projects	Projekte	Englisch
http://fritzing.org/projects/	Projekte	Englisch
http://www.arduinoevilgenius.com/projects	Projekte	Englisch
http://hacknmod.com/topics/arduino/	Projekte

Quelle:
http://fkainka.de/arduino-linkliste/

Die Software
ARDUINO IDE installieren und verbinden,
unter Windows.

Die Entwicklungsumgebung ARDUINO-IDE 1.0.5 nach dem erfolgreichen Upload


Unter Windows ist die Softwareinstallation problemlos. Die aktuelle Version findet Sie immer unter:
http://www.arduino.cc/en/Main/software
Seit ARDUINO-IDE Version 1.0.5 (2013-01-0) können Sie auch eine Installationsdatei laden.
Diese Exe-Datei funktioniert wie jede Installation, indem sie mit Doppelklick ausgeführt wird.
Nachdem Sie sich durch die Dialoge geklickt haben, wird das Programm inklusive der Treiber installiert.
Sie müssten dann einfach nur Ihren Arduino mit einem USB-Kabel mit dem PC verbinden, und der Rechner sollte die Hardware erkennen.
Unter Umständen kann es auch sinnvoll sein, die Zip-Datei zu laden. Möchten Sie Arduino
z. B. auf einem USB-Stick installieren, müssen Sie nur die Zip-Datei in den entsprechenden Ordner entpacken.
In dem entpackten Ordner befindet sich eine Exe-Datei.
Es ist praktisch, sich sofort eine Verknüpfung auf dem Desktop zu erstellen.
Am leichtesten geht das, indem Sie mit der rechten Maustaste auf die Exe-Datei
und anschließend mit der linken Maustaste auf den Befehl klicken [Senden an > Desktop (Verknüpfung erstellen)].
Das Programm gleich zu starten, ist zu diesem Zeitpunkt noch nicht sinnvoll, denn Sie müssen zunächst den Treiber des Boards installieren.
Wenn Sie das Board per USB mit dem Rechner verbinden, versucht der PC, den Treiber selbst zu finden und zu installieren.
Das wird aber zu keinem Ergebnis führen.
Also müssen Sie im Gerätemanager (Start > Systemsteuerung > System > Gerätemanager) das Board suchen
und dort auf den Befehl klicken Treiber aktualisieren.
Daraufhin können Sie unter dem Punkt Auf dem Rechner nach Treibersoftware suchen eine Quelle angeben.
Diese Quelle ist der Ordner, in den Sie zuvor das Arduino-Zip entpackt haben, genauer gesagt dessen Unterorder Drivers.


Wenn Sie das Board per USB mit dem Rechner verbinden, versucht der PC in der Regel, den Treiber selbst zu finden und zu installieren.


Nach einer Warnung, dass der Treiber aus einer unbekannten Quelle stammt, installiert sich der Treiber,
und das Board wird im Gerätemanager unter Anschlüsse angezeigt.
Hinter dem Board steht noch eine COM-Nummer. Diese sollten Sie sich für später merken.

Merken Sie sich die COM-Nummer hinter dem Board für später!


Die Programmierumgebung
Nach der erfolgreichen Treiberinstallation können Sie nun die Arduino-Software starten.
Anschließend stellen Sie eine Verbindung zu Ihrem Board her.
Das geht ganz einfach, indem Sie Tools > Board > Arduino Uno
und anschließend unter Tools > Serieller Port den bei der Installation vergebenen Port auswählen.
Es werden automatisch mögliche COM-Schnittstellen angezeigt.

Nach der erfolgreichen Treiberinstallation können Sie die Arduino-Software starten.

Ob der Verbindungsaufbau erfolgreich war, sehen Sie erst, wenn Sie Ihr erstes Programm übertragen.
Deswegen laden Sie einfach durch Klick auf Datei > Beispiele > 01.Basics > Blink ein Beispiel
und übertragen es anschließend mit dem Upload-Button in der Symbolleiste.
Das Programm wird nun kompiliert und anschließend auf den Controller geladen.
Die Rx-LED sollte auf Ihrem Controller während des Upload-Vorgangs unregelmäßig blinken.
War der Vorgang erfolgreich, erscheint nach kurzer Wartezeit die Meldung Upload abgeschlossen.
Der Verbindungsaufbau war also erfolgreich.
Außerdem können Sie die Leiterplatten-LED (pin-13) im Sekundentakt blinken sehen.

Die Rx-LED sollte auf Ihrem Controller während des Upload-Vorgangs unregelmäßig blinken.



Quelle: Florian Kainka
http://wp.fkainka.de/

*********************************************************

Das FRANZIS ARDUINO Lernpaket

https://www.franzis.de/maker/raspberry-pi-arduino-und-mehr/das-franzis-arduino-lernpaket-experimentierbox

Für Kinder unter 14 Jahren nicht geeignet!

Leseprobe

https://www.franzis.de/media/pdf/17/25/96/67032-8_LP_Das-Franzis-Arduino-Lernpaket.pdf

• Autor:Uli Sommer
• ISBN:40 19631 67032-8

Mit diesem Lernpaket entdecken Sie die Grundlagen der Elektronik und der Arduino™-Programmierung. Schritt für Schritt erfahren Sie, wie Sie vorgehen müssen, um Ihre Ideen in die Praxis umzusetzen. Egal ob Sie eine Haussteuerung oder eine LED-Leuchte mit Farbwechsel bauen möchten - mit Arduino™ verwirklichen auch Quereinsteiger ihre eigenen Ideen.

• Inkl. Arduino™-Uno-Platine
• 70 Projekte zum Nachmachen
• Komplett: alle Bauteile enthalten
• Einsteiger-gerechte Programmiersoftware
• 300 Seiten Handbuch

• Seiten: 310
  
• Verlag: Franzis (29. Juli 2013)
• Sprache: Deutsch
• ISBN-10: 3645651489
• ISBN-13: 978-3645651486
• Größe: 24 x 17 x 1,5 cm

Lernpaket Arduino von Franzis

Alles für den Einstieg
Dieses Lernpaket bietet alles, was Sie für Ihren Einstieg in die Programmierung benötigen: original Arduino -Uno-Platine, Steckboard, Bauteile sowie ein 300-seitiges Handbuch und Software. So gelingen Ihre Projekte, und Arduino erwacht zum Leben.
Projekte die jeder programmieren kann!
Egal ob Sie eine Haussteuerung oder eine LED-Leuchte mit Farbwechsel bauen möchten - mit Arduino gelingt es auch Quereinsteigern, die ersten Programme zu schreiben und so die eigenen Ideen zu verwirklichen. Mit diesem Lernpaket entdecken Sie die Grundlagen der Elektronik und der Arduino -Programmierung und erfahren Schritt für Schritt, wie Sie vorgehen müssen, um Ihre Ideen in die Praxis umzusetzen.
70 mitreißende Projekte, die wirklich jeden aus den Platinen hauen
Werden Sie zum Spezialagenten, der Codeschlösser knackt und Hinterausgänge überwacht. Oder schlüpfen Sie in die Rolle des Maestro Arduino , und spielen Sie Musik oder komponieren Sie Ihre eigenen Songs. Oder entflammen Sie als Casanova mit dem Romantic Light die Herzen der Damenwelt.
Worauf warten Sie noch? Legen Sie los. Starten Sie mit Arduino in das neue kreative Zeitalter der Programmierung.
Diese Projekte lassen sich verwirklichen: Programmieren mit Schleifen Zufallszahlen generieren Ein einfaches Game Stoppuhr Spannung messen LED-Dimmer Ein- und Ausschaltverzögerung Musik mit ArduinoTM Mikrocontroller-Kerzenlicht Ausgänge überwachen Schuluhr Lüftersteuerung Dämmerungsschalter Alarmanlage Codeschloss Spannungsplotter Speicheroszilloskop Temperaturschalter Romatic Light Zeitschaltuhr Melodien komponieren State Machine Kapazitätsmesser ... und viele mehr

Sie benötigen: USB-Anschlusskabel

Wer schon länger die fantastischen Möglichkeiten des Arduino ausprobieren wollte, aber bisher nicht den passenden Einstieg gefunden hat, der muss nicht mehr länger warten.

Das Lernpaket Arduino von Franzis umfasst die Original-Arduino-UNO-Platine, die dazugehörige Software auf CD-ROM, Steckboard, 20 elektronische Bauteile und ein 300-seitiges Handbuch. Damit bietet dieses Lernpaket alles, was für einen schnellen und einfachen Einstieg in die Arduino-Programmierung benötigt wird.

Mit diesem Lernpaket entdecken Sie die Arduino-Programmierung und Grundlagen der Elektronik. Sie erfahren Schritt für Schritt, wie Sie vorgehen müssen, um Ihre Ideen in die Praxis umzusetzen. Egal, ob Sie eine Haussteuerung oder eine LED-Leuchte mit Farbwechsel bauen möchten, mit diesem Lernpaket gelingt es auch Quereinsteigern, Programme für den Arduino zu schreiben und eigene Ideen zu verwirklichen.

Folgende Anwendungen können aus dem Handbuch und den beiliegenden Bauteilen verwirklicht werden:

• Ein einfaches Game
• Stoppuhr
• Spannung messen
• LED-Dimmer
• Ein- und Ausschaltverzögerung
• Musik mit Arduino
• Kerzenlicht-Simulation
• Ausgänge überwachen
• Schuluhr
• Lüftersteuerung
• Dämmerungsschalter
• Alarmanlage
• Codeschloss
• Spannungsplotter
• Speicheroszilloskop
• Temperaturschalter
• Romantic Light
• Zeitschaltuhr
• Melodien komponieren
• State Machine
• Kapazitätsmesser
• und vieles mehr

Die Bauteile im Überblick:

• 1 Arduino-Board UNO R3
  
• kein mit geliefertes USB Anschlusskabel
• 1 Steckboard klein
  
• 2 Taster
• 1 Lichtsensor LDR A9060-13 (R100 = 5 kOhm)
• 1 NPN-Transistor BC548C
• 1 Silizium-Diode 1N4148
• 1 Piezo-Schallwandler
• 1 LED 5mm  rot
• 1 LED 5mm grün
• 2 LED 5mm gelb
• 3 Widerstände 1,5k Ohm
• 1 Widerstand   4,7k Ohm
• 1 Widerstand   47k Ohm
• 1 Widerstand   10k Ohm
• 1 Widerstand   68k Ohm
• 1 Trimmwiderstand 10k Ohm   (PIHER PT10)
• 1 Kondensator 1μF
• 1 1m isolierter Schaltdraht  Dm=0,64mm
  
• 
  

Zusätzlich benötigt wird ein USB-Anschlusskabel, was in der Regel jeder in Reserve daheim hat.

• Arduino-Lernpaket mit Original UNO-Platine von Franzis

Wer auf Handbuch und Bauteile verzichten und die Software zum Programmieren aus dem Internet laden kann, der kauft einfach nur die Platine.

• Arduino UNO R3
• Download: Entwicklerkit Arduino

Ein Arduino Uno kostet 20 €, 4 LEDs, ein paar Widerstände, Draht(ohne Microstecker, dafür zum selber abisolieren) und eine viel zu kleines Breadbord kosten höchstens 5 €, für das beiligende Buch alleine würde ich nichtmal 20 € auf den Tisch legen. Macht alles in allem ein Wert von nicht mal 45 €. ABER kosten tut das Paket fast 80 €.

Zum Buch selber, einige Inhalte finde ich Seitenschinderei - seitenweise werden die Verschiedenen Arduino Modelle vorgestellt, aber was interessieren mich die, wenn doch ein UNO beiliegt? Den Aufbau des Buches finde ich nicht sehr logisch und schon gar nicht didaktisch. Wichtige Informationen für den Einstieg wie die Berechnung vor Vorwiderständen für LEDs werden irgendwo nebenbei abgehandelt. Veranschaulichungen der Zusammenhänge fehlen gänzlich. Die Projekte sind zum größtenteil einfach langweilig für den Einstieg - Tasterentprellen mag wichtig sein, ist aber für den Einstieg eher langweilig.

https://www.elektronik-kompendium.de/sites/com/1810231.htm

CONRAD Lernpaket Arduino

FRANZIS Lernpaket Arduino

ELVjournal 6/2010

092_d_ELVjournal-x_2010-06sXX  68-95116 FRANZIS Lernpaket ARDUINO - Mikrocontroller-Programm._1a.pdf

*********************************************************

MAKER KIT für ARDUINO   € 79,95

ISBN:40 19631 67084-7

Demoversion

715_d_ARDUINO-x_67084-7 Franzis Maker-Kit-Arduino Zusatzmaterial_1a.zip

DIN A4 ausdrucken
*********************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE