Posts mit dem Label PWM Signal werden angezeigt. Alle Posts anzeigen
Posts mit dem Label PWM Signal werden angezeigt. Alle Posts anzeigen

Samstag, 27. Dezember 2025

PWM-Signal auf dem Raspberry PI PINs läst sich nicht ansteuern

Beim Prüfen der PWM-Ausgänge musste ich feststellen, dass sich die Pins nicht ansprechen ließen.

Hierfür habe ich ein C#-Projekt mit .NET erstellt, das auf die GPIOs zugreift und ein PWM-Signal zur Steuerung von zwei Servos einrichtet.
Selbst mit direkten Shell-Kommandos ließen sich die PWM Pins auf dem Raspberry Pi nicht einstellen.


Verwendete Hardware

  • Raspberry Pi 4
  • Raspbian OS
  • Mini-Servo

Ziel

Einen GPIO-Pin für PWM-Signale korrekt einrichten, sodass ein Servo zuverlässig gesteuert werden kann.

  • GPIO12 auf PWM festlegen
  • GPIO13 auf PWM festlegen


Welche Version von Raspbian OS ist installiert?

Mit folgendem Befehl werden mehrere Zeilen ausgegeben, die Informationen über die aktuell verwendete Linux-Version liefern:

 hostnamectl  




PWM zunächst einrichten

Über die config.txt kann der PWM-Eintrag gesetzt werden.
In älteren Raspbian-Versionen befand sich diese Datei unter /boot/config, der Pfad hat sich jedoch geändert zu:

 /boot/firmware/config.txt  

Bearbeiten der Datei:

 sudo nano /boot/firmware/config.txt  

Ganz nach unten scrollen und folgenden Eintrag setzen:

 dtoverlay=pwm-2chan  

HINWEIS: Dieser Eintrag ist Teil des Problems. Die korrekte Lösung wird im letzten Abschnitt unter „Dauerhaft einstellen“ beschrieben.

Speichern mit STRG + O, bestätigen mit ENTER.
Nano mit STRG + X verlassen.

Anschließend muss das Betriebssystem neu gestartet werden:

 sudo reboot  

Servo anschließen

Der Servo kann nun am Raspberry Pi angeschlossen werden.
Die Stromversorgung sollte jedoch nicht über die GPIO-Pins des Raspberry Pi erfolgen. Eine Ausnahme gilt nur für Mini-Servos ohne nennenswerte Last und mit sehr geringem Stromverbrauch.

Zwar kann die USB-C-Stromversorgung bis zu 3 A liefern, dennoch empfiehlt es sich, unter 500 mA zu bleiben und die Stromaufnahme nicht auszureizen.


Einrichtung über die Shell

Zunächst ein einfacher Test, um einen Servo direkt über die Shell anzusteuern.

Prüfen, ob der PWM-Chip verfügbar ist

 ls /sys/class/pwm  

Das erwartete Ergebnis ist pwmchip0.
Andernfalls muss der Chip über die config.txt korrekt eingerichtet werden.




Prüfen, ob pwm0 vorhanden ist

 ls /sys/class/pwm/pwmchip0  

In meinem Fall wurde nur pwm1 angezeigt.




PWM-Kanal exportieren

 echo 0 | sudo tee /sys/class/pwm/pwmchip0/export  

Danach sollte auch pwm0 verfügbar sein.




PWM für Servo einstellen

Periode: 20 ms

 echo 20000000 | sudo tee /sys/class/pwm/pwmchip0/pwm0/period  

Pulsweite für Mittelstellung (1,5 ms)

 echo 1500000 | sudo tee /sys/class/pwm/pwmchip0/pwm0/duty_cycle  

PWM aktivieren

 echo 1 | sudo tee /sys/class/pwm/pwmchip0/pwm0/enable  

An dieser Stelle sollte der Servo in die Mittelstellung fahren.

Servo nach links bewegen (Pulsweite 1 ms)

 echo 1000000 | sudo tee /sys/class/pwm/pwmchip0/pwm0/duty_cycle  

Servo bewegt sich weiterhin nicht

Wenn sich der Servo trotz dieser Einstellungen nicht bewegt, liegt die Ursache sehr wahrscheinlich an der Pin-Konfiguration.
Als Nächstes wird der Status des GPIO-Pins geprüft:

 raspi-gpio get 12  

In meinem Fall erschien die Meldung „command not found“.




Alternative Prüfung

 pinctrl get 12  

Damit lässt sich ebenfalls die aktuelle Konfiguration von GPIO12 auslesen.
In meinem Fall ergab sich folgendes Ergebnis:



raspi-gpio-Paket installieren?

In aktuellen Versionen von Raspbian OS ist das Paket raspi-gpio nicht mehr standardmäßig installiert.
Ein Nachinstallieren ist grundsätzlich möglich:

 sudo apt update  
 sudo apt install raspi-gpio  

In meinem Fall trat dabei jedoch ein Fehler auf.


Offenbar ist hier entweder eine Anpassung seitens der Distribution erforderlich – oder das Paket wird nicht mehr vorgesehen.


Pin umstellen (Pin-Multiplexing)

In meinem Fall war GPIO12 als INPUT konfiguriert und musste über Pin-Multiplexing umgestellt werden.

GPIO12 auf PWM0 setzen:

 sudo pinctrl set 12 a0  

Die Änderung sollte ohne Neustart wirksam sein.
Bei mir bewegte sich der Servo danach endlich wie erwartet.


Dauerhaft einstellen

Rückblickend hätte ich diese Konfiguration direkt zu Beginn vollständig setzen sollen.
Hätte ich das früher gewusst, hätte ich mir viele Zwischenschritte erspart, da sich die meisten Lösungsansätze nur auf kurzfristige Workarounds beziehen.

Für eine dauerhafte PWM-Konfiguration muss folgender Eintrag in der Datei
/boot/firmware/config.txt gesetzt werden:

 dtoverlay=pwm-2chan,pin=12,func=4,pin2=13,func2=4  

Danach speichern mit STRG + O, bestätigen mit ENTER, Nano mit STRG + X beenden und anschließend neu starten:

 sudo reboot  

Fazit

Offensichtlich wurde mit der neuen Betriebssystemversion deutlich aufgeräumt. Viele Funktionen scheinen heute durch unterschiedliche Bibliotheken mehrfach vorhanden zu sein oder wurden neu strukturiert.

Erst mit Unterstützung von Microsoft Copilot und ChatGPT bin ich – nach zahlreichen Fragen und Fehlversuchen – auf diese Lösung gestoßen.
Über die klassische Google-Suche bzw. Gemini führte der Weg ebenfalls nicht direkt zum Ziel.

Ein möglicher Grund dafür ist der Wechsel des Raspbian OS von Bookworm auf Trixie, der intern offenbar einige Änderungen an der GPIO- und PWM-Konfiguration mit sich gebracht hat.

Dienstag, 13. Januar 2015

Arduino Control (Teil 3) – LED mit dem PC Dimmen

image

Nicht alles lässt sich immer sinnvoll mit Ein- und Ausschalten lösen. Möchte man eine LED dimmen, so sollte ein PWM Signal verwendet werden. Ein PWM verwendet einen Timer, um das Rechtecksignal abzubilden. Daher können nur sechs bestimmte Ausgänge am Arduino (D3, D5, D6, D9, D10, D11) verwendet werden. Die Pins sind daran zu erkennen, dass neben den Anschlüssen ein kleines Wellensymbol zu sehen ist (oder sie sind direkt mit PWM beschriftet).

image

Der Programm Code ist dem ersten Beispiel Ähnlich. Beim Senden jedoch, kann ein Wert von 0 bis 255 angegeben werden.

static void Main(string[] args)
{
    // Die Verwendete COM Verbindung
    // sollte der aus dem Arduino Programm entsprechen.
    SerialPort sp = new SerialPort("COM16", 115200);

    // Verbindung öffnen.
    // Wenn das Programm gestartet ist,
    // sollte der Arduino bereits mit dem PC verbunden sein.

    sp.Open();

    while (true)
    {
        Console.Write("Bitte geben sie einen Wert von 0 bis 255 ein und drücken sie anschließend die Enter Taste: ");

        // Abfrage eines Wertes.
        string readline = Console.ReadLine();

        // Zeichenkette in einen Integer Wert umwandeln.
        byte value = byte.Parse(readline);

       // Sendet den Wert.
        sp.Write(new byte[] { value }, 0, 1);
    }
}

Für den Empfang im Arduino wird diesmal für die LED Ansteuerung der Pin D3 verwendet. Und anstatt eines digitalWrite wird ein analogWrite verwendet.

// Pin 3 für die LED Beleuchtung
int pinPwmOut = 3;

void setup()
{
  // Baudrate wie bei dem C# Programm
  Serial.begin(115200);
 
  // Pin 3 für die LED
  pinMode(pinPwmOut, OUTPUT);
}

void loop()
{
  // Wenn neue Daten verfügbar sind.
  if(Serial.available() > 0)
  {
    // Liest den empfangen Byte Wert ein
    byte value = Serial.read();
   
    // Empfangener Byte Wert für das PWM Signal verwenden.
    analogWrite(pinPwmOut, value);
  }
}

Nach Eingabe eines Wertes von 0 bis 255 sollte die LED weniger oder heller leuchten. Durchschnittlich haben die LEDs eine Stromaufnahme von 20mA. Der Unterschied liegt in der Farbe, die unterschiedliche Spannungen für den Betrieb benötigen.

Farbe Spannung Berechneter Vorwiderstand Widerstand aus der E6 Reihe
Rot 1,6V 170 220 Ohm
Grün 2,1 145 150 Ohm
Blau 2,9 105 100 Ohm

Wenn die technischen Daten der verwendeten LED bekannt sind, dann kann der Widerstand mit der Formel R = U / I berechnet werden.

image

Das Schaltbild weist keine Besonderheiten auf, stelle dies jedoch zur Vollständigkeit mit in den Post ein.

image

Wie zu sehen ist, lässt sich dieses Beispiel schnell umsetzten.

 

Quellcode zum Downloaden

Dienstag, 14. Oktober 2014

Intervallaufnahme mit der Kamera ohne Interne Funktion

IntervallAufnahme01

Die Funktion für eine Intervallaufnahme ist simpel, daher ist es für mich unverständlich, warum nicht zumindest die Systemkameras von der Nikon 1 Serie in ihren Modellen diese Option anbieten. Nun gut, dies war kein Kaufkriterium, wäre aber schön gewesen. Ich selbst verwende die Nikon 1 J3 (die J1 hat die Intervallaufnahme), allerdings sollte mein Beispiel auch für andere Kameras funktionieren. Grundsätzlich geht es darum einen Servo auf den Auslöser zu drücken. Für diesen Zweck habe ich aus Aluminium Eckschienen eine Vorrichtung gebaut.

image

Wie schon am Bild zu erkennen ist, sollten zum Schutz die Alu Eckschienen nach der Verarbeitung abgerundet und ggf. mit Filzaufklebern beklebt werden.

Die Materialliste:

  • Alu Eckschienen ca. 20cm
  • Filzaufkleber
  • ein paar 3mm Schrauben und entsprechende Muttern
  • Mini Servo mit ca. 10 Ncm
  • Eine passende Schraube zur Kamera dass mit dem Stativ auch verschraubt werden kann. (siehe folgendes Bild)
image

Zum Ansteuern wird der Netduino mit einem passenden Shield zur Ansteuerung für einen Servo verwendet. Die geringe Belastung kann das Board verkraften. Bei Normalen und größeren Servos wird eine Externe Stromversorgung notwendig.

image

Der Aufwand des Programmcodes gestaltet sich übersichtlich. Zusehen ist, dass noch ein Analoger Wert eingelesen wird, worauf ich im nächsten Absatz zu sprechen komme.

public class Program
{
    // Für die Einstellung des Druckpunktes.
    private static SecretLabs.NETMF.Hardware.AnalogInput _Input;

    // Ansteuerung des Servos für den Auslöser.
    private static PWM _Servo;

    // Led Status wiedergeben.
    private static OutputPort _Status;

   // Einen Zähler.
    private static int _IntervallCounter = 0;

   // Nach wie viel Sekunden soll ausgelöst werden.
   private static int _IntervallEnd = 15;//30;

    public static void Main()
    {
        _Input = new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A0);
        _Servo = new PWM(Pins.GPIO_PIN_D5);
        _Status = new OutputPort(Pins.ONBOARD_LED, false);
           
        // 20ms für den Analog Servo.
        uint periode = 20000;

        // Mittelstellung bei 1,5ms
        _Servo.SetPulse(periode, 1500);

       while (true)
        {
           if (_IntervallCounter >= _IntervallEnd)
            {
                for (int i = 0; i < 3; i++)
                {
                    _Status.Write(true);
                    Thread.Sleep(100);
                    _Status.Write(false);
                    Thread.Sleep(100);
                }

                // Hinweis: bei Netduino 1 wird ein Wert gelesen von 0 bis 1023.
                //          Der Netduino 2 hingegen liest bis 4095.
                //uint duration = 1000 + (uint)_Input.Read();         // Ein kommentieren um den Servo
                //Debug.Print("Duration: " + duration.ToString());  // einzustellen am Pin A1.

                _Servo.SetPulse(periode, 1710); // 1710 ist eine Einstellung, an meiner Kamera
                Thread.Sleep(400);

               // Zähler Zurücksetzten.
                _IntervallCounter = 0;
            }
            else
            {
                // Aktivität zeigen
                _Status.Write(true);
                Thread.Sleep(100);
                _Status.Write(false);
               Thread.Sleep(900);

                _IntervallCounter++;
            }

           // Zurückstellen.
            _Servo.SetPulse(periode, 1500);
        }
    }
}

Das gleiche nochmal für den Arduino.

#include <Servo.h>
// Servo Kontrolle anlegen
Servo controlServo;
// Einstellung wie weit sich der Servo drehen darf
int pinAnalogIn = A0;
// Servo ansteuern
int pinServo = 5;
// LED Status
int pinLed = 13;
// Intervall Zähler
int intervall = 0;
// IntervallLänge in Sekunden
int intervallLength = 15; // 30;

void setup(){

  // Dient zu Einstellgunszwecke
  Serial.begin(9600);
  // Pins zuweisen
  pinMode(pinAnalogIn, INPUT);
  controlServo.attach(pinServo);
  pinMode(pinLed, OUTPUT);
}

void loop()
{
  if(intervall >= intervallLength)
  {
    for(int i = 0; i < 3; i++)
    {
      digitalWrite(pinLed, HIGH);
      delay(100);
      digitalWrite(pinLed, LOW);
      delay(100);
    }
   
   // Einkommentieren um die Reichweite des Servos einzustellen,
    // mit einem Potitometer am Pin A1.

    int result = 500; //analogRead(pinAnalogIn);
   
    controlServo.write(map(result, 0, 1023, 0, 179));
    delay(400);
   
    // Zähler zurück setzen
    intervall = 0;
  }
  else
  {
   digitalWrite(pinLed, HIGH);
   delay(100);
    digitalWrite(pinLed, LOW);
    delay(900);
    intervall++;
  }
 
  // Zurück stellen.
  controlServo.write(90);
}

Jetzt fehlt noch ein fester Wert für den Druckpunkt. Der Potentiometer wird an Pin A1 angeschlossen, die Spannungsversorgung muss beim Netduino mit 3,3V angelegt werden. Das Auslesen des Stellwertes erfolgt beim Netduino über Debug.Print() und wird über die Ausgabe angezeigt. Beim Arduino wird der Stellwert über dem Serial Monitor wiedergegeben. Je nach Belastung kann die Versorgung über USB instabil werden. Das zeigt sich dann, wenn der Servo beim Drücken des Auslösers leicht zittert. Später, mit einem 9V Akku oder Netzteil, sollten diese Schwierigkeiten nicht mehr auftauchen. Ansonsten muss der Servo einen eigenen Stromkreis erhalten, um zu verhindern, dass die Versorgung des Mikrocontrollers zu sehr schwankt und so zu einem Neustart des Programms führt.

image image
image image

Zu den Einstellungen der Kamera. Um ein schnelles Auslösen der Kamera zu ermöglichen, sollte auf den Kreativ Modus gewechselt werden. Die Blende, die Verschlusszeit und der Fokus sind am besten manuell festzulegen. Spätestens bei Nachtaufnahmen kommt man an diesen Einstellungen nicht vorbei. Achja, das Dateiformat JPG ist für die Ausgabe zu empfehlen. Mit dem NEF bzw. RAW ist das Bearbeiten im Video Schnittprogramm kaum machbar.

BeiNachtMitSternenhimmel_06

Tipp zur Nachtaufnahme: acht bis fünfzehn Sekunden für die Verschlusszeit bei maximal offener Blende reichen aus. Zu lange Belichtung führt dazu, dass die Sterne Streifen bilden, also praktisch gesehen wird die Erdrotation sichtbar. Die idealen Nächte mit Sternenhimmel sind in der Zeit um Neumond. Die besten Bedingungen sind Orte, die so dunkel sind, dass beim Hinabsehen die eigenen Füße nicht mehr zu sehen sind. Zwinkerndes Smiley

Nun noch ein paar Aufnahmen, die ich mit meiner Apparatur erstellt habe.

Zu guter Letzt auch noch der Quellcode zum Herunterladen.

Dienstag, 27. Mai 2014

TCS3200 Farbsensor einlesen (Netduino)

TCS3200_01

Das Licht leuchtet hier in verschiedenen Farben. Mit Hilfe des TCS3200 Sensor, können die verschiedenen Farben gemessen werden. Anders als bei einem lichtempfindlichen Sensor, an dem sich der Leitwert verändert, liegt ein Pulssignal an. Für die Schaltung werden insgesamt fünf Digitale Ports und zwei Pins für die Spannungsversorgung benötigt.

image

Wenn mal kein Breadboard zur verfügung steht, geht das auch so wie im folgendem Bild. Die Pins von S0 bis S3 und OUT auf die digitalen Ausgängen von Pin 2 bis Pin 6 steckt.

TCS3200_Netduino_03

Wie die Schaltung bereits verrät, ist das einlesen deutlich anders. Anstatt über OneWire , I²C oder eines Spannungspegel, kommt ein PWM (oder auch PPM) Signal. Je nach Farbe müssen die Anschlüsse von S0 bis S3 entsprechend geschaltet sein. Das bedeutet wiederum, dass die Farben nacheinander gemessen werden. Im .NET Micro Framework gibt es zum Einlesen die Klasse "InteruptPort", mit der auf das PWM Signal reagiert werden kann. Das erfordert etwas zusätzlichen Programmcode.

// Optionen für Ausgangsfrequenz
public enum
OutputFrequencyScaling
{
    PowerDown,
    TwoPercent,
    TwentyPercent,
    HundredPercent
}

// Filter Auswahl
public enum SelectColor
{
    Red,
    Blue,
    Green,
    Clear
}

public class Program
{
    // Die Klasse wird für das Einlesen des PWM Signals verwendet.
   private static InterruptPort _IntPort = new InterruptPort(
        Pins.GPIO_PIN_D6,
        true,
        Port.ResistorMode.Disabled,
        Port.InterruptMode.InterruptEdgeBoth);

    // Ruft die gemessene Zeit ab,
    // wann die HIGH Pegele begonnen hat oder legt diese fest.
    private static long _HighTicks = 0;

    // S0 und S1 Schaltet die Ausgangs frequenz entsprechend ein (Siehe dazu Datasheet)
    private static OutputPort _S0 = new OutputPort(Pins.GPIO_PIN_D2, false);
   private static OutputPort _S1 = new OutputPort(Pins.GPIO_PIN_D3, false);

   // S2 und S3 Schaltet die verschiedenen Filter Möglichkeiten ein
    private static OutputPort _S2 = new OutputPort(Pins.GPIO_PIN_D4, false);
    private static OutputPort _S3 = new OutputPort(Pins.GPIO_PIN_D5, false);

    // Die Onboard LED als Status Aktivität
    private static OutputPort _StatusLED = new OutputPort(Pins.ONBOARD_LED, false);

    private static string _readColorName = string.Empty;

    private static bool _valueIsSet = false;
    private static long _resultTemp = 0;
    private static int _resultRed = 0;
    private static int _resultBlue = 0;
    private static int _resultGreen = 0;
    private static int _resultClear = 0;

    public static void Main()
    {
        OutputFrequencyScaling scale = OutputFrequencyScaling.TwoPercent;

       while (true)
        {
          
// Status Lesen
            _StatusLED.Write(true);

            // Farben nach einander einlesen.
            ReadPwmSignal(ref _resultRed, SelectColor.Red, scale);
            ReadPwmSignal(ref _resultBlue, SelectColor.Blue, scale);
            ReadPwmSignal(ref _resultGreen, SelectColor.Green, scale);
            ReadPwmSignal(ref _resultClear, SelectColor.Clear, scale);

            // Ausgabe über die Messergebnisse.
            Debug.Print("Red:" + _resultRed.ToString() +
               "\t Blue:" + _resultBlue.ToString() +
               "\t Green:" + _resultGreen.ToString() +
               "\t Clear:" + _resultClear.ToString());

           // Status warten
            _StatusLED.Write(false);
           Thread.Sleep(500);
        }
           
    }

    // Methode mit Filter- und Ausgangsfrequenzschalten und gibt das Ergebnis über "result" zurück.
   private static void ReadPwmSignal(ref int result, SelectColor color, OutputFrequencyScaling scaling)
    {
       // Ausgangsfrequenz schalten
        switch (scaling)
        {
            case (OutputFrequencyScaling.TwoPercent): { _S0.Write(false); _S1.Write(true); break; }
            case (OutputFrequencyScaling.TwentyPercent): { _S0.Write(true); _S1.Write(false); break; }
           case (OutputFrequencyScaling.HundredPercent): { _S0.Write(true); _S1.Write(true); break; }
            default: { _S0.Write(false); _S1.Write(false); break; }
        }

        // Filter einstellen
        switch (color)
        {
            case (SelectColor.Red): { _S2.Write(false); _S3.Write(false); break; }
            case (SelectColor.Blue): { _S2.Write(false); _S3.Write(true); break; }
            case (SelectColor.Green): { _S2.Write(true); _S3.Write(true); break; }
            default: { _S2.Write(true); _S3.Write(false); break; }
        }

       // Member für das erfassen des Messergebnisses.
        _HighTicks = 0;
        _resultTemp = 0;
        _valueIsSet = false;

        // Event zuweisen
        _IntPort.OnInterrupt += _IntPort_OnInterrupt;

        // Warten
        for (int i = 0; i < 5; i++) { Thread.Sleep(2); }

        // Event wieder abziehen
        _IntPort.OnInterrupt -= _IntPort_OnInterrupt;
           
        // Ergebniss kopieren
        result = (int)_resultTemp;
    }

    // Wird ausgeführt, wenn sich der Pegel am Digitalen Port geändert hat.
    private static void _IntPort_OnInterrupt(uint data1, uint data2, DateTime time)
    {
        // Lock verhindert, das ein zweiter unmittelbarer Event nicht erfolgen kann.
        lock (_IntPort)
        {
           // Wenn noch kein Wert erfasst wurde.
            if (!_valueIsSet)
            {
               // Wenn HIGH Pegel anlieg und die Aktuelle
                // Zeit in Ticks noch nicht erfast wurde.
                if (data2 == 1 & _HighTicks == 0)
                {
                    // Aktuelle Zeit in Ticks zwischen speichern
                    _HighTicks = time.Ticks;
                }
                else if (_HighTicks != 0 & !_valueIsSet)
                {
                    // Wenn der Pegel von HIGH nach LOW gewechselt hat
                    _resultTemp = time.Ticks - _HighTicks;
                   // True zuweisen, dass der Messwert erfasst wurde
                    _valueIsSet = true;
                    // Event abziehen
                    _IntPort.OnInterrupt -= _IntPort_OnInterrupt;
                }
            }
        }
    }
}

Als Ausgangsergebnis werden vier Werte wiedergegeben. Wenn nun vor dem Sensor eine Farbige Fläche mit einer der Grundfarben gehalten wird, dann verändern sich die Werte dementsprechend. Stammt die Farbe von einem Bildschirm (wie im folgenden Bild von einem Smart Phone), dann kann der Blaue Jumper herausgezogen werden, um die LED Beleuchtung abzustellen.

TCS3200_Netduino_01

  Bei grob angemalten Flächen wie dieser Karteikarte funktioniert es weniger gut..

TCS3200_Netduino_02

Anhand der Farbe stellen sich die Werte neu ein. Je ein deutiger die Farbe ist, um so deutlicher zeigt sich das Ergebnis.

Also bei durch gehenhenden Blau, Grün oder Rot zeigt sich ein hoher Wert. Wenn die Farbfläche jedoch wie bei meinem Beispiel mit der Karteikarte durchgeführt wird, stehen an jeden Ausgang relativ hohe Werte.

image

Noch ein Hinweis. Die Pulslänge wird kürzer, wenn der Weg des reflecktierten Licht kürzer wird, oder salobt gesagt, wenn die Farbfläche zu nah am Sensor ist, dann ist das Pulssignal sehr kurz. Dies führt dann dazu, dass die letzte Methode sehr häufig ausgeführt wird. Im schlimmsten Fall kommt es zu einem Speicherüberlauf und das Programm bleibt stehen.

Beispiel Programm zum Herunterladen für Netduino mit .NET Micro Framework 4.2

Dienstag, 29. Oktober 2013

PWM / PPM Frequenz an Brushless Motoren mit dem Netduino

NetduinoServo01_bearbeitet-1

Im Modellbau ist es üblich, dass die Frequenz für PWM bei 50Hz zum Ansteuern von analogen Servos und analogen Motorenreglern verwendet wird. Wer allerdings einen digitalen Servo oder eine digitale Motorensteuerung hat, kann hier eine weit höhere Frequenz verwenden. Besonders bei Modellhelikoptern oder auch bei den Quadrocoptern wird dies gefordert. Der Grund liegt hier klar auf der Hand, dass die Periodendauer wesentlich kürzer wird und somit pro Sekunde mehrmals ein neuer Steuerwert festgelegt werden kann. Bei 50Hz liegt die Periodendauer bei 20 Millisekunden, wovon 1 bis 2 Millisekunden das eigentliche Steuersignal (Duration) abbilden und in den restlichen 18 Millisekunden nichts weiter kommt. Daher habe ich mir gedacht, wie sieht eigentlich dann das Signal aus, wenn es auf 200Hz gesetzt wird.

image
Beispiel Darstellung mit 50Hz PWM Signal mit einer Periodendauer von 20ms.
image
Beispiel Darstellung mit 200Hz PWM Signal mit einer Periodendauer von 5ms

Schnell stellt sich heraus, dass sich grundsätzlich die Periodendauer und die LOW Pegellänge verändert, wie in den Bildern zu sehen ist. Die Duration bleibt unverändert und wird auch nicht skaliert, was das Programmieren des Signals einfach gestaltet. Im nächsten Programm Beispiel wird der erste PWM Port mit 20ms und der zweite Port mit 5ms Periodendauer initialisiert.

// PWM Signal mit 20 Millisekunden Periode und 1 Millisekunde Duration
PWM pwm1 = new PWM(PWMChannels.PWM_PIN_D5, 20000, 1000,
    PWM.ScaleFactor.Microseconds, false);
// PWM Signal mit 5 Millisekunden Periode und 1 Millisekunde Duration
PWM pwm2 = new PWM(PWMChannels.PWM_PIN_D6, 5000, 1000,
   PWM.ScaleFactor.Microseconds, false);

// PWM Ausgänge starten
pwm1.Start();
pwm2.Start();

// Analogen Eingang einrichten zum verstellen der Duration für die PWM Ausgänge
AnalogInput ai = new AnalogInput(Cpu.AnalogChannel.ANALOG_0);

double addDuration = 0;

while (true)
{
   // Abfrage des Analogen Einganges
    addDuration = ai.Read();

    // Neuen Duration Wert zuweisen zwischen 1000µs bis 2000µs
    pwm1.Duration = 1000 + (uint)(addDuration * 1000);
    pwm2.Duration = 1000 + (uint)(addDuration * 1000);

}

Dieser Inhalt wird in der ‘Main()’ Methode ausgeführt.

Mit dem analogen Eingang wird die Duration neu festgelegt, was mit einem Potentiometer bestimmt werden kann.

Netduino_zwei_Servos_Steckplatine
Hier sollten möglichst schwache Servos verwenden werden, um den Netduino nicht sonderlich zu belasten andernfalls ist eine externe Versorgung notwendig.

Für diesen Test funktionierten auch die analog Mini Servos, wenn auch nicht ideal (Leider keine passenden Digital Servos). Dreht man nun an dem Potentiometer, so kann man erkennen, dass der Servo am Port mit 200Hz schneller reagiert und der andere mit 50Hz nachzieht.

PWM Steuerung mit verschiedenen Frequenzen
Highspeed Aufnahme mit zwei Servos. Der mit dem Kreuzarm, wird mit 200Hz betrieben. Der mit den einzelnen Arm, wird mit 50Hz angesteuert.

Zudem benötigt die Klasse beim Zuweisen einer neuen Duration etwas Zeit. Grund hierfür ist, dass beim Zuweisen gewartet wird (siehe dazu ggf. Interrupt). Das bedeutet, wenn im Programmcode die Duration einen neuen Wert erhält, so kann es einige Millisekunden dauern, bis es an der Stelle weiter geht. Deutlich wird dies beim Zeitstoppen. Die folgenden Ergebnisse zeigen die Dauer eines Durchlaufens vom Einlesen des Analogen Wertes und anschließend das Zuweisen der beiden PWM Ports.

image image
Netduino Plus 2 Netduino Plus 1

Eigentlich sollte hier die Iterationsdauer fast immer gleich sein, aber sie springt teilweise von 2100 Mikrosekunden bis über 4000 Mikrosekunden bei dem Netduino Plus 1. Der Netduino Plus 2 ist da schon wesentlich konstanter und ist im Schnitt eine halbe Millisekunde schneller, was allein der höheren Taktrate zu verdanken ist.

Zusammengefasst ist klar, dass eine höhere Steuerfrequenz weniger Zeit benötigt, und die zu steuernde Einheit in kürzerer Periodendauer ein neues Steuersignal erhält. Die Frequenzen weit über 50Hz sind aber gut für digital Servos und ESC Regler (Brushless Regler) geeignet. Wie hoch die maximale Steuerfrequenz sein darf ist von der Abtastung des Reglers abhängig.

Verwendete Inhalte:

  • Netduino Plus und Netduino Plus 2
  • Analog Servo; 4,8V-6V  (oder besser ein Digital Servo)
  • Potentiometer
  • Kabel

Die Beispiel Solution mit .NET Micro Framework 4.2 zum Downloaden.

Mittwoch, 1. Mai 2013

PWM Signal Einlesen mit dem Netduino

PwmSignal_Netduino2
Der Empfänger am Netduino

Es gibt zwei Lösungen, wie man ein PWM Signal einlesen kann. Über eine RC Schaltung mit der “AnalogInput” Klasse oder vollständig programmatisch. Wenn keine Bauteile wie Widerstand und Kondensator vorhanden ist, dann erübrigt sich das letztere. Beim Arduino kennt man bereits aus der Library die Methode ‘pulseIn()’. Leider wurde das für den Netduino noch nicht umgesetzt. Alternativ bleibt die Möglichkeit, die sich ändernden Pulszustände zeitlich zu messen und das geht hervorragend mit der “InterruptPort” Klasse.

/// <summary>
/// Dieses Klasse ermöglicht das genaue Einlesen des eingehenden Pulssignals
/// </summary>
private static InterruptPort _IntPort = new InterruptPort(
    Pins.GPIO_PIN_D0,
    true,
    Port.ResistorMode.Disabled,
    Port.InterruptMode.InterruptEdgeBoth);

/// <summary>
/// Wird verwendet um den Startzeit des Pulssignals zu merken
/// </summary>
private static long _HighTicks = 0;
/// <summary>
/// Kann verwendet werden um einen Servo anzusteuern
/// </summary>
private static PWM _PwmOutput = new PWM(Cpu.PWMChannel.PWM_0, 20000, 1500, PWM.ScaleFactor.Microseconds, false);

public static void Main()
{
    // PWM Ausgang starten
    _PwmOutput.Start();
    // Event zuweisen
    _IntPort.OnInterrupt += new NativeEventHandler(_IntPort_OnInterrupt);

    while (true)
    {
        Thread.Sleep(1000);
    }
}
/// <summary>
/// Wird ausgeführt, wenn sich der Zustand am Eingang geändert hat.
/// </summary>
private static void _IntPort_OnInterrupt(uint data1, uint data2, DateTime time)
{
   if (data2 == 1)
    {
        // Startzeit des Pulssignals merken
        _HighTicks = time.Ticks;
    }
    else
    {
        // Mit Ende des High Zustands wird die aktuelle
        // Zeit mit der begin Zeit abgerechnet und erhält hier
        // die Pulslänge des High Signals

        double result = time.Ticks - _HighTicks;

        // Werte werden zwischen 10.000 bis 20.000 ausgegeben
        Debug.Print(result.ToString());

       if (result < 20000)
        {
            // Das Pulssignal darf nur zwischen 1000 bis 2000 sein
            _PwmOutput.Duration = (uint)(result / 10);
        }
    }
}

Zum einlesen eines PWM Signals

Über die PWM Klasse gebe ich das eingelesene Signal wieder aus, um z.B. einen Servo oder Regler anzusteuern. Sinn ergibt dies jedoch, wenn der Wert noch verarbeitet wird, bevor es weiter gegeben wird.

Solution zum Downloaden: ExampleReadPwm

Bis kein Schatten mehr fällt

Damit mein Netzteil sein Potential abgeben kann, wird für dieses Jahr die Anforderung der Weihnachtsbeleuchtung angehoben. Letztes Jahr hatt...