Startseite‎ > ‎

FRANZIS Starterpaket

http://sites.prenninger.com/arduino-uno-r3/home/franzis-starterpaket

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                        Wels, am 2015-12-02

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************
   ~015_b_PrennIng-a_arduino.uno.r3-home-franzis.starterpaket (xx Seiten)_1a.pdf


[1] www.arduino.cc
[2] www.arduino.cc//en/Main/Hardware
[3] www.freeduino.org
[4] www.processing.org
[5] ELVjournal 3/2010, S. 54
[6] www.freeduino.de
[7] www.watterott.com
[8] www.elmicro.com
[9] http://fritzing.org
[10] www.arduino.org
[11] http://diydrones.com

Arduino.org und Arduino.cc


    Hinweis in eigener Sache zu FRANZIS Starterpakete
     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.prenninger.com/arduino-uno-r3/home/franzis-starterpaket genügt aber auch.

siehe auch
http://sites.prenninger.com/arduino-uno-r3/arduino-starterpaket



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.prenninger.com/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.


BefehlSchreibweise
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 festlegenpinMode(led, OUTPUT);    
Library einbinden#include <libX.h>

 
Ausgaben/Eigaben 
Pin auf HIGH schaltendigitalWrite(led,HIGH);
PWM-Pin auf maximal Wert setzenanalogWrite(led, 255);    
Digitalen Zustand von Pin schalter lesendigitalRead(schalter)
Funktion: Analog Pin A0 auslesenanalogRead(A0)
Ton Ausgabe an Pin8, Frequenz x, länge ytone(8, x, y)
Ton Ausgabe an Pin8 stoppennoTone(8)


Serielle Schnittstelle 
Serielle Schnittstelle initialisierenSerial.begin(9600);
Text seriell AusgebenSerial.print(“Hallo”);
Text seriell Ausgeben + neue ZeileSerial.println(“Hallo”);
Byte seriell AusgebenSerial.write(val) 
Funktion: Anzahl von auslesbaren BytesSerial.available()
Funktion: seriell EinlesenSerial.read();
Funktion: Text im Buffer finden (true/false)Serial.find(„TEXT“)
Funktion: Text i. Buffer finden bis EndetextSerial.findUntil(“TEXT“,“ENDE TEXT“)
Speichert Anzahl Bytes in BufferSerial.readBytes(buffer, length)
Speichert Bytes in Buffern bis lenght oder Ende-chracter erreichtSerial.readBytesUntil(character, buffer, length)
Funktion: Findet nächste IntegerzahlSerial.parseInt()
Prozedur aufgerufen wenn Daten vorhandenvoid serialEvent()

 
Abfragen/Schleifen             
If-Abfrage mit Elseif (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-Schleifewhile (schalter== HIGH) {  }ODER: do{} while (schalter==HIGH);
Schleife vorzeitig verlassenbreak;
Überspringt ausführbaren Quelltext in Schleifecontinue;

 
Mathematisches 
Sinus, Cosinus, Tangenssin(),cos(),tan()
Wurzel aus Xsqrt(x)
X hoch Y : xypow(x, y)
Absolut Wert einer Zahl (Betrag von x)abs(x)
Zufällige Zahlrandom()
  
Vergleiche   
gleich==
ungleich!=
größer, kleiner<, >
Größer oder gleich, kleiner oder gleich<= , >=
Funktion: kleinere Zahl von x und ymin(x, y)
Funktion: größere Zahl von x und ymax(x, y)
  
Boolsche Operatoren   
Und&&
Oder||
Nicht!
 
DatentypenBoolean; char; unsigned char; byte; int; unsigned int; word; long; unsigned long; short; float; double; string; String;

 
Datentypkonvertierungenchar(); byte(); int(); word(); long(); float()

 
Interrupts 
Interrupts verbietennoInterrupts()
Interrupts erlaubennterrupts()
Interrupt an Pin mit Funktion verknüpfenattachInterrupt(interrupt, function, mode)
Interrupt Verbindung aufhebendetachInterrupt(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ückgebenreturn x;
Zum Sprungpunk hier springengoto hier;
ProzedurVoid Prozedurname() {   }
Funktion mit Integer-Rückgabewert und Byte-Parameterint 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

LinkBeschreibungSprache
http://arduino.cc/forum/Offizielles Arduino ForumViel 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.netImmer eine gute Wahl, wenn es um Mikrocontroller gehtKomplett auf Deutsch mit unzähligen, strukturierten Themen
http://arduino.cc/en/Reference/HomePageKomplette BefehlslisteAuf Englisch
http://www.arduino-tutorial.de/Gutes Tutorial mit vielen Erklärungen für EinsteigerDeutsch
http://playground.arduino.cc/
interfacing/processing
Hilfe zum Thema Arduino und ProcessingEnglisch
http://shieldlist.org/Liste aller Arduino-ShieldsEnglisch
http://www.golem.de/specials/arduino/Interessante Projekte mit ausführlichen ArtikelnDeutsch
http://www.arduinoforum.de/Projekte und HilfeDeutsch
http://fff2.at/drupal/content/arduino-projekteProjekte und Code-BeispieleDeutsch
http://www.ladyada.net/make/ProjekteEnglisch
http://wiring.org.co/
learning/basics/index.html
Code-BeispieleEnglisch
http://playground.arduino.cc/Projects/IdeasProjekt IdeenEnglisch
http://hacknmod.com/hack/
top-40-arduino-projects-of-the-web/
Top 40 Arduino ProjekteEnglisch
http://practicalarduino.com/projectsProjekteEnglisch
http://fritzing.org/projects/ProjekteEnglisch
http://www.arduinoevilgenius.com/projectsProjekteEnglisch
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

Arduino-Lernpaket mit Original UNO-Platine (Elektronik Lernpaket)  – 29. Juli 2013   € 75,95

von Ulli Sommer (Autor)



kostenloser Software Download auf   Arduino.cc

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

Das Franzis Arduino Lernpaket

  • 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.

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



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


Das FRANZIS Mach’s einfach Maker Kit ist der perfekte Begleiter auf diesem Weg.
Alles, was Sie zum Einstieg brauchen, befindet sich in diesem Maker Kit. Los geht’s!
Dieses Maker Kit enthält alles, was Sie für Ihren Einstieg in die Programmierung eines Arduinos® benötigen.
Die beschriebenen Projekte vermitteln nicht nur Wissen und Spaß, sondern inspirieren auch zu eigenen Hacks mit dem Arduino
Richtig interessant wird ein Arduino erst durch angeschlossene Hardware.
Dieses Maker Kit bietet neben einer ausführlichen Schritt-für-Schritt-Anleitung für eine Vielzahl an Projekten auch alle nötigen Bauteile! Mach's einfach!
Denn die Zeiten, in denen das Programmieren von Mikrocontrollern nur etwas für echte Spezialisten war, sind vorbei.
Mit dem Arduino® können auch Anfänger innerhalb kurzer Zeit Elektronik- und Programmiergrundlagen erlernen und dann ihrer Kreativität in eigenen Projekten freien Lauf lassen.

Das alles bietet das Maker Kit für Arduino® - Mach's einfach:

++ Ausführliches Handbuch
++ Alle Bauteile enthalten
++ Erste Spiele programmieren
++ Speziell für Einsteiger

Diese Projekte führen Sie durch:
• Grafische Programmierung mit mBlock 3
• Fußgängerampel mit Taster
• Fußgängerampel mit mBlock 3
• Spielwürfel mit LEDs
• LED per Pulsweitenmodulation dimmen
• LED mit Potentiometer dimmen
• Analoge Pegelanzeige mit LEDs
• Arduino® über mBlock 3 interaktiv steuern
• Pong-Spiel mit Arduino®-Tasten
• Scratch mit analoger Eingabe steuern
• Spiele mit den Fingern steuern
• Texte auf dem LCD-Modul darstellen
• Uhr auf dem LCD-Modul
• Zahlenspiel mit Tasten und LCD-Modul
• Eigene Zeichen für das LCD-Modul erstellen
• Umlaute auf dem LCD-Modul
• Menüsteuerung auf dem LCD-Modul
• Stoppuhr mit mBlock 3
• LCD-Statusanzeige für Windows-PCs
• Arduino interaktiv steuern



Diese Bauteile sind enthalten
ARDUINO Nano-Board
• 3x Steckplatine
• 1x LCD-Modul
• 1x Pfostenverbinder (16-polig) für LCD
• 2x LED rot (mit Vorwiderstand)
• 2x LED grün (mit Vorwiderstand)
• 1x LED gelb (mit Vorwiderstand)
• 1x LED orange (mit Vorwiderstand)
• 1x LED blau (mit Vorwiderstand)
• 6x Taster
• 1x Potentiometer 15 kOhm
• 6x Widerstand 10 kOhm (Braun-Schwarz-Orange)
• 1x Widerstand 560 Ohm (Grün-Blau-Braun)
• 2x Widerstand 20 MOhm (Rot-Schwarz-Blau)
• Schaltdraht (isoliert)









DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE








Comments