Mähroboter Landroid

Heute 16.04.2018 habe ich den WORX-Landroid SB450 WR102SI.1 beim Bauhaus in Pforzheim gekauft.

20 V, Li-Ionen, 2 Ah, Max. Flächenempfehlung: 450 m²

  • Mäht bis zu 450 m² Rasenfläche vollautomatisch im Zufallsprinzip
  • W-LAN Funktion für einfache Programmierung per Smartphone
  • Multi-Zonenfunktion für unterschiedlich beschaffene Gartenbereiche
  • Schafft Steigungen bis 35 %
  • Patentierte AIA Technik ermöglicht das mühelose Mähen von engen und verwinkelten Flächen

3D Drucker – Extruderumbau

  1. Der bisherige Extruder, direkt am Hotend soll auf einen Bowedenextruder umgebaut werden.

Gründe für den Umbau:

  • PLA-Filament wird beim Fördern teilweise so warm, das es durch den Extruder nicht mehr in den Kühlkörper des Hotend’s geschoben wird. Durch das trennen von Hotend und Extruder verspreche ich mir einen besseren Materialtransport.
  • Die Mechanik am Extruder wird durch das Hotend nicht mehr erwärmt
  • Die mitfahrende X-Achse wird um einiges leichter. Der Schrittmotor plus Halterung sowie der jetzige Vorschub entfallen auf der X-Achse.

Die erforderlichen Teile habe ich bestellt bez. werden aus Hartholz hergestellt. Später werden die Holzteile mit ABS gedruckt.

HyperCube 3D-Drucker

Nach dem ich den Franzis-Mendel erfolgreich zum laufen gebracht habe, habe ich beschlossen, einen HyperCube 3D Drucker zu bauen. Den HyperCube habe ich bei thingiverse.com gefunden. Der Drucker HyperCube 3D Printer/CNC von thingiverse-Mitglied Tech2C ist lizensiert unter der  Creative Commons – Attribution – Non-Commercial Lizens.

Von Tech2C gibt es bei YouTube einen BuildLog wo Tech2C genau den Aufbau, leider nur auf Englisch, beschreibt. Das BuildLog besteht aus zur Zeit 20 sehr ausführlichen und guten Videos.

Warum will ich den Drucker bauen?
Der Franzis-Mendel funktioniert, vor allem nach den diversen Verbesserungen, gut. Vom HyperCube erwarte ich allerdings einiges mehr an Genauigkeit, und vor allem an Geschwindigkeit.

3D Drucker – Schritte pro mm berechnen

Anzahl der Microschritte
RAMPS unterstützt 1/16 Schritte (Steps)

Berechnung Riemenscheibe:
Berechnung Schritte (Steps)/ mm

Motordaten:
Schrittwinkel = 1,8 Grad/Schritt
Schritte für eine Umdrehung = 360 Grad / 1,8 Grad/Schritt
Schritte für eine Umdrehung = 200 Schritte

Motrotreiber:
Jeder Schritt wird in Microschritte aufgeteilt
Treiber Microschritte = 1/16
Microschritte pro Umdrehung = 200 Motorschritte * 16 Microschrittt = 3200 Schritte

Riemenscheibe:
Zahnteilung = 2mm (GT2 Belt)
Anzahl Zähne = 36 (20)
Scheibenumfang = Zahnteilung * Zähne
Scheibenumfang = 2mm * 36 Zähne
Schiebenumfang = 72mm (40mm)

Schritte pro mm = 3200 Schritte/Umdrehung / 72mm
Schritte pro mm = 44,4444 (80) Schritte
==================================

Berechnung Trapetzspindel:
Berechnung Schritte (Steps)/mm

Motordaten und Treiberdaten bleiben wie bei der Riemenscheibe

Trapetzgewindespindel:
Steigung der Spindel (Pitch) = 2mm/Umdrehung

Schritte pro mm = 3200 Schritte/Umdrehung / 2mm
Schritte pro mm = 1600 Schritte
==================================

Berechnung Extrudervorschub:
Berechnung Schritte (Steps)/mm

Motordaten und Treiberdaten bleiben wie bei der Riemenscheibe

Vorschubrad für 1,75mm und 3mm Filament:
Durchmesser Zahnrad = 11mm
Umfang = 3,14 * Durchmesser = 34,5mm
Schritte pro mm = 3200 Schritte/Umdrehung / 34,5mm
Schritte pro mm = 92,75 Schritte

 

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;

 

 

Arduino – Pin Change Interrupt

Standardmäßig stellt der Arduino UNO mit der Funktion „attachInterrupt()“ nur 2 Interrupt-Pins (Pin 2 und 3) zu Verfügung. Durch entsprechende Registerprogrammierung kann jedoch durch jeden Ein-/Ausgangspin ein „Pin Change Interrupt“ ausgelöst werden.

Wie der Name „Pin Change Interrupt“ bereits sagt, wird bei jeder Zustandsänderung eines Eingangssignals, also sowohl bei steigender als auch bei fallender Flanke ein Interrupt ausgelöst. Die Auswertung, welche Flanke den Interrupt ausgelöst hat, bzw. falls mehr als ein Pin Change Interrupt pro Port programmiert wurde, welcher Pin einen Interrupt ausgelöst hat, muss in der „Interrupt-Serviceroutine“ erfolgen.

Verwendete Register:
PCICR = Pin Change Interrupt Register
PCMSKx = Pin Change Mask Register x (0 / 1 / 2)
SREG = Statusregister

Vorgehensweise:
1. Alle Interrupts sperren
2. Port für Interrupt freischalten
3. Pin(s) für Pin Change Interrupt freigeben
4. Alle Interrupts freigeben
5. Interrupt-Serviceroutine

1. Alle Interrupts sperren
Während der Manipulation der Interruptregister sollte kein Interrupt ausgelöst werden. Durch löschen des Global Interrupt Enable Bits (I) im Status Register (SREG) werden alle Interrupts gesperrt

Bit 7 6 5 4 3 2 1 0
I T H S V N Z C
SREG – Status Register
// Löschen des Global Interrupt Enable Bits (I) im Status Register (SREG)
   cli(); // alle Interrupts sperren

// Setzen des Global Interrupt Enable Bits (I) im Status Register (SREG)
   // sei(); // alle Interrupts zulassen
   // oder
   SREG |= 0x80; // alle Interrupts zulassen

 2. Port für Interrupt freischalten

Im Pin Change Interrupt Control Register (PCICR) wird festgelegt welcher Ports für einen Pin Change Interrupt zugelassen werden. Den Ports sind bestimmte Pins zugeordnet.

Bit 7 6 5 4 3 2 1 0
 PCICR PCIE2 PCIE1 PCIE0
Pin D0 – D7 A0 – A5 D8 – D13
Port D C B
PCICR – Pin Change Interrupt Control Register

In Abhängigkeit für welche Pins ein Interrupt ausgelöst werden soll, ist das entsprechende Pin Change Interrupt Enable Bit (PCIEx) zu setzen.

// Setzen des PCIE2-Bit im Pin Change Interrupt Control Register (PCICR)
   PCICR |= (1 << PCIE2);

// Zurücksetzen / löschen des PCIE2-Bit im Pin Change Interrupt Control Register (PCICR)

// Abfragen

3. Pin(s) für Pin Change Interrupt freigeben
Durch setzen des Pin Change Enable Mask Bit (PCINTx) im entsprechenden Pin Change Enable Mask Register (PCMSKx) wird die Auslösung eines Interrupt ermöglicht.

Bit 7 6 5 4 3 2 1 0
 PCMSK0 PCINT7 PCINT6 PCINT5 PCINT4 PCINT3 PCINT2 PCINT1 PCINT0
PIN D13 D12 D11 D10 D9 D8
Port B
PCMSK0 – Pin Change Mask Register 0
Bit 7 6 5 4 3 2 1 0
 PCMSK1  PCINT14 PCINT13 PCINT12 PCINT11 PCINT10 PCINT9 PCINT8
PIN A5 A4 A3 A2 A1 A0
Port C
PCMSK1 – Pin Change Mask Register 1
Bit 7 6 5 4 3 2 1 0
 PCMSK2 PCINT23 PCINT22 PCINT21 PCINT20 PCINT19 PCINT18 PCINT17 PCINT16
PIN D7 D6 D5 D4 D3 D2 D1 D0
Port D
PCMSK2 – Pin Change Mask Register 2
//Setzen des Pin Change Enable Mask Bit 18 (PCINT18)  ==> Digital-Pin D2
  PCMSK2 |= (1 << PCINT18);

// Zurücksetzen / löschen

// Abfragen

4. Alle Interrupts freigeben
Durch setzen des Global Interrupt Enable Bits (I) im Status Register (SREG) werden alle Interrupts freigegeben. Siehe 1. Alle Interrupts sperren.

5. Interrupt Serviceroutine
Wird ein Pin Change Interrupt ausgelöst, verzweigt das Programm in die entsprechende Serviceroutine. Die Namen der Interrupt-Serviceroutinen sind vom System fest vorgegeben und können nicht ohne weiteres verändert werden.

Pin Change Interrupt PCMSK0 -> Serviceroutine ISR(PCINT0_vect)
Pin Change Interrupt PCMSK1 -> Serviceroutine ISR(PCINT1_vect)
Pin Change Interrupt PCMSK2 -> Serviceroutine ISR(PCINT2_vect)

ISR = Interrupt Service Routine

Beispeilcode
Als Beispiel soll der Pin Change Interrupt am Digital-Pin D2 ausgelöst werden:

void setup(){
  //Löschen des Global Interrupt Enable Bits (I) im Status Register (SREG)
  cli();

  //Setzen des PCIE2-Bit im Pin Change Interrupt Control Register (PCICR)
  PCICR |= (1 << PCIE2);

  //Setzen des Pin Change Enable Mask Bit 18 (PCINT18)  ==> Digital-Pin 2
  PCMSK2 |= (1 << PCINT18);

  //Setzen des Global Interrupt Enable Bits (I) im Status Register (SREG)
  SREG |= 0x80; // gleichwertig mit "sei();"
}

...

//Aufruf der Interrupt Serviceroutine
ISR(PCINT2_vect){
  //Programmcode der Service-Routine
}


Quellen:
arduino-projekte.webnode.at
ATmega328/P Datenblatt

 

DALI Master / Slave

Aufbau eines DALI-Master / Slave

 

Arduino

Simple DALI Controller
DALI Interface für AVR und PIC 

Dali Click
https://www.mikroe.com/dali-click

Belegung auf der Bestückten Seite

NC ICP
TX INT (RX)
PHY NC
NC NC
NC NC
NC NC
3.3V 5V
GND GND

Versuchsbauteile die mir zur Verfügung stehen:

Philips Actilume Controller LCC 1653/01

Tridonic LCA 75W 100-400mA one4all Ip PRE ArtNr.:28000657
Tridonic LCA 35W 24V one4all SC PRE ArtNr.: 28001662

MDT SCN-DALI64.02 Dali-KNX Gateway

MW LCM-25DA mit LED Leuchte