elektor Einsteiger-Kurs

http://sites.prenninger.com/arduino-uno-r3/elektor-einsteiger-kurs

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-11-01

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

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************

Einführung in die Mikrocontrollerwelt mit

ARDUINO UNO

Arduino ist eine Open-Source-Plattform für Elektronik-Prototyping auf der Grundlage von flexibler und benutzerfreundlicher Hardware und Software.
Sie ist für Anwender bestimmt, die sich für die Erschaffung interaktiver Objekte oder Umgebungen interessieren, insbesondere für Bastler.

Mikrocontroller für Einsteiger  Arduino UNO R3 und Bascom-AVR
Ein elektor-Kurs für Bastler mit etwas analog Elektronikerfahrung - von Burkhard Kainka - für den einfachen Einstieg in die Welt der Mikrocontroller.
Teil 1 elektor 2014-04s54

Elektronik und Mikrocontroller
http://www.b-kainka.de/index.htm


Arduino Uno Rev. 3
Der Topseller schechthin!
Eigenschaften:
Mikrocontroller:    ATmega328
Betriebsspannung:    5V
Externes NT (empfohlen): 7..12V
Externes NT (Grenzwerte): 6-20V  
Digitale IO-Pins:    14 (davon 6 als PWM)
PWM-Kanäle:    6
Analoge Eingänge:    6
Strom pro 1/0-Pin:    max. 40mA
3,3-V-Belastbarkeit:    max. 50mA
Flashspeicher:    32 KB (davon 0,5 KB für  Bootloader)
SRAM:    2 KB (ATmega328)
EEPROM:    1 KB (ATmega328)
Taktrate:    16 MHz

€ 27,50  STAND 2014
www.elektor.de/arduino



*********************************************************
              elektor Mikrocontroller Einsteiger-Kurs

Mikrocontroller für Einsteiger (1)
Arduino Uno und BASCOM-AVR  V 2.0.7.5
300_d_elektor-x_120574-11  2014-04s054  Mikrocontroller für Einsteiger (1) Arduino Uno und BASCOM_1a.pdf
www.elektor-magazine.de/120574

Software: 300_d_elektor-x_120574-11  2014-04s054  Mikrocontroller für Einsteiger (1) Arduino Uno und BASCOM_1a.zip


300_d_elektor-x_130568-11  2014-05s050  Mikrocontroller für Einsteiger (2) Digitale Eingänge_1a.pdf

www.elektor-magazine.de/130568

Software:  300_d_elektor-x_130568-11  2014-05s050  Mikrocontroller für Einsteiger (2) Digitale Eingänge_1a.zip

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

                           elektor und ARDUINO UNO

300_d_elektor-x_120366-11 2012-07s120 ARDUINO auf Kurs (1a) Arduino Tonerzeugung_1a.pdf
300_d_elektor-x_120366-11 2012-07s120 ARDUINO auf Kurs (1a) Arduino Tonerzeugung_1a.zip

300_d_elektor-x_120427-11 2012-09s056 ARDUINO auf Kurs (1b) Arduino als Sound-Player_1a.pdf
300_d_elektor-x_120427-11 2012-09s056 ARDUINO auf Kurs (1b) Arduino als Sound-Player_1a.zip

300_d_elektor-x_100681-11 2012-03s054 Regeln mit Arduino und PC - uC-gest. Regler mit PC-Schnittstelle_1a.pdf
300_d_elektor-x_100681-11 2012-03s054 Regeln mit Arduino und PC - Platine_1a.pdf
300_d_elektor-x_100681-11 2012-03s054 Regeln mit Arduino und PC - uC-gest. Regler mit PC-Schnittstelle_1a.zip

300_d_elektor-x_110092-11 2011-07s065 Arduino Shields +++ - Steck-Platine (Experimentier-Lochraster)_1a.pdf


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

                         http://arduino.cc/en/Main/Software

BASIC-Compiler BASCOM-AVR  www.mcselec.com

Atmel ATmega328p
32KB Flash-Speicher (davon 0,5kB vom ARDUINO-Bootloader belegt)

2KB SRAM
1KB EEPROM
16MHz
14 I/Os (davon 6 als PWM-Ausgänge)
6 AE

UNO_LED1.bas = Quellcode
UNO_LED1.hex = Hexcode
COM3
115200 Baud
High > 2,7V (laut Datenblatt 0,7x Vcc = 3,5V)
Low  < 2,2V (laut Datenblatt 0,3x Vcc = 1,5V)
Schmitt-Trigger Verhalten mit 0,5V Hysterese


2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-1\UNO-AD3_1a.bas
START > rechte Maustaste > Geräte Manager > Anschlusse (COM & LPT) > Arduino UNO (COM6)
BASCOM-IDE
MENU > Options > Programmer > COM6  115200  Timout 3000
MENU > Tools > Terminal Emulator > Terminal > Setting > Communicattion >  COM6   9600   None   8   1

MENU > Programm > Compile <F7>          (schwarzer IC)
MENU > Programm > Send to chip <F4>    (grüner Print)


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

Bei www.schaltungen.at angemeldete USER die € 20,00 gespendet haben werden gewünschte Artikel eingescannt.
Zusätzlich zu den 200 downloads.


BASCOM-1:   120574-11.zip

1.1  Der LED-Blinker   UNO_LED1_1a.BAS    § OnBoard LED  PB5=pin-13

BASCOM-2:
   130568-11.zip
2.1  Eingang auf Ausgang kopieren           UNO_Input1_1a.BAS     § Taster 100k PC5=pin-A5  UND OnBoard LED  PB5=pin-13
2.2  Invertierung des Eingangssignals        UNO_Input2_1a.BAS    § Taster 100k PC5=pin-A5  UND OnBoard LED  PB5=pin-13
2.3  Eine If-Abfrage (Blinklicht)                  UNO_Input3_1a.BAS     § Taster 100k PC5=pin-A5  UND OnBoard LED  PB5=pin-13
2.4  Portabfrage mit PullUp-Widerstand      UNO_Input4_1a.BAS    § Taster 100k PC5=pin-A5  UND OnBoard LED  PB5=pin-13

BASCOM-3:
   140028-11.zip
3.1  Print-Ausgabe                                       UNO_Print_1a.BAS    § 0..255 auf den "Serial-Monitor"
3.2  Verwendung des AD-Wandlers                UNO_AD1_1a.BAS    § 10k Schutzwiderstand PC0=pin-A0
3.3  Umrechnung in Volt  (0,,5Vdc Voltmeter) UNO_AD2_1a.BAS     § 10k Schutzwiderstand PC0=pin-A0
3.4  Messung von Vcc (Geheimkanal 14)     UNO_AD3b_1a.BAS   § PC1=pin-A1 Lastwiderstand 220R  PC0=pin-A0
3.5  Messung der internen IC-Temperatur (Geheimkanal 8)    UNO_AD4_1a.BAS    § PB4=pin-12  PB5=pin-13
3.6  Messung der Eingangshysterese  (Hi/Lo Input Threshold)  UNO_AD5_1a.BAS    § PC5=pin-A5  PB5=pin-13

BASCOM-4:
   140064-11.zip
4.1  Text- und Zahlenausgabe ( LCD-Display 2x8)                     UNO_LCD1_1a.BAS 
      §  10k Poti PC3=pin-A3     LED PC2=pin-A2     Taster PC1=pin-A1    Taster C0=pin-A0     LED B2=pin-10
4.2  LCD-Anzeige von Spannungen (2-Kanal Voltmeter)      UNO_LCD2b_1a.BAS    §  pin-A0  pin-A3 und auf den "Serial-Monitor"  elektor Shield 140009-91
4.3  Messung an der LED und am Poti UNO_LCD???_1a.BAS    §  pin-A0  pin-A3 und auf den "Serial-Monitor"
4.4  PWM-Steuerung                          UNO_LCD3_1a.BAS       §  10k Poti PC3=pin-A3     LED PC2=pin-A2     LED B2=pin-10

BASCOM-5:
   140049-11.zip
5.1  Messung der LCD-Ausgabezeit (Timer-1  0,5us)  UNO_Timer1_1a.BAS   §  10k Schutzwiderstand PC0=pin-A0  elektor Shield 140009-91
5.2  Periodendauer in Mikrosekunden messen 125Hz bis 4MHz   (Timer-1  0,5us)  UNO_Timer2_1a.BAS   §  10k Schutzwiderstand PC0 = pin-A0
5.3  Timer1 als Rechteckgenerator   (B1 Fout 250Hz .. 4MHz )    UNO_Timer3_1a.BAS   §  PC0=pin-A0      PC1=pin-A1   PB1=pin9
5.4  Genaue Sekunden im Interrupt                                              UNO_Timer4_1a.BAS   §  PC0=pin-A0      PC1=pin-A1   PB1=pin9
5.5  Mittelung im Timer-Interrupt  (Timer1-Interrupt, ADC0 average) UNO_Timer5_1a.BAS    §  PC0=pin-A0    PB2=pin10
5.6  Frequenzmessung bis 4MHz  (Frequency 0..4MHz)              UNO_Timer6_1a.BAS    §  PB3=pin-11    PD5=pin-5
5.7  Textausgabe auf dem LCD-Display  (COM input B0)                UNO_Display_1a.BAS   §  elektor Shield 140009-91

BASCOM-6:
   140245-11.zip
6.1  Ausgabe über ein Schieberegister                       UNO_shift_1a.BAS   § 4094 PB2=pin-10  PB3=pin-11  PB4=pin-12  elektor Shield 140009-91
6.2  SPI-Master und Slave ganz langsam (Shift in/out) UNO_spi1_1a.BAS   § LED PC2=pin-A2  Taster PC1=pin-A1   Taster PC0=pin-A0    LED PB2=pin-10
6.3  Der SPI-Maste    UNO_spi2_1a.BAS     §  PB2=pin-10      PB3=pin-11      PB5=pin-13
6.4  Der SPI-Slave     UNO_spi2_1a.BAS     §  PC0=pin-A0      PC1=pin-A1     PB5=pin-13    PB3=pin-11    PB2=pin-10
6.5  Schreiben und Lesen über MOSI und MISO UNO_????_1a.BAS  §  PB5=pin-13      PB4=pin-12  PB3=pin-11    PB2=pin-10
6.6  Auslesen eines EEPROMs UNO_????_1a.BAS                  §  elektor Shield 140009-91
6.7  Freischalten der Schreibzugriffe           UNO_????_1a.BAS  §  elektor Shield 140009-91
6.8  Verwendung der Software-SPI              UNO_????_1a.BAS  §  elektor Shield 140009-91
6.9  Datenspeicherung im Timer-Interrupt   UNO_????_1a.BAS  §  elektor Shield 140009-91

BASCOM-7:
   140293-11.zip
7.1  Testen der aktiven I2C-Adresse  UNO_I2C1_1a.BAS                                    § PC4=pin-A4     PC5=pin-A5
7.2  Portzugriffe beim PCF8574        UNO_I2C2_1a.BAS                                     § elektor Shield 140009-91
7.3  Verwendung des Portexpander PCA9555  (input/output) UNO_LCD1_1a.BAS  § elektor Shield 140009-91
7.4  Diodentester mit dem PCF8591  (AD/DA )                     UNO_I2C4_1a.BAS   § elektor Shield 140009-91





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

Mikrocontroller für Einsteiger von Burkhard Kainka

7 Teile

KURS von  www.schaltungen.at downloadbar.



(1)  Arduino UNO Rev.3 und Bascom-AVR

Veröffentlicht in elektor Heft 2014-04s054



Recht oft bekommt die Redaktion Anfragen von Elektronikfans, die einen einfachen Einstieg in die Welt der Mikrocontroller suchen.
Da der letzte größere Kurs in Elektor schon einige Jahre zurückliegt und die Hardware inzwischen nicht mehr erhältlich ist, wird es höchste Zeit für eine Neuauflage.
Mit unserer Serie wenden wir uns an jene Leser, die schon etwas analoge Elektronikerfahrung mitbringen und nun endlich auch einmal Mikrocontroller in eigenen Schaltungen einsetzen wollen.

Artikel herunterladen...

704_d_elektor-x_120574-11  2014-04s054  Mikrocontroller für Einsteiger (1) Arduino BASCOM_1a.pdf
C:\2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-1 120574-11.zip


BASCOM-IDE

'-------------------------------------------------------------------------------
'UNO_LED1_1a.BAS
'-------------------------------------------------------------------------------
$regfile = "m328pdef.dat"                                   'ATmega328p
$crystal = 16000000                                         '16 MHz

'-------------------------------------------------------------------------------

Config Portb = Output

Do
  Portb.= 1                                               'LED  on
  Waitms 500                                                '
500ms Wartezeit
  Portb.= 0                                               'LED  off
  Waitms 500                                                '500ms Wartezeit
Loop



ARDUINO-IDE

/*
  Blink
 Schaltet ein für eine Sekunde LED an, dann für eine Sekunde wiederholt. 
 
  Dieses Beispiel-Code ist in der Public Domain. 
 */
 
// Pin 13 verfügt über eine LED auf den meisten Arduino-Boards
int led = 13;    // pin-13


void setup() {   // Die Setup-Routine läuft einmal, wenn Sie RESET drücken:         
  pinMode(led, OUTPUT);      // Initialisierung der digitalen Pin als Ausgang.   
}

void loop() { // Die Schleifenroutine läuft immer und immer wieder   digitalWrite(led, HIGH); // Die LED einschalten, Spannung 5V   delay(1000); // 1Sek. Wartezeit   digitalWrite(led, LOW); // Schalten die LED aus, Spannung 0V   delay(1000); // 1Sek. Wartezeit }





(2)   Digitale Eingänge

Veröffentlicht in elektor Heft 2014-05s050

Ein Mikrocontroller wie der ATmega328 auf dem Arduino-Uno-Board verfügt über viele unterschiedliche Eingänge.
Da gibt es analoge Eingänge, mit denen eine Spannung gemessen werden kann.
Digitale Eingänge nehmen dagegen nur wahr, ob eine Leitung auf „High“ oder „Low“ liegt. Man kann mit ihnen z.B. den Zustand eines Tasters oder Schalters einlesen.

Artikel herunterladen...

704_d_elektor-x_130568-11 2014-05s050 Mikrocontroller für Einsteiger (2) Digitale Eingänge_1a.pdf
C:\2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-2 130568-11.zip


BASCOM-IDE

Eingang auf Ausgang kopieren

'-------------------------------------------------------------------------------
'UNO_Input1_1a.BAS
'-------------------------------------------------------------------------------
$regfile = "m328pdef.dat"                                   'ATmega328p
$crystal = 16000000                                         '16 MHz

'-------------------------------------------------------------------------------

Config Portb = Output                                       ' Ausgaberegister PortB
Config Portc = Input
                                                            ' Leseregister PortC
Do
  Portb.= Pinc.5                                          'Copy Eingang zu Ausgang
  Waitms 20                                                 '20ms (50Hz) Wartezeit
Loop



ARDUINO-IDE

/*
  Button
 
Zum Ein- und Ausschalten einer Leuchtdiode (LED), um digitale verbunden 
  Stift 13, wenn Tastendruck angebracht an Pin 2.
 
 
  Die Schaltung:
  * Von Pin 13 LED angebracht an Masse
  * Drucktaste Pin 2 von + 5V angeschlossen
  * 10K Widerstand an Pin 2 vom Boden befestigt
 
  * Hinweis: auf den meisten Arduinos es bereits eine LED auf dem Board
  befestigt an Pin 13.
   http://www.arduino.cc/en/Tutorial/Button */ const int buttonPin = 2; // Taster an pin-2 const int ledPin = 13; // OnBoard LED an pin-13 // variables will change: int buttonState = 0; // Variable für das Lesen des Status-Taster
void setup() {   pinMode(ledPin, OUTPUT); // Initialisiert den LED-pin als Ausgang:   pinMode(buttonPin, INPUT); // Initialisiert der Drucktaster-pin als Eingang }
void loop(){   buttonState = digitalRead(buttonPin); // Lesen des des Drucktasters Wertes    // Überprüfen, ob die Taste gedrückt wird.   if (buttonState == HIGH) {    // Wenn ja, ist die Button HIGH:     digitalWrite(ledPin, HIGH); // LED einzuschalten:   }    else {     digitalWrite(ledPin, LOW); // LED ausschalten:   } }





(3) Serielle Schnittstelle und AD-Wandler

Veröffentlicht in elektor Heft  2014-06s056

Im Mittelpunkt dieser Folge steht der Analog-Digital-Wandler.
Das ist praktisch ein in den Mikrocontroller eingebautes Spannungsmessgerät.
Einen Zeiger oder eine Anzeige gibt es erstmal nicht, um die Ausgabe muss man sich also selbst kümmern.
Der AD-Wandler liefert einfach Zahlen.
Und damit die irgendwo angezeigt werden können, müssen sie übermittelt werden.
Hier kommt die serielle Schnittstelle ins Spiel.

Artikel herunterladen...

704_d_elektor-x_2014-06s056 Mikrocontroller für Einsteiger (3) Serielle Schnittstelle und AD-Wandler_1a.pdf
C:\2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-3 140028-11.zip

ARDUINO-Bootloader = UnoBoot.hex

www.elektor-magazine.de/130568



BASCOM-IDE  (Prg. stürzt immer ab 3x Reset drücken)

'-------------------------------------------------------------------------------
'UNO_Print_1a.BAS
'-------------------------------------------------------------------------------
$regfile = "m328pdef.dat"      'ATmega328p
$crystal = 16000000            '16MHz
$baud = 9600

Dim N As Byte                 
'Zahlenausgabe 0..255
Dim D As Word                  'Zahlenausgabe 0..32767

Do


  Print " Zahl = "             ' ODER einzeilig Print N: " Zahl = " 
  Print
 N;
                     ' Print D;  
  Waitms 100                  
' 100ms Wartezeit 
  N 
= N + 1
                    ' D = D + 1
 Loop




ARDUINO-IDE
/*
Dieser Sketch gibt eine Folge von Zahlen über den "Serial-Monitor" aus.
Sketch: SerialOutput_0_32767_1a
Gibt Zahlen von 0 bis 32767 (-32768..0) in 460sec (14ms) am COM-Port aus.
*/
void setup()
{
Serial.begin(9600);         // Senden und Empfangen mit 9600 Baud
}
int number = 0;


void loop()
{
Serial.print("Die Zahl = ");
Serial . println (number);    // Zahl ausgeben
//delay(500);                 // Halbe Sekunde warten
number++;                     // Nächste Zahl
}






BASCOM-IDE

Geheimkanal 14 (ADC) erlaubt es die interne 1,1V-Referenz zu messen

'----------------------------------------
'UNO_AD3b_1a.BAS  Vcc / 1.1 V
'----------------------------------------
$regfile = "m328pdef.dat"
$crystal = 16000000
$baud = 9600
$hwstack = 32
$swstack = 64
$framesize = 64


Dim D As Word
Dim E As Word
Dim U As Single
Dim V As Single

Config Adc = Single , Prescaler = 64 , Reference = Avcc     ' 5,0V

Do
  E = Getadc(0)                                             'int Ref off
  V = E * 5.0
  V = V / 1023
  Print "pin-A0 = ";
  Print V ; " V"
  Waitms 3000


  D = Getadc(14)                                            'int Ref on
  Waitms 100
  D = Getadc(14)                                            'Ref 1.1 V
  U = 1023 / D
  U = U * 1.1
  Print "Vcc = ";
  Print U ; " V"
  Print " - - - - - - - - - - - "
  Waitms 1000

Loop

'Das Messen von Kanal 14 schaltet die Referenz erst ein,
'andere Kanäle schalten sie wieder aus.
'Und es wird jedesmal etwas Zeit benötigt, bis die Referenz voll da ist.
'Von so einer Einschwingzeit steht auch etwas im Datenblatt.
'Also muss man in diesem Fall den Kanal AD14 zweimal messen,
'einmal zum Einschalten der Referenz
'und dann nach einer kurzen Pause für die eigentliche Messung.




BASCOM-IDE
Geheimkanal 8 (ADC) erlaubt es die interne IC-Temperatur zu messen

'-------------------------------------------
'UNO_AD4b_1a.BAS   interne IC-Temp
'-------------------------------------------
$regfile = "m328pdef.dat"
$crystal = 16000000
$baud = 9600
$hwstack = 32
$swstack = 64
$framesize = 64


Dim D As Word
Dim N As Word
Dim U As Single

Config Portb = Output
Portb.= 1
Portb.= 0


Do
Config Adc = Single , Prescaler = Auto , Reference = Avcc   'Ref. Vcc (+5,0V)
  Waitms 200
  D = Getadc(0)                                             ' Default Ref. Vcc
  U = D * 5.0
  U = U / 1023
  Print "pin-A0 = ";
  Print U ; " V"
  D = Getadc(1)
  U = D * 5.0
  U = U / 1023
  Print "pin-A1 = ";
  Print U ; " V"
  Waitms 1000

  Config Adc = Single , Prescaler = Auto , Reference = Internal       ' int Ref. 1,1 V
  Waitms 200
  D = Getadc(8)                                             'int Ref. 1,1V  on                                         'Temperature
  D = D - 331
' pi mal Daumen Wert 331 abziehen damit Temp. in Grad C herauskommt
  Print "uC-IC-Temp. = ";
  Print D ; " Grad C"
  Print "- - - - - - - - - - - - "
  Waitms 3000
Loop







(4) Benutzer-Schnittstelle


Veröffentlicht in Heft 7/2014 auf Seite 38



Ernsthafte Mikrocontroller-Anwendungen besitzen meist geeignete Schnittstellen zwischen Mensch und Maschine.
Ein kleines Display, ein paar Taster, ein Einstell-Poti, ein paar LEDs - schon kann man richtig schöne Geräte entwickeln.
Gleich loslegen können wir mit dem von Elektor entwickelten Arduino-Shield, das ebenfalls in dieser Ausgabe beschrieben wird.

Artikel herunterladen...

704_d_elektor-x_2014-07s038 Mikrocontroller für Einsteiger (4) Benutzer-Schnittstellen_1a.pdf
C:\2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-4 140064-11.zip

Webseiten


BASCOM-IDE

2-Kanal Voltmeter

'-------------------------------------------------------------------------------
'UNO_LCD2b_1a.BAS  Voltage pin-A0  pin-A3
'-------------------------------------------------------------------------------
$regfile = "m328pdef.dat"                                   'ATmega328p
$crystal = 16000000                                         '16 MHz
$baud = 9600

Dim D As Word
Dim U As Single

Config Adc = Single , Prescaler = 64 , Reference = Avcc     '5 V

Config Lcdpin = Pin , Db4 = Portd., Db5 = Portd., Db6 = Portd., Db7 = Portd., E = Portd., Rs = Portd.2
Config Lcd = 16 * 2

Cls
Cursor Off

Do
  Locate 1 , 1
  Lcd "A0 "
  D = Getadc(0)                                             'pin-A0
  U = D * 5.0
  U = U / 1023
  Lcd U
  Lcd "    "

  Print "pin-A0 = ";
  Print U ; " V"
  Waitms 500

  Locate 2 , 1                                              '
  Lcd "A3 "
  D = Getadc(3)                                             ' pin-A3
  U = D * 5.0
  U = U / 1023
  Print "pin-A3 = ";
  Print U ; " V"

  Print " - - - - - - - - - - - "
  Waitms 1500
Loop


ARDUINO-IDE
/*
* Display5vOrless Sketch
* Gibt die Spannung am Analogpin über den seriellen Port aus
* Warnung - schließen Sie nicht mehr als 5V direkt an den Arduino-Pin an.
*/
// Sketch: 2_Kanal_Spannungen_messen_5V_1a.ino
const float referenceVolts = 5.0; // Referenzspannung eines 5-Volt-Boards
const int Pin_A0 = 0;	// Batterie ist mit Analog pin-A0 verbunden
const int Pin_A3 = 3;	// n.c.
const int Pin_A14 = 14;	// Geheim-Kanal 14 int. 1,1V referenz

void setup()
{
Serial.begin(9600);
}

void loop()
{
int val0 = analogRead(Pin_A0); // Wert vom Sensor einlesen
float volts = (val0 / 1023.0) * referenceVolts; //Verhältnis berechnen
Serial.print("pin-A0 = ");
Serial.print(volts); // und Wert in Volt ausgeben
Serial.println(" Volt");

int val3 = analogRead(Pin_A3); // Wert vom Sensor einlesen
float volts3 = (val3 / 1023.0) * referenceVolts; //Verhältnis berechnen
Serial.print("pin-A3 = ");
Serial.print(volts3); // und Wert in Volt ausgeben
Serial.println(" Volt");

Serial.println(" - - - - - - - - - ");
delay (1500);
}




(5) Timer-Anwendung


Veröffentlicht in Heft 9/2014 auf Seite 62

Eines der größten Kapitel im Datenblatt des ATmega328 behandelt die drei Timer des Controllers.
Ihre Anwendungen sind so vielfältig, das hier nur ein kleiner Teil der Möglichkeiten vorgestellt werden kann.
Die wesentlichen Aufgabenfelder heißen Zeitmessung, Frequenzmessung, Signalerzeugung und PWM-Ausgab

Artikel herunterladen...

704_d_elektor-x_2014-09s062 Mikrocontroller für Einsteiger (5) Timer-Anwendung_1a.pdf
C:\2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-5 140049-11.zip


BASCOM-IDE

Periodendauer in Mikrosekunden messen (Impulslängen)
Geschwindigkeitsanzeige "Sie fahren ...  kmh"
PC0=pin-A0
50Hz = 20ms (= 20.000us) Periode der Netzspannung

'-------------------------------------------------------------------------------
'UNO_Timer2b_1a.BAS  Timer1,  0,5us
'-------------------------------------------------------------------------------
$regfile = "m328pdef.dat"                                   'ATmega328p
$crystal = 16000000                                         '16 MHz
$baud = 9600
Dim D As Word


Config Timer1 = Timer , Prescale = 8                        'Clock 2 MHz
Config Timer2 = Pwm , Prescale = 256 , Compare A Pwm = Clear Up
Ddrb = 255
Pwm2a = 128


Config Lcdpin = Pin , Db4 = Portd., Db5 = Portd., Db6 = Portd., Db7 = Portd., E = Portd., Rs = Portd.2
Config Lcd = 16 * 2
Waitms 50

Cls
Cursor Off
Do
  Do
  Loop Until Pinc.= 0
  Do
  Loop Until Pinc.= 1
  Timer1 = 0
  Do
  Loop Until Pinc.= 0
  Do
  Loop Until Pinc.= 1
  D = Timer1
  D = D / 2
  Locate 1 , 1
  Lcd "Timer1 ="
  Locate 2 , 1
  Lcd D
  Lcd " us    "
  Print "Timer1 = ";
  Print D;
  Print " us"
  Waitms 1000
Loop




(6) Die SPI-Schnittstelle

Veröffentlicht in Heft 10/2014 auf Seite 34

Beim Seriellen Peripherie-Bus (SPI) laufen die eigentlichen Daten Bit für Bit über eine Leitung; zum Beispiel von einem Mikrocontroller zu einem Display, einem EEPROM oder einer SD-Karte. Da man meist auch Daten lesen will, braucht man eine zweite Leitung, auf der Bits zurückflitzen können. Aber dann kommt noch etwas hinzu, nämlich eine Taktleitung. Das Taktsignal zeigt immer eindeutig, wann das nächste Bit auf der Leitung steht. Unnötig sind dann genaue zeitliche Vereinbarungen, die bei beiden Gesprächspartnern durch einen Timer überwacht werden müssten. Mit den drei Leitungen wird die Übertragung ziemlich robust.

Artikel herunterladen...

704_d_elektor-x_2014-10s034  Mikrocontroller für Einsteiger (6) Die SPI-Schnittstelle_1a.pdf
C:\2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-6 140245-11.zip




(7) Der I2C-Bus

Veröffentlicht in Heft 11/2014 auf Seite 54

Der I2C-Bus ist eine 2-Draht-Datenverbindung mit Datenleitung und Taktleitung und wurde ursprünglich von Philips für die Unterhaltungselektronik entwickelt. Viele ICs können am selben Bus angeschlossen sein, ohne sich gegenseitig zu stören. In der letzten Folge unseres Mikrocontrollerkurses zeigen wir, wie man Porterweiterungen und andere I2C-Chips mit BASCOM ansteuert.

Artikel herunterladen...

704_d_elektor-x_2014-11s054 Mikrocontroller für Einsteiger (7) Der I2C-BUS_1a.pdf
C:\2014 BASCOM-AVR 2.0.7.5\elektor-KURS\Bascom-7 140293-11.zip




Webseiten



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

BASCOM-AVR-Kurs

http://forum.elektor.com/viewforum.php?f=659855



Die neue Elektor-Serie "Mikrocontroller für Einsteiger" begann mit dem Aprilheft.

Im Doppelheft Juli/August wird das neue Arduino-Shield von Elektor vorgestellt.
ARDUINO BASCOM Shield  140009-91
Das Shield wird für den Einsteigerkurs verwendet: LCD, Poti, Taster, LEDs, also die Dinge, die man fast immer braucht.
So hat man ein kompaktes System, ein Kabel zum USB und sonst nichts.
Jens Nickel beschreibt die Hardware ausgiebig im Doppelheft 2014, und ich zeige in Mikrocontroller-Kurs die passenden Bascom-Programme.

BASCOM hängt sich auf bei Print-Befehl
Arduino Uno lässt sich nicht mehr mit Bascom programmieren
http://forum.elektor.com/viewtopic.php?f=659855&t=2708164&sid=d757ca3dc8f4df4c5dfdf643b6ddbdcd

Man könnte folgendes versuchen:

- Nachsehen, ob die Baudrate 115200 noch eingestellt ist.
- Test, ob die originale Arduino-Software noch hochlädt.
- Eventuell eine andere Timeout-Einstellung im Bascom-Arduino-Bootloader ausprobieren.
- Auf einen andern USB-Port wechseln.

Manchmal macht USB 2 oder USB 3 einen Unterschied, an modernen PCs gibt es beide.
Manchmal hilft ein Hub.
Und manchmal merkt sich Windows Fehler an einem Port und verwendet ihn nicht mehr.
Das ist mir bei anderen Geräten schon öfter passiert.
Nach dem dritten Neustart von Windows ist dann wieder alles normal.
Aber ein Wechsel des USB-Ports bringt oft eine schnelle Lösung.
Siehe auch: http://www.elektronik-labor.de/AVR/ElektorBas.html

Also ich habe bei dem gleichen Kapitel in dem Kurs ein ähnliches Problem.
Ich konnte aber feststellen, dass sich das Programm genau 1x laden lässt. Es funktioniert dann auch.
Ändere ich es ab oder möchte ich ein anderes Programm direkt im Anschluss laden (F4), hängt sich das ganze auf.
Die Visualisierung ist so wie immer, es erscheint das HEX Fenster und auf dem Board ist die L LED an und die TX LED blinkt permanent.
Manchmal ist die TX LED auch dauerhaft an.
Klicke ich mit dem Cursor irgendetwas an, erscheint die Meldung (keine Rückmeldung) im Rahmen des Fensters und ich kann nur noch alles schliessen.
Wechsel ich dann direkt in die Arduino IDE, kann ich wieder einen Sketch laden und er funktioniert.
Wechsel ich wieder zurück zu Bascom-AVR, kann ich ein beliebiges Programm erneut fehlerfrei einmal laden und das Spiel beginnt von neuem.
Das habe ich mit zwei verschiedenen Arduino Uno Boards getestet und jeweils das gleiche Verhalten, das Board sollte also in Ordnung sein.
Die Baudrate habe ich kontrolliert, aber ich denke sonst würde es generell nicht funktionieren.


Listings und Downloads

http://forum.elektor.com/viewtopic.php?f=659855&t=2708315&sid=462e51f0f774d7c4bfdd83e36cd95420

BASCOM-IDE
'-------------------------------------------------------------------------------
'UNO_Print.BAS
'-------------------------------------------------------------------------------
$regfile = "m328pdef.dat" 'ATmega328p
$crystal = 16000000 '16 MHz
$baud = 9600

Dim N As Byte

Do
Print N;
Print " Uno"
Waitms 200
N = N + 1
Loop


*****************************
'RS232Test.bas
'
'Ein  Testprogramm für Arduino Uno und kompatible Boards
'
'Das Programm stellt den Port PB5 (Pin 13) auf Ausgang und
'schaltet ihn im Sekundentakt zwischen Low und High um
'Die Led auf dem Board blinkt also
'Zudem wird die Variable z jede Sekunde um 1 erhöht und
'ein Satz über die serielle Schnittstelle ausgegeben
'Mit einem Terminalprogramm kann man die Daten empfangen
'

$regfile = "m328pdef.dat"
$framesize = 32
$swstack = 32
$hwstack = 64

$crystal = 16000000        'Resonatorfrequenz
$baud = 9800               'Baudrate (Übertragungsgeschwindigkeit)



dim z as integer

Config PortB.5 = Output

z=0
Do
    Print "Hallo - Ich zaehle: "; z
    incr z
    toggle   PortB.5
    wait 1
Loop



Bascom- und ArduinoTM kompatible Boards sowie Bascom-Compiler erhältlich bei
www.robotikhardware.de Weitere Beispiele auf DVD von RobotikHardware oder in den Portalen http://www.Roboternetz.de und http://rn-wissen.de




Allerdings dienen die abgedruckten Programme nur der schnellen Übersicht.
Auf der Elektor-Homepage kann man sich die Programmdateien laden.
Vor allem in den späteren Folgen mit immer längeren Programmen werden nur noch die entscheidenden Teile der Programme abgedruckt.
Dann sollte man grundsätzlich auf die Dateien zurückgreifen.
http://www.elektor-magazine.com/de/zeitschrift/alle-elektor-ausgaben.html



In der ersten Folge (elektor 2014-04s54) ging es ganz einfach los, mit Portausgaben.
Und es wurde gezeigt, wie man in Bascom den Arduino-Bootloader verwenden kann.
Der entscheidende Punkt war, dass man für den Uno 115200 Baud einstellen muss.
Bascom verwendet dann den originalen Uno-Bootloader.



 
Später habe ich dann auch andere Wege vorgestellt, wie man sein Programm in den Controller bekommt:
Mit einem externen Brenner oder mit dem angepassten MCS-Bootloader, den ich übrigens besonders gern verwende.
Man muss nur aufpassen, dass man die Bootloader nicht verwechselt.
Den MCS-Bootloader habe ich mit einem Aufkleber auf der USB-Buchse gekennzeichnet, damit nicht versehentlich versucht wird die Arduino-IDE mit diesem Bootloader zu nutzen.



Fehlersuche bei Upload-Problemen


Vermutlich die meisten Anwender sind beim Adruino-Bootloader geblieben, was ja auch den Vorteil hat, dass man nahtlos zwischen Bascom und Arduino wechseln kann.
In einigen wenigen Fällen sind Probleme aufgetreten, die manchmal auch von der Arduino-IDE berichtet werden.
Irgendwas klemmt mit dem Upload. Dann kann man folgendes versuchen:

- Nachsehen, ob die Baudrate 115200 noch eingestellt ist.
- Test, ob die originale Arduino-Software noch hochlädt.
- Eventuell eine andere Timeout-Einstellung im Bascom-Arduino-Bootloader ausprobieren.
- Auf einen andern USB-Port wechseln.

Manchmal macht USB 2 oder USB 3 einen Unterschied, an modernen PCs gibt es beide.
Manchmal hilft ein Hub.
Und manchmal merkt sich Windows Fehler an einem Port und verwendet ihn nicht mehr. Das ist mir bei anderen Geräten schon öfter passiert.
Nach dem dritten Neustart von Windows ist dann wieder alles normal. Aber ein Wechsel des USB-Ports bringt oft eine schnelle Lösung.


Alle Programme aus Elektor (Hefte 4, 5 und 6) lassen sich laden und in Betrieb nehmen.
Die einzige Ausnahme bildet das Programm UNO_Print.BAS
Bei einem „Waitms 200“ erfolgt keine erfolgreiche Terminalanzeige. (Bei 250ms funktioniert das)
Wenn UNO_Print.BAS mit Waitms 200/250ms läuft, kann bei mir auf keinem Rechner ein anderes Programm geflasht werden
– Bascom hängt sich auf (mit: Keine Rückmeldung) und muß z.B. mit Taskmanager abgewürgt werden.
Auch bei einem Neustart von BASCOM gleiches Problem.
Mit ARDUINO-IDE kann das Programm BLINK (aus: File/Examples/Basics) geflasht werden. und ARDUINO blinkt.
Dann ist wieder mit BASCOM das Flashen der Programme möglich – und die Programme funktionieren.
Bei einer Einstellung von Waitms von 300 und mehr in UNO_Print.BAS, gibt es mit BASCOM auf allen Rechnern keine Probleme.
Nach Compile von UNO_Print.BAS ist die Baudrate 115200 noch eingestellt – bei Absturz ist keine Kontrolle mehr möglich.

Lösung:
Inzwischen konnte ich den Fehler nachvollziehen:
Immer wenn eine Print-Ausgabe im Programm enthalten ist klemmt der Arduino-Programmer in Bascom.
Es handelt sich wohl um ein Problem in der Bascom-IDE.
(Das hatte ich leider bisher übersehen, weil ich lieber mit dem MCS-Bootloader arbeite, wo es dieses Problem nicht gibt.)
Nach einigem Herrumprobieren kam folgende Lösung heraus:

1. Die Timeout-Einstellung wird auf 3000 hochgesetzt:




2. Beim Upload wird dreimal (! ! ! ) kurz die Reset-Taste des ARDUINO UNO gedrückt.
Vor dem ersten Reset stehen im Chip-Fenster erstmal drei Fragezeichen ???.
Nach dem ersten Reset erhält man hier den Eintrag ATmega328P. Der Programmer liest also erstmal diese Info.
Nach dem zweiten Reset geht es immer noch nicht weiter.  Vielleicht wird da noch etwas anderes gelesen oder aber der Speicher wird gelöscht.
Aber nach dem dritten Reset geht es dann wie gewohnt weiter.



Dreimal Reset löst das Problem.
Oder der MCS-Bootloader, den man allerdings mit einem externen Brenner reinladen muss.

Nachtrag 2 von Jürgen Conrad:
Froher Hoffnung habe ich sofort die Änderung auf Timeout 3000 vorgenommen. Auch den Link genau studiert.
Die Programmierung von UNO_Print.BAS mit Waitms 200 geht problemlos. Ausgabe auf Terminalfenster ok.
Während des Laufes von UNO_Print.BAS mit 200 ms kann das Programm LEDblink.bas wieder nicht geflasht werden.
Bascom hängt sich auf (mit: Keine Rückmeldung), wird mit Arduino wieder „entsperrt“.
Erhöhe ich Waitms jedoch auf 300 ms funktioniert alles wieder.
Timeout 3000, $crystal = 16000000, $baud = 9600, sofern sich das Programm Bascom nicht aufhängt, stets kontrolliert.
Ich habe BASCOM-AVR IDE free (2.0.7.5), neu installiert. USB-Treiber für Arduino (Ver. 1.5.6-r2) neu eingespielt.


Mit einer Pause von 300 ms kommt man ohne die Reset-Taste aus.
Wenn das Programm aber schneller sendet muss man wie beschrieben dreimal Reset drücken.


http://www.elektronik-labor.de/AVR/ElektorBas.html





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

                        ARDUINO auf Kurs

Teil 1a: Hello World & Arduino Tonerzeugung

Veröffentlicht in elektor Heft 2012-07s120

Dieser Artikel zeigt, wie interaktive Klang-Maschinen auf der Basis von gewöhnlichen Arduino-Uno-Boards funktionieren.
Natürlich eignet sich das hier vermittelte Know-How und die Software auch zur Übertragung auf Arduino Mega, Arduino Mini oder andere Arduino-Lösungen mit 8-bit-Controllern.
Außerdem ist dieser Kurs ein guter Einstieg in die Arduino-Welt.

Artikel herunterladen...

704_d_BASCOM-x_2012-07s120  Teil 1a Hello World & Arduino Tonerzeugung_1a.pdf


Teil 1b: Arduino als Sound-Player

Veröffentlicht in elektor Heft 2012-09s056



Bei unseren diversen Code-Experimenten haben wir uns bisher der arduino-eigenen Sprache bedient.
Jetzt aber geht es dem Controller des Arduino Uno an den Kragen:
Der ATmega328 wird auf „low level“ gehackt, um Code zu erzeugen, der Daten aus einer WAVE-Datei im Programmspeicher ablegt und diese natürlich auch hörbar machen kann.

Artikel herunterladen...

704_d_BASCOM-x_2012-09s056  Teil 1b Arduino als Sound-Player_1a.pdf


Teil 2: Fernauslesen von Sensoren per Mobilfunk

Veröffentlicht in elektor Heft 2012-10s036



Konzepte wie IoT (Internet of Things) oder M2M (Machine to Machine) sind in aller Munde.
In dieser Folge unserer Arduino-Serie werden die Möglichkeiten der Mobilfunk-Datenkommunikation für eigene Projekte beleuchtet.
Zusammen mit der spanischen Telefongesellschaft Telefonica hat der Autor ein GSM-Shield und eine komfortable Library für Arduino-Boards entwickelt.
Wir zeigen anhand von einfachen Beispielen, wie man mit wenigen Codezeilen eine Menge erreichen kann.

Artikel herunterladen...

704_d_BASCOM-x_2012-10s036  Teil 2 Fernauslesen von Sensoren per Mobilfunk_1a.pdf


Teil 3a: Android-Smartphone mit der realen Welt verbinden

Veröffentlicht in elektor Heft 2012-11s064



Mit Android und Arduino ist es für jeden möglich, Hardware-Erweiterungen für Smartphones und Tablets zu bauen.
Der dritte Teil unserer Serie bietet eine Anleitung, wie man solche Erweiterungen und passende Apps entwickeln kann.
In dieser Folge experimentieren wir mit dem Arduino Mega ADK und loten aus, wie wir uns mit einem unter Android laufenden Smartphone oder Tablet verbinden können.

Artikel herunterladen...

704_d_BASCOM-x_2012-11s064  Teil 3a Android-Smartphone mit der realen Welt verbinden_1a.pdf


Teil 3b: Android-Smartphones & externe Sensoren

Veröffentlicht in elektor Heft 2012-12s056



In der letzten Folge stellten wir eine Reihe von Tools für die Arbeit mit Android und dem Arduino Mega ADK vor.
Diese Ausgabe gehen wir noch einen Schritt weiter und zeigen, wie man mit einem Smartphone Sensoren auslesen kann, die an Arduino angeschlossen sind.
Wenn alle Entwicklungs-Tools am richtigen Platz sind, dann sind die Ausführung von Code im Smartphone und die Kommunikation mit Arduino sehr einfach.
Man kann direkt mit den Beispielen loslegen, die bei den ADK-Libraries dabei sind!

Artikel herunterladen...

704_d_BASCOM-x_2012-12s056  Teil 3b Android-Smartphones & externe Sensoren_1a.pdf


Teil 4:  Pflanzenbewässerung für kommunale Zwecke

Veröffentlicht in elektor Heft 2013-01s090



In meiner Bauteilkiste hatten sich viele Dinge angesammelt, die ich für experimentelle Projekte gekauft hatte, welche niemals fertig gestellt wurden.
In einer dieser Schachteln fand ich ein Punkt-Matrix-Display und einige Taster.
Da kam mir die Idee, daraus eine Art Uhr zu bauen.
Also ergänzte ich die alten Bauteile durch einen neuen RTC-Chip (Real Time Clock) und machte mich an den Aufbau…

704_d_BASCOM-x_2013-01s090  Teil 4  Pflanzenbewässerung für kommunale Zwecke_1a.pdf


Teil 5:  Keksdieb gefasst!

Veröffentlicht in elektor Heft 2013-04s052



Irgendjemand stibitzte Kekse aus einer Dose in der Küche! Was tun? Wir beschlossen, dem Dieb eine Falle zu stellen.
Die Aufgabe war klar und wir hatten zur Lösung Hilfsmittel wie eine Webcam und ein Arduino-Board zur Verfügung.

Artikel herunterladen...

704_d_BASCOM-x_2013-04s052  Teil 5  Keksdieb gefasst!_1a.pdf



Teil 6:   Reisen im Namen der Elektronen

Veröffentlicht in elektor Heft 2013-07s116



Wenn ich an Elektronik denke, fallen mir zwei Dinge ein: die zunehmende Vernetzung der Dinge, aber auch die Möglichkeit, Jugendlichen etwas Sinnvolles beizubringen.
Ich finde, dass wir im ersten Bereich schon sehr weit gekommen sind.
Bei der Ausbildung junger Leute gibt es dagegen noch vielfach Raum für Verbesserungen.
Über eine Initiative auf diesem Gebiet berichtet dieser Artikel.

704_d_BASCOM-x_2013-07s116  Teil 6   Reisen im Namen der Elektronen_1a.pdf





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

Bewegungsgesteuerter Fernauslöser - mit Arduino

Veröffentlicht in elektor Heft 2013-09s058



Ein preiswertes Nachtlicht mit Bewegungssensor, eine Infrarot-LED, nur wenige passive Bauelemente und dazu ein passend programmiertes Arduino-Board:
Daraus entsteht ein System, das bei Bewegungen eines Objekts drahtlos eine Fotokamera auslöst.

704_d_BASCOM-x_2013-09s058  Bewegungsgesteuerter Fernauslöser - mit Arduino_1a.pdf



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

Arduino Yún - das Beste zweier Welten?

Veröffentlicht in elektor Heft 2013-12s060



Die Cloud bietet Zugriff auf alle Daten, egal wo man ist. Doch eine Verbindung mit der Cloud erfordert einen Internet-Zugang, vorzugsweise per Funk.
Hier kommt Arduino Yún ins Spiel.
Yún ist chinesisch und bedeutet Wolke.
Das Board hat schon WLAN an Bord.
Doch Yún kann mehr als nur WLAN — hier läuft auch Linux. Arduino unter Linux? Linux auf Arduino?
Wie funktioniert das?

704_d_BASCOM-x_2013-12s060  Arduino Yún - das Beste zweier Welten_1a.pdf




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

CAN mit Bascom-AVR

Veröffentlicht in elektor Heft 2013-01s102



Bascom-AVR, der bekannte Basic-Compiler für AVR-Mikrocontroller unter Windows, unterstützt von Haus aus zahlreiche periphere Komponenten.
Eine Ausnahme machte bisher der CAN-Bus (Controller Area Network).
Ursprünglich war dieser Bus für die System-Kommunikation in Fahrzeugen gedacht, doch inzwischen ist CAN in fast alle Bereiche der Technik vorgedrungen.

Artikel herunterladen...

704_d_BASCOM-x_2013-01s102  CAN mit Bascom-AVR_1a.pdf




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

Laserprojektion mit ARDUINO

Veröffentlicht in elektor Heft 2012-07s134



Diese Konstruktion projiziert mit einem Laserstrahl attraktive Ornamente auf fast jede Oberfläche.
Der Grundidee war der spielerische Einsatz von Laserstrahlen, wie sie von den bekannten Laserpointern produziert werden.
Der Laserstrahl wird von einem Spiegel umgelenkt, der auf der Achse eines Motors montiert ist.
Da der Spiegel nicht absolut gerade auf der Motorachse sitzt, beschreibt der Laserstrahl bei jeder Achsdrehung einen Kegel.
Der Lichtkegel fällt auf einen zweiten Spiegel, der von einem zweiten Motor gedreht wird. Vom zweiten Spiegel wird der Laserstrahl auf die Projektionsfläche geworfen.

Artikel herunterladen...

704_d_BASCOM-x_2012-07s134  Laserprojektion mit Arduino_1a.pdf






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

Regeln mit ARDUINO und PC

Universeller µC-gesteuerter Regler mit PC-Schnittstelle

Veröffentlicht in elektor Heft 2012-03s054



In technischen Systemen sind Regelungen allgegenwärtig. Realisieren lassen sie sich mit Mikrocontroller-Systemen wie dem bekannten Arduino-Board.
Ergänzt durch eine unkomplizierte Schnittstellenkarte entsteht ein System, das sich mit den unterschiedlichsten Sensoren und Aktoren kombinieren lässt.
Die hier beschriebene Regelung arbeitet autonom, sie kann aber auch über einen PC gesteuert werden.

Artikel herunterladen...


704_d_BASCOM-x_2012-03s054  Regeln mit Arduino und PC_1a.pdf






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

Gleich oder verschieden?

ARDUINO UNO versus GR SAKURA

Veröffentlicht in elektor Heft 2013-07s060



Der Halbleiterhersteller Renesas legt besonderen Wert darauf, dass das neueste Board vom Typ GR Sakura arduino-kompatibel ist.
Unsere Übersicht der Eigenschaften erlaubt Ihnen selbst zu beurteilen, wie weit diese Kompatibilität geht.

704_d_BASCOM-x_2013-07s060  Gleich oder verschieden_1a.pdf




DIN A4 ausdrucken

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

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




Comments