Blinkende LED

// blinkende LED
// Eine Leuchtdiode wird eine Sekunde an, und dann wieder eine Sekunde ausgeschaltet. Dieser Vorgang wird endlos wiederholt.

void setup() {   
  pinMode(13, OUTPUT); // Port 13 wird als Ausgang festgelegt
}

void loop() {
  digitalWrite(13, HIGH); // Port 13 wird high geschaltet
  delay(1000); // eine Sekunde warten
  digitalWrite(13, LOW); // Port 13 wird low geschaltet
  delay(1000); // eine Sekunde warten
}

Schrittmotortreiber DRM8825

Beschreibung

Spezifikationen

Pinbelegung Modul


GND = Masse
DIR = Drehrichtung
STEP = Schritt
SLEEP =
RESET =
M2 =
M1 =
M0 =
ENABLE =
FAULT =
A2 = Motorwicklung A
A1 = Motorwicklung A
B1 = Motorwicklung B
B2 = Motorwicklung B
GND = Masse
VMOT = Spannungsversorgung 8 – 45V DC für Motor

Links

https://iknowvations.in/de/arduino/drv8825-stepper-motor-driver-with-arduino-tutorial/

RGB LED-Modul

Vorwiderstände (102) mit 1kOhm sind auf dem Modul schon vorhanden.

Pinbelegung:
R = Rot
G = Grün
B = Blau
GND = Masse

// RGB LED-Modul
// Die vorhandenen Farben schalten

  int BLAU = 13;
  int GRUEN = 12;
  int ROT = 11;
  
void setup() {
  pinMode(BLAU, OUTPUT); // Port als Ausgang und als BLAU festlegen
  pinMode(GRUEN, OUTPUT); // Port als Ausgang und als GRUEN festlegen
  pinMode(ROT, OUTPUT); // Port als Ausgang und als ROT festlegen
}

void loop() {
  digitalWrite(BLAU, HIGH); // Blau wird high geschaltet
  delay(500); // warten
  digitalWrite(BLAU, LOW); // Blau wird high geschaltet
  digitalWrite(GRUEN, HIGH); // Gruen wird high geschaltet
  delay(500); // warten
  digitalWrite(GRUEN, LOW); // Gruen wird low geschaltet
  digitalWrite(ROT, HIGH); // ROT wird high geschaltet
  delay(500); // warten
  digitalWrite(ROT, LOW); // ROT wird low geschaltet
}

Arduino – Hallo Welt

Allgemeine Programmstruktur

Ein Programm besteht grundsätzlich aus dem setup() – und dem loop() – Block.

Der setup()-Block wird einmal beim Neustart oder beim hochladen eines Programm auf den Arduino ausgeführt.

Der loop()-Block wird, nach dem setup()-Block, so lange zyklisch wiederholt bis der Arduino ausgeschaltet wird.

// Allgemeine Programmstruktur
//
// Ausgabe von "Hallo Welt" am Seriellen Monitor über die Serielle Schnittstelle
//

void setup() {
  // initialisiere die serielle Kommunikation mit 9600bps:
  Serial.begin(9600); }

void loop() {
  Serial.println("Hallo Welt!" );   
 // warte 10ms bis zur nächsten loop()-Ausführung.
  delay(10); }

Achtung:
Wenn die Serielle Schnittstelle verwendet wird, dürfen die Ports 0 und 1 nicht verwendet werden.

http://popovic.info/html/arduino/arduinoUno_1.html

Satanlage ausrichten

Hardware

Die Hardware ist zum großen Teil aus Holz.

Die 3D-Drucke stammen von TNT3Dprint.de.
Zahnriemenscheibe Azimut:
teeth = 120; // Number of teeth
profile = 12; //12=GT2_2mm
motor_shaft = 50.1; // NEMA17 motor shaft exact diameter = 5

m3_dia = 3.2; // 3mm hole diameter
m3_nut_hex = 1; // 1 for hex
m3_nut_flats = 5.7; // normal M3 hex nut exact width = 5.5
m3_nut_depth = 2.7; // normal M3 hex nut exact depth = 2.4

retainer = 1; // Belt retainer above teeth
retainer_ht = 1.5; // height of retainer flange over pulley
idler = 1; // Belt retainer below teeth
idler_ht = 1.5; // height of idler flange over pulley

pulley_t_ht = 8; // length of toothed part of pulley
pulley_b_ht = 8; // pulley base height
pulley_b_dia = 70; // pulley base diameter
no_of_nuts = 3; // number of captive nuts required
nut_angle = 120; // angle between nuts
nut_shaft_distance = 1.2; // distance between inner face of nut and shaft

Lagerbock

Der Lagerbockbesteht aus drei aufeinandergeleimte Multiplexplatten. In diese wurde unten und oben ein Lager, Innendurchmesser 50mm eingesetzt.

Lager: 2 x Rillenkugellager 6010 2RS 50 x 80 x 16 mm

Lagerbock mit Zahnriemenscheibe 120Zähne

Azimut, Elevations- und Deklinnationswinkel

Azimutwinkel berechnen:
A = Azimutwinkel
gLE = geographische Länge des Empfangsort
gBE = geographische Breite des Empfangsort
gLS = geographische Länge der Satelittenposition

tan(gLE – gLS)
A = 180° + arctan ————–
sin gBE

Für Astra mit 19,2 Ost würde das z.B. so aussehen:
gLE = 8,7582988 (Längengrad für Knittlingen)
gBE = 49,0240107 (Breitengrad für Knittlingen)
gLS = 19,2

tan(8,7582988 – 19,2)
A = 180° + arctan ——————-
sin 49,0240107

Elevation berechnen:

GPS-Koordinaten für Knittingen:
49° 1′ 26.439″ N
8° 45′ 29.876″ E

http://www.fen-net.de/satellitentechnik-online/texte/orbit/azimut.htm

// Azimut und Elevation berechnen

void setup() {
  double A; // Azimutwinkel
  double E; // Elevationswinkel
  
  // Daten für Stuttgart
  String Ort = "Stuttgart";
  float gLE = 9.2L; // Längengrad Stuttgart
  float gBE = 48.8L; // Breitengrad Stuttgart
  
  // Daten für Berlin
  /*String Ort = "Berlin";
  float gLE = 13.4L; // Längengrad Berlin
  float gBE = 52.5L; // Breitengrad Berlin
  */
  
  String Satellit = "Astra 19,2 Ost";
  float gLS = 19.2L; // Längengrad Astra
  //string Satellit = "Eutelsat F2 10,0 Ost";
  //float gLS = 10.0L;   // Längengrad Eutelsat F2

  // Die Grademaße in Bogenmaße umrechnen
  float L = 3.14/180 * gLE;
  float B = 3.14/180 * gBE;
  float P = 3.14/180 * gLS;

  // Azimut in Gradmaß berechnen
  A = 180 + 180/3.14 * atan (tan(L - P) / sin(B));

  // Elevation im Gradmaß berechnen
  E = 180/3.14 * atan (((cos(B) * cos(L - P)) -0.1513) / sqrt(1-sq(cos(B) * cos(L - P))));
  
  // initialisiere die serielle Kommunikation mit 9600bps:
  Serial.begin(9600); 
  
  // Ausgabe der berechneten Winkel
  Serial.println ("Ort: " + Ort);
  Serial.println ("Satellit: " + Satellit);
  Serial.print ("Azimut = ");
  Serial.print (A);
  Serial.print (" Elevation = ");
  Serial.println (E);
}

RAMPS 1.4 zur Ansteuerung

Für die Ansteuerung der Schrittmotoren wird ein RAMPS 1.4 – Shield verwendet. Folgende Anschlüsse werden verwendet

Azimut
E0 = Anschluss für den Schrittmotor „Azimut“
X_MIN = Endschalter Azimut MIN
X_MAX = Endschalter Azimut MAX

Elevation
E1 = Anschluss für den Schrittmotor „Elevation“
Y_MIN = Endschalter Elevation MIN
Y_MAX = Endschalter Elevation MAX

Kompasssensor am RAMPS 1.4

Der Kompassensor so wie eventuell weitere Sensoren werden über den I2C-Bus am RAMPS 1.4 angeschlossen

5V = rot
GND = schwarz
20 = blau
21 = grün

RF Transmitter mit Empfänger 433Mhz

Beschreibung

Das ist 433Mhz RF Transmitter mit Empfänger Satz für Arduino ARM MCU drahtlos
Anwendungsumgebung:
Fernbedienungsschalter, Empfängermodul, Motorräder, Automobil Antidiebstahlprodukte, Haussicherheitsprodukte, elektrische Türen, Verschlusstüren, Fenster, Fernbedienungssteckdose, Fernbedienung LED, entfernte Audiofernbedienung elektrische Türen, Werkstättentürenfernbedienung, Fernbedienung einziehbare Türen, entferntes Volumentor, Pantüren, Fernbedienungstürenöffner, Tür Schlussgerätregelsystem, Fernbedienungsvorhänge, alarmieren Gastgeber, Warnung, Fernbedienungsmotorradfernbedienung elektrische Autos, Fernbedienung mp3.

Spezifizierung:

Empfängermodul:
Produktmodell: Xd-rf-5v
Betriebsstromspannung: dc5v
Ruhiger Strom: 4ma
Empfang der Frequenz: 433.92 MHz
Empfängerempfindlichkeit:-105db
Größe:30x14x7mm

Transmitter:
Technische Rahmen dessen
Produktmodell: xd-fst
Startentfernung:20-200 Meter (verschiedene Stromspannung, verschiedene Ergebnisse)
Betriebsstromspannung:3.5-12v
Dimensionen: 19 * 19 Mm
Betriebsweise: Sind
Übertragungsrate: 4 Kilobyte / s
Übertragungspower: 10mw
Übertragungsfrequenz: 433 M
Pinbelegung von linkem → Recht: (Daten; VCC; GND)

Arduino – Bitmanipulation

&       bitweise AND – Verknüpfung (bitwise and)
<<     (bitshift left)
>>     (bitshift right)
^       bitweise XOR – Verknüpfung (bitwise xor)
|         bitweise OR – Verknüpfung (bitwise or)
~       bitweise NOT – Verknüpfung (bitwise not)

Bit Setzen 

// Setzen von Bit 2 und 7 im Register
// Die Bit's in Register werden mit B10000100 ODER verknüpft

   Register |= B10000100; // Nur Bit 2 und 7 werden auf 1 gesetzt, die restlichen Bits bleiben unverändert
   // entspricht
   Register = Register | B10000100;

// oder
   Register |= (1 << Bit2); //Bit2 wird auf 1 gesetzt
   Register |= (1 << Bit7); //Bit7 wird auf 1 gesetzt

// oder
   Register |= (1 << Bit2) | (1 << Bit7); //Bit2 und Bit7 werden auf 1 gesetzt

Bit löschen

// Löschen von Bit 2 und 7 im Register
   Register &= ~B10000100;
   // entspricht
   Register = Register & ~B10000100;

// oder
   Register &= ~(1 << Bit2); // Bit2 wird auf 0 gesetzt
   Register &= ~(1 << Bit7); // Bit7 wird auf 0 gesetzt

// oder
   Register &= ~(1 << Bit2) | (1 << Bit7); //Bit2 und Bit7 werden auf 0 gesetzt

Bit invertieren (umschalten)

// invertiert Bit 4 im Register 
   Register ^= B00010000;
   // entspricht
   Register = Register ^ B00010000; // Invertiert Bit4

// oder
   Register ^= (1 << Bit4); // Invertiert Bit4

Bit abfragen

// abfragen des  WGM12-Bits im TCCR1B Register
   byte bitStatus = (TCCR1B & (1 << WGM12)) >> WGM12;

// oder mit
// Bedingungsoperator
   bool bitStatus = (TCCR1B & (1 << WGM12)) == (1 << WGM12) ? 1 : 0;

Quellen:
arduino-projekte.webnode.at

Arduino – Ein- / Ausgangsports

  1. Data Direction Register x (DDRx)
    Die einzelnen Bits geben an, ob der jeweilige Pin als Ein- oder Ausgang benutzt wird.
    DDxn = 0 -> Eingang
    DDxn = 1 -> Ausgang
  2. Port x Data Register (PORTx)
    Wenn ein Pin im Data Direction Register x (DDRx) als Ausgang definiert ist:
    PORTxn = 0 -> Ausgabe von logisch „0“
    PORTxn = 1 -> Ausgabe von logisch „1“
    Wenn ein Pin im Data Direction Register X (DDRX) als Eingang definiert ist:
    PORTxn = 0 -> Interner Pullup-Widerstand deaktiviert
    PORTxn = 1 -> Interner Pullup-Widerstand aktiviert
  3. Port x Input Pins Register (PINxn)
    Wenn ein Pin im Data Direction Register X (DDRX) als Eingang definiert ist, stellt PINXn des jeweiligen Zustand des Pins dar.

Tabelle 1:

Bit (n) 7 6 5 4 3 2 1 0
DDRx  DDxn DDxn DDxn DDxn DDxn DDxn DDxn DDxn
PORTBn D13 D12 D11 D10 D9 D8
PORTCn A5 A4 A3 A2 A1 A0
PORTDn D7 D6 D5 D4 D3 D2 D1 D0
PINx PINx7 PINx6 PINx5 PINx4 PINx3 PINx2 PINx1 PINx0
Ein- / Ausgangsports

x = Portnummer, n = Bitnummer

Beispiel:
Setzen der Binär-Pins D2 und D7 als Ausgang:

(D2 und D7 sind die Bits 2 und 7 am Port D)

DDRD |= B10000100; // Nur Bit 2 und 7 werden verändert

// oder

DDRD |= (1 << DDD2); //D2 ist Ausgang
DDRD |= (1 << DDD7); //D7 ist Ausgang

// oder

DDRD |= (1 << DDD2) | (1 << DDD7); //D2 und D7 sind Ausgaenge


Ausgabe von logisch „1“ und logisch „0“ am Beispiel Binär-Pin D10:

(D10 ist das Bit 2 am Port B)

//D10 als Ausgang setzen
DDRB |= (1 << DDB2);

//D10 auf "1" setzen
PORTB |= (1 << PORTB2);

//D10 auf "0" setzen
PORTB &= ~(1 << PORTB2);


Einlesen des Binär-Pins D5 mit internem Pullup-Widerstand:

(D5 ist das Bit 5 am Port D)

//D5 als Eingang setzen
DDRD &= ~(1 << DDD5);

//Pullup-Widerstand aktivieren
PORTD |= (1 << PORTD5);

//Abfrage des Eingangs-Pin D5
byte bitStatus = (PIND & (1 << PIND5)) >> PIND5;