PCA9685 PWM Driver Modul mit dem Netduino
Nach etwas längerer Zeit ist eine Thema mit dem Netduino wieder dran. Diesmal ist das PWM Treiber Modul dran, den ich schon etwas länger hier liegen habe und es ist eigentlich zunächst für den Raspberry Pi gedacht, aber da fehlt mir noch eine neue Platine um einen eigenen Motor Treiber zu bauen.
Benötigt wird:
- Netduino (sollte mit allen Versionen funktionieren)
- PCA9685 16 Channel PWM Driver (Meins ist nicht von Adafruit)
- Mindestens ein Servo zum Testen
- Externe Spannunsquelle mit Maximal 6V
Neues Projekt
Für das Projekt werden die Referenzen Microsoft.SPOT.Hardware und Microsoft.SPOT.Native die für die I²C und Debug Ausgaben verwendet werden. Neben der bestehenden Program.cs Klasse wird eine eigene Klasse für den PWM Treiber hinzugefügt, die dann den Inhalt hat des hier folgenden gezeigten Code. Weitere Kommentare sind im Github Repository zu sehen.
public class Pca9685 : I2CDevice
{
private readonly byte PCA9685_MODE1 = 0x00;
private readonly byte PCA9685_PRESCALE = 0xFE;
private readonly byte LED0_ON_L = 0x06;
private readonly byte LED0_ON_H = 0x07;
private readonly byte LED0_OFF_L = 0x08;
private readonly byte LED0_OFF_H = 0x09;
private readonly byte ALL_LED_ON_L = 0xFA;
private readonly byte ALL_LED_ON_H = 0xFB;
private int _period;
public Pca9685(int period) : base(new Configuration(0x40, 100))
{
this._period = period * 1000;
}
public void Reset()
{
this.Write(new byte[]{ PCA9685_MODE1, 0x00 });
Thread.Sleep(10);
}
internal void Start()
{
int hz = 1000000 / this._period;
this.Reset();
this.SetPwmFrequency(hz);
}
public void SetPwmFrequency(float frequency)
{
frequency *= 0.9f;
float prescaleval = 25000000;
prescaleval /= 4096;
prescaleval /= frequency;
prescaleval -= 1;
byte prescale = (byte)(prescaleval + 0.5);
byte[] buffer = new byte[1] { PCA9685_MODE1 };
if (this.Read(buffer) != 1)
{
throw new Exception("can not read mode1");
}
byte oldMode = buffer[0];
byte newMode = (byte)(((byte)oldMode & (byte)0x7F) | (byte)0x10);
// go to sleep
this.Write(new byte[] { PCA9685_MODE1, newMode });
this.Write(new byte[] { PCA9685_PRESCALE, prescale });
this.Write(new byte[] { PCA9685_MODE1, oldMode });
Thread.Sleep(5);
this.Write(new byte[] { PCA9685_MODE1, (byte)(oldMode | 0x80) });
byte[] bufferRead = new byte[] { PCA9685_MODE1 };
this.Read(bufferRead);
Debug.Print("Mode now: " + bufferRead[0].ToString());
}
internal void SetPwm(byte outputNumber, int on, int off)
{
Debug.Print("Output: " + outputNumber.ToString() + ", ON: " + on.ToString() + ", OFF: " + off.ToString());
byte targetOutput_ON_L = (byte)(LED0_ON_L + 4 * outputNumber);
byte targetOutput_ON_H = (byte)(LED0_ON_H + 4 * outputNumber);
byte targetOutput_OFF_L = (byte)(LED0_OFF_L + 4 * outputNumber);
byte targetOutput_OFF_H = (byte)(LED0_OFF_H + 4 * outputNumber);
this.Write(new byte[] { targetOutput_ON_L, (byte)on });
this.Write(new byte[] { targetOutput_ON_H, (byte)(on >> 8) });
this.Write(new byte[] { targetOutput_OFF_L, (byte)(off) });
this.Write(new byte[] { targetOutput_OFF_H, (byte)(off >> 8) });
}
private int Write(byte[] buffer)
{
I2CTransaction[] trans = new I2CTransaction[]
{
CreateWriteTransaction(buffer)
};
return Execute(trans, 1000);
}
private int Read(byte[] buffer)
{
I2CTransaction[] trans = new I2CTransaction[]
{
CreateReadTransaction(buffer)
};
return Execute(trans, 1000);
}
}
|
Inhalt zur Klasse
Mit der Fertigstellung der Klasse, bzw. ist diese jetzt soweit ausgeführt, dass die einzelnen PWM Ausgänge des Moduls über die I²C gesteuert werden können. Sieht man in das Datenblatt, dann ist zusehen, dass das Modul noch ein paar mehr Sachen kann. Zum einen bin ich hier nicht auf das Kaskadieren des Moduls mit mehreren nicht eingegangen. Dazu komme ich auf ein anderes mal, wenn ich mehrere Module davon besitze.
Der Programmcode selbst habe ich ursprünglich aus öffentlichen C++ Programmcode entnommen und habe deshalb auch die selben Namen für Methoden verwendet wie aus dem Adafruit Programmcode.
Vielleicht verdreht
An der Stelle für SetPwm bin ich mir noch nicht sicher ob die Ansteuerung so richtig ist. Zugegeben, ich bin noch nicht mit dem Datenblatt durch. Da ich selbst weis, wie ein PWM Signal auszusehen hat, sollte auch die Ansteuerung meiner Vorstellung entsprechen. Doch wenn ich den High Puls festlege, dann ist dieser länger als der Low Puls Länge Inherhalb der Periode. Das sollte eigentlich umgekehrt sein.
Verkabeln
Mit vier Leitungen ist das Modul vom Netduino steuerbar. Damit aber auch die Servos später versorgt sind, muss in der Mitte ebenfalls eine Spannungsquelle angeschlossen werden.
Probleme
Falls ihr die Stromversorgung in der Mitte vom Modul mit dem 5V Ausgang vom Netduino versorgt, kann es sein, dass es nicht funktioniert oder instabil reagiert. Bedeutet, kann funktionieren, muss aber nicht. Besser ist immer eine seperate Versorgung anzuschließen. Allein je nach größe des verwendeten Servos und dessen Belastung, könnte die Stromaufnahme zu groß sein (Leider konnte ich keine Information finden, wieviel Strom maximal am 5V Pin abgenommen werden kann vom Netduino).
Die Wesentlichen Technischen Infos:
PWM Signal kann in 4096 Stufen gesteuert werden (12Bit)
PWM Signal kann zwischen 24Hz bis maximal 1526Hz eingestellt werden.
Die 16 Anschlüsse für die Stromversorgung der Servos, können maximal betrieben werden in Abhängigkeit der Angeschlossenen Spannungsversorgung.
PWM Output selbst kann maximal bis 25mA verwendet werden für LEDs
Spannungsversorgung für die Steuerung über I²C darf von 2,3V bis 5,5V liegen.
16 PWM Ausgänge
Kann über einen Externen Clock betrieben werden, der maximal bis 50MHz sein darf.
Intern ist ein 25MHz Ozillator verbaut.
Kann für LEDs oder Servos verwendet werden.
Quellenangaben:
Github Quellcode in C++
Datenblatt:
Kommentare