Windows 11 und langsame VirtualBox

Im Wandel von Updates kommt mit der Zeit auch ein neues Windows. Und leider funktioniert nicht immer alles. Sehen wir davon ab, das VirtualBox weitgehend Kostenlos ist und deshalb nicht gewährleistet wird, dass alle Umstände funktionieren oder unterstützt werden.

 

Verwendet

• Windows 11 (oder Windows 10)
• VirtualBox
• Virtualisiertes System mit Windows 2000 Professional

 

Problem Beschreibung

Nach einem größeren Update oder mit dem Wechsel von Windows 10 auf Windows 11, kann das Ausführen von Virtuell Box sehr langsam werden. Man kann praktisch sehen wie Pixel für Pixel das Bild aufgebaut wird.

 

Ursache

Nun im Grunde kenne ich nicht die eigentliche Technische Ursache, warum ein eingeschaltetes Feature in Windows 11 für Virtuelle Maschinen Probleme erzeugt. Vielleicht hilft diese Beschreibung, die ich in den Weiten des Internets gefunden habe. (https://www.pctipp.ch/praxis/virtualisierung/quaelend-langsame-virtualbox-unter-windows-11-2742835.html?page=1_abhilfe-hyper-v-sandbox-nbsp---weg-damit)

 

Lösung des Problems in Windows 10

Drücke auf die Windows Taste und gebe 'Windows-Features aktivieren oder deaktivieren' ein

 

Dann deinstalliert ihr die Features durch das Entfernen der gesetzten Hakens.

• Hyper-V
• Windows-Hypervisor-Plattform
• Windows Sandbox

 

Anschließend Ok und das Betriebssystem neu starten.

 

Lösung des Problems in Windows 11

Im Grunde das gleiche. Nur halt mit runden Ecken. 

An einem anderem System konnte ich feststellen, dass nicht zwingen alle Punkte aufgeführt sein müssen. Denn je nach Hardware Unterstützung werden auch nur die Optionen wieder gegeben, die auch wirklich unterstützt werden.

Karosseriebeleuchtung mit PCA9685 (Zusatz)

Eine Sache ist noch offen: Bei meinem vorigen Blogpost konnte man in den Videos sehen, dass die LEDs beim Fade-OUT nie ganz aus waren.

Benötigt werden:

• Arduino
• PWM Modul PCA9685
• LEDs und Widerstände

Ziel

Die LEDs sollen im Fade-OUT komplett ausgehen. Asynchrone Animationsabläufe.

Ursache

Es lag daran, dass der Wert nie den Endwert von 4095 erreicht hat. Auch, wenn das High Level nur sehr kurz anliegt, reicht die Spannungsversorgung aus, um einen LED noch glimmen zu lassen.

Daher liegt die Lösung nahe, dass am Ende eines Schleifendurchgang nochmal ein Signal-Zustand festgelegt wird, mit dem genannten Endwert. Jedoch soll das für die asynchronen Vorgänge auch funktionieren. Hier nochmal das Beispiel, in denen die LEDs nicht ganz aus sind.

 #include <Wire.h>  
 #include <Adafruit_PWMServoDriver.h>  
 Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();  
 void setup() {  
  pwm.begin();  
  pwm.setPWMFreq(1600);  
  Wire.setClock(400000);  
 }  
 void loop() {  
  int stepAdd = 10;  
  int leds = 4;  

  for (uint16_t i=0; i<4096; i += stepAdd) {  
   for (uint8_t pwmnum=0; pwmnum < leds; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, 4096 - i);  
   }  
  }  
  delay(1000);  
  for (uint16_t i=0; i<4096; i += stepAdd) {  
   for (uint8_t pwmnum=0; pwmnum < leds; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, i);  
   }  
  }  
  delay(2000);  
 }  

Einfache Lösung

Mit der bekannten Schrittweite kann nach dem Schleifendurchlauf bedingt die PWM Ports auf den Max Wert eingestellt werden.

 #include <Wire.h>  
 #include <Adafruit_PWMServoDriver.h>  
 Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();  
 void setup() {  
  pwm.begin();  
  pwm.setPWMFreq(1600);  
  Wire.setClock(400000);  
 }  
 void loop() {  
  int stepAdd = 10;  
  int leds = 4;  

  for (uint16_t i=0; i<4096; i += stepAdd) {  
   for (uint8_t pwmnum=0; pwmnum < leds; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, 4096 - i);  
   }  
  }  
  delay(1000);  
  uint16_t iSetValue = 0;  
  for (uint16_t i=0; i < 4096; i += stepAdd) {  
   for (uint8_t pwmnum=0; pwmnum < leds; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, i);  
   }  
   iSetValue = i;  
  }  
  if(iSetValue > 4095 - stepAdd) {  
   for (uint8_t pwmnum=0; pwmnum < leds; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, 4095);  
   }  
  }  
  delay(2000);  
 }  

Lösung für asynchrone Vorgänge

Das gleiche kann auch für den asynchronen Vorgang verwendet werden. Jedoch hat die bisherige Lösung einen Nachteil: Dass sie schnell unübersichtlich wird. 

Die Beispiele habe ich oft nur mit zwei LEDs abgebildet, aber für 16 LEDs wird's schlecht leserlich.

Deshalb gehe ich hier mit der Beispiellösung einen Schritt weiter und lege ein Objekt an, in dem ich für die einzelne LED den Zustand hinterlegen kann.

 #include <Wire.h>  
 #include <Adafruit_PWMServoDriver.h>  
 Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();  
 unsigned long mCurrentMillis = 0;  
 void setup() {  
  pwm.begin();  
  pwm.setPWMFreq(1600);  
  Wire.setClock(400000);  
  // schaltet alle aus  
  for (uint8_t pwmnum=0; pwmnum < 16; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, 4095);  
  }  
 }  
 // status objekt für eine LED  
 typedef struct {  
   unsigned long LastMillis;      // letzte Zeitstand  
   unsigned long DistanceFromNowToLast;// Intervall länge  
   uint16_t Value;           // aktuell verwendeter Wert  
   bool IsFlashing;          // soll nur an und aus  
   bool IsGoingOn;           // Schritt soll heller   
                     // oder an sein  
 } ledStateType;  
 // Konfiguration einzelner LEDs  
 ledStateType mLEDs[] = {  
  { 0, 5, 0, false, true },       // fade animation  
  { 0, 1000, 0, true, true }      // flashing  
 };  
 void PrepareLED(int ledIndex) {  
  int stepAdd = 10;  
  unsigned long rest = mCurrentMillis - mLEDs[ledIndex].LastMillis;  
  if(rest < mLEDs[ledIndex].DistanceFromNowToLast) {  
   return;  
  }  
  if(mLEDs[ledIndex].IsFlashing) {  
   if(mLEDs[ledIndex].IsGoingOn) {  
    mLEDs[ledIndex].Value = 4095;  
    mLEDs[ledIndex].IsGoingOn = false;  
   }  
   else {  
    mLEDs[ledIndex].Value = 0;  
    mLEDs[ledIndex].IsGoingOn = true;  
   }  
  }  
  else {  
   if(mLEDs[ledIndex].IsGoingOn) {  
    if(mLEDs[ledIndex].Value > stepAdd) {  
     mLEDs[ledIndex].Value -= stepAdd;  
    }  
    else {  
     mLEDs[ledIndex].Value = 0;  
     mLEDs[ledIndex].IsGoingOn = false;  
    }  
   }  
   else {  
    if(mLEDs[ledIndex].Value < 4096) {  
     mLEDs[ledIndex].Value += stepAdd;  
    }  
    if(mLEDs[ledIndex].Value > 4095 - stepAdd) {  
     mLEDs[ledIndex].Value = 4095;  
     mLEDs[ledIndex].IsGoingOn = true;  
    }  
   }  
  }  
  mLEDs[ledIndex].LastMillis = mCurrentMillis;  
 }  
 void loop() {  
  mCurrentMillis = millis();  
  for(int i = 0; i < 2; i++) {  
   PrepareLED(i);  
   pwm.setPWM(i, 0, mLEDs[i].Value);  
  }  
 }  

Natürlich ist das nur eine Möglichkeit, wie der Programmablauf aussehen könnte. Der geübte C++ Programmierer würde das sicherlich anders lösen können.

Vorheriger Blog Post:

Karosseriebeleuchtung mit PCA9685

Karosseriebeleuchtung mit PCA9685

Ein Teil des Ausbaus meines FPV Crawler bestand darin, die LEDs zu montieren und entsprechend mit Energie zu versorgen. Natürlich reichte nicht ein einfaches Anschließen an die Versorgungsspannung aus. Denn die LEDs sollten je nach ihrer Aufgabe eingeschaltet werden, was zunächst einfach klingt.
Vom Gedanken bis zur Umsetzung zeigte sich ein deutliche höherer Aufwand beim Verkabeln mehrere Leitungen und beim Programmieren des PWM Moduls, als gedacht.

Benötigt

• Arduino
• PWM Modul PCA9685
• LEDs und Widerstände

 

Ziel

Standlicht, Fahrlicht, Blinker und Flutlichter sollten alle individull an-steuerbar sein. Hier sollen die Lichter immer durch ein Fade-Effekt abgebildet werden.

 

Initialisieren

Für die folgenden Beispiele verwendete ich immer die gleiche Initialisierung.

 #include <Wire.h>  
 #include <Adafruit_PWMServoDriver.h>  
 Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();  
 void setup() {  
  pwm.begin();  
  pwm.setPWMFreq(1600);  
  Wire.setClock(400000);  
  // schaltet alle aus  
  for (uint8_t pwmnum=0; pwmnum < 16; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, 4095);  
  }  
 }  

Fade-In und Fade-Out

Leider kann man nicht einfach einen Wert von 0 bis 256 in den Controller eingeben, um Animationsverläufe darin abzubilden. Wenn man versucht auf diese Weise die LEDs anzusteuern, dann funktioniert das schlecht oder gar nicht. Zum Glück ist bereits ein Beispiel Code in den Sourcen für das PCA9685 Modul integriert, dass genau diese Funktion darstellt.

Mit dem Adafruit Beispiel  'pwmtest' wird gezeigt, wie das Zuweisen um-gesetzt wird. Dort sieht man, dass nicht immer plus eins, sondern immer plus acht addiert wird. Das ist sicherlich auf die 12Bit pro Port zurück zu führen.

 
void loop() {  
  int stepAdd = 10;  
  int leds = 4;  
  for (uint16_t i=0; i<4096; i += stepAdd) {  
   for (uint8_t pwmnum=0; pwmnum < leds; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, 4096 - i);  
   }  
  }  
  delay(1000);  
  for (uint16_t i=0; i<4096; i += stepAdd) {  
   for (uint8_t pwmnum=0; pwmnum < leds; pwmnum++) {  
    pwm.setPWM(pwmnum, 0, i);  
   }  
  }  
  delay(1000);  
 }

Asynchroner Ablauf

Für mein Ziel wird mehr als eine LED und neben dem Modul noch WS2812b RGB LEDs eingesetzt. Damit ich nicht für jede LED einen eigenen Controller benötige, muss ich sicherstellen, wie schnell etwas aus- oder eingeblendet werden soll.

 unsigned long mCurrentMillis;  
 unsigned long mLastMillis_LED_1;   
 unsigned long mLastMillis_LED_2;  
 uint16_t mValueLED_1 = 0;  
 uint16_t mValueLED_2 = 0;  
 void loop() {  
  uint16_t endValue = 4096;  
  int stepAdd = 10;  
  int leds = 4;  
  mCurrentMillis = millis();  
  if(mCurrentMillis - mLastMillis_LED_1 > 5) {  
   if(mValueLED_1 < endValue) {   
    mValueLED_1 += stepAdd;  
    pwm.setPWM(0, 0, mValueLED_1);  
   }  
   else {   
    mValueLED_1 = 0;  
   }  
   mLastMillis_LED_1 = mCurrentMillis;  
  }  
  if(mCurrentMillis - mLastMillis_LED_2 > 10) {  
   if(mValueLED_2 < endValue) {   
    mValueLED_2 += stepAdd;  
    pwm.setPWM(1, 0, mValueLED_2);  
   }  
   else {   
    mValueLED_2 = 0;   
   }   
   mLastMillis_LED_2 = mCurrentMillis;  
  }  
 }   

Blinker

Einfaches Ein- und Ausschalten ist nicht schwer zu programmieren. Mit einem schnelle Fade-In, Fade-Out war nur etwas ausprobieren nötig. Zuerst hatte ich das Problem. dass die LEDs nie ganz ausgingen, womit das Blinken selbst weniger deutlich zu sehen waren, wenn der Blinker betätigt wurde.
Im Grunde war das ein Denkfehler, weil ich die Schrittweite zum Fade-Out nicht berücksichtigt habe und, um eine Iteration zu früh den Vorgang verlassen habe.

 unsigned long mCurrentMillis;  
 unsigned long mLastMillis_LED_1;   
 unsigned long mLastMillis_LED_2;  
 uint16_t mValueLED_1 = 0;  
 bool mFlashingLED_2 = false;  
 void loop() {  
  uint16_t endValue = 4096;  
  int stepAdd = 10;  
  int leds = 4;  
  mCurrentMillis = millis();  
  if(mCurrentMillis - mLastMillis_LED_1 > 5) {  
   if(mValueLED_1 < endValue) {   
    mValueLED_1 += stepAdd;  
    pwm.setPWM(0, 0, mValueLED_1);  
   }  
   else {   
    mValueLED_1 = 0;  
   }  
   mLastMillis_LED_1 = mCurrentMillis;  
  }  
  if(mCurrentMillis - mLastMillis_LED_2 > 200) {  
   mFlashingLED_2 = !mFlashingLED_2;  
   if(mFlashingLED_2) {   
    pwm.setPWM(1, 0, 4095);  
   }  
   else {   
    pwm.setPWM(1, 0, 0);  
   }   
   mLastMillis_LED_2 = mCurrentMillis;  
  }  
 } 

 

Viel aus-probieren

Erst am Ende, wenn alles im Programmcode eingegeben ist, muss die Geschwindigkeit der Animationen eingestellt werden. Damit dies geht, sollte möglichst am Anfang diese Einstellungen zentral eingehalten werden, um das Nachjustieren zu beschleunigen.

Crawler - LUA Skript für Lipo Sensor

Wie voll ein Lipo Akku ist, kann an der Spannung der einzelnen Zelle oder an der Gesamtspannung erkannt werden. Der Umstand ist immer, dass wir in unserem Kopf umrechnen, wie viel uns noch vom Akku an Kapazität bleibt.

Bei unseren Geräten wie dem Smartphone oder Tablet gibt es eine Prozentanzeige und dieses will ich hier nun umsetzen.

 

Benötigt

• Frsky X-Lite oder Fernsteuerung mit OpenTX
• Frsky Lipo Sensor

 

Ziel

Der Akkustand soll in Prozent ausgegeben und graphisch mit einem Ladebalken angezeigt werden. Wenn die verbrauchbare Akkuladung sich dem Ende nährt, soll außerdem eine Warnung ausgegeben werden.

 

Auslesen der Telemetrie

Anders als bei dem Arduino Projekt wird das Ergebnis nicht als einzelner Wert ausgegeben. Genau genommen ist der verwendete Typ eine Tabelle, das wie ein Dictionary verwendet wird. Mit einem Schleifendurchgang kann der Index und der Wert gelesen werden.

 local mCellId = nil  
 local mField = nil  
 -- read from telemetry pool by name  
 local function getTelemetryId(name)  
   mField = getFieldInfo(name)  
   if mField then  
    return mField.id  
   else  
    return -1  
   end  
 end  
 local function init()  
      mCellId = getTelemetryId("Cels")  
 end  

 

Spannungen umrechnen

Im Grunde ist es keine große Sache, die Spannung in Prozent umzurechnen. Wir wissen, dass eine Lipo-Zelle eine Lagerspannung von 3,7 Volt hat und bei ca. 4.2 Volt voll ist. Praktisch darf der Akku nur 0,5V an Spannung verlieren, um dann als verbraucht zu gelten. Einige haben 3,6V als Grenze, aber weiter runter sollte man hier nicht gehen, wenn der Akku keinen Schaden nehmen soll.

 

Gesamtspannung = 8,4 V

Lagerspannung = 7,4 V

Verbrauchbare Differenzspannung = Gesamtspannung - Lagerspannung

1,0 V = 8,4 V - 7,4 V

 

Messspannung = 8,1 V

Rest Differenzspannung = Messspannung - Lagerspannung

0,7 = 8,1 V - 7,4 V

 

Kapazitätswert in Prozent = Rest Differenzspannung / Verbrauchbare Differenzspannung * 100

70 % = 0,7 / 1,0 * 100

 

Genauer wird dies, wenn die Spannungen der einzelnen Zellen berechnet werden. Zudem bleibt die Möglichkeit die Zellen einzeln zu betrachten, um bei Bedarf den nicht-balancierten Zustand zu erkennen.

 -- Lipo total  
 local mLipoTotalFull = 8.4  
 local mLipoTolalLow = 7.4  
 -- lipo cell  
 local mLipoCellVoltage = 4.2  
 local mLipoCellVoltageLow = 3.7  
 -- results  
 local mTotalResult = 0  
 local mCellResult1 = 0  
 local mCellResult2 = 0  
 local mTotalCellsResult = 0  
 local mCells = 0  
 local mCell1 = 0  
 local mCell2 = 0  
 local function calculateCellsState()  
      if mCellId == -1 then  
           return 0  
      end       
      mCells = 0  
      local cells = getValue(mCellId)  
      if(type(cells) == "table") then  
           for index, voltage in ipairs(cells) do  
                mCells = mCells + voltage  
                if index == 1 then  
                     mCell1 = voltage  
                end  
                if index == 2 then  
                     mCell2 = voltage  
                end  
           end  
      end  
      -- total voltage   
      local totalFull = mLipoTotalFull - mLipoTolalLow  
      local totalState = mCells - mLipoTolalLow  
      mTotalResult = math.ceil(totalState / totalFull * 100)  
      -- cell  
      local cellFull = mLipoCellVoltage - mLipoCellVoltageLow  
      -- cell 1 voltage  
      local cellState1 = mCell1 - mLipoCellVoltageLow  
      mCellResult1 = cellState1 / cellFull * 100  
      -- cell 2 voltage  
      local cellState2 = mCell2 - mLipoCellVoltageLow  
      mCellResult2 = cellState2 / cellFull * 100  
      -- total result  
      mTotalCellsResult = math.ceil((mCellResult1 + mCellResult2) / 2.0)  
      return 1  
 end  

 

Werte und Balken als Zustandsanzeige

Anstatt nur Zahlen zu lesen, kann ein Balken gezeichnet werden. Damit man sehen kann, wo die 100 % liegen, wird zusätzlich ein Rahmen angelegt.
Anders gesagt wird es wie ein Ladebalken angezeigt, der als haptische Füllstandsanzeige verwendet werden soll.

 local function drawTextAndBars()  
      -- lipo accu state calculate to percentage  
      -- title  
      lcd.drawText(0, 0, "Accu State", MIDSIZE)  
      -- total lipo voltage  
      lcd.drawText(2, 12, "Lipo Accu:", SMLSIZE)  
      lcd.drawText(46, 12, mTotalResult.."%", SMLSIZE)  
      -- sum of cells lipo voltage  
      lcd.drawText(64, 12, "By Cells", SMLSIZE)  
      lcd.drawText(102, 12, mTotalCellsResult.."%", SMLSIZE)  
      -- Cell voltage  
      lcd.drawText(2, 20, string.format("%.2f", mCells).."V", SMLSIZE)  
      lcd.drawText(32, 20, string.format("%.2f", mCell1).."V", SMLSIZE)  
      lcd.drawText(62, 20, string.format("%.2f", mCell2).."V", SMLSIZE)  
      -- screensize  
      -- 128 x 64  
      -- cells  
      lcd.drawRectangle(5, 28, 118, 5)  
      lcd.drawLine(7, 30, math.ceil(mTotalResult * 1.18), 30, SOLID, FORCE)  
      -- cell 1  
      lcd.drawRectangle(5, 34, 118, 5, SOLID)  
      lcd.drawLine(7, 36, math.ceil(mCellResult1 * 1.18), 36, SOLID, FORCE)  
      -- cell 2  
      lcd.drawRectangle(5, 41, 118, 5, SOLID)  
      lcd.drawLine(7, 43, math.ceil(mCellResult2 * 1.18), 43, SOLID, FORCE)  
      return 0  
 end

 

Alternativ kann die Füllstandsanzeige mit lcd.drawGauge(x1, y1, w, h, maxfill) gezeichnet werden. Jedoch habe ich noch nicht die Option gefunden, eine vertikale Darstellung zu zeichnen. Ist deshalb in dem von mir hier erstellten Skript noch nicht der Fall.

 

Skript ausführen

Das Skript muss in den Ordner SCRIPTS/TELEMETRY und die Bezeichnung des Scripts darf hier nicht mehr als 5 Zeichen lang sein, da sonst das Skript nicht für das Display ausgewählt werden kann.

Nun habe ich da noch ein Problem mit der Darstellung auf dem Bildschirm. Obwohl das Skript im Menü eingebunden wurde, wird mir auf der Telemetrie Ansicht gemeldet, dass keine Telemetrie Screens verfügbar sei.

 

Am Ende offen

Den Fehler konnte ich noch nicht herausfinden und starte daher alternativ das Skript direkt aus dem Ordner heraus. Eine weitere Störung tritt auf, wenn man den Crawler ausschaltet, dann scheint die Fernsteuerung im Zustand des Betriebs zu springen und hier kann man nur noch ausschalten.

Aktuell ist die Darstellung nur sehr einfach und nicht sehr stylisch, weshalb ich ein Screen zusätzlich designe.

 

Handling Lipo Sensor Data - OpenTX 2.3 Lua Reference Guide (open-tx.org)

OpenTX 2.2 Lua Reference Guide (schorse-video.de)

Taranis-XLite-Q7-Lua-Dashboard/farl.lua at master · AndrewFarley/Taranis-XLite-Q7-Lua-Dashboard (github.com)

 

Arduino als Messgerät mit Logging (Teil 2)

Im ersten Teil habe ich erläutert, welche Schritte nötig sind, um den Arduino als Messgerät einzusetzen. Nun gehe ich einen Schritt weiter. Statt einem, können jetzt vier Messungen erfasst und auf der WPF Anwendung angezeigt werden.

Die Anwendung ist eigentlich zum Probieren von verschiedenen Mechanismen gedacht. Praktisch ein Training, um für meinen Beruf immer fit zu bleiben.

 

Benötigte Materialien:

• Arduino
• mindestens 2 x 10k Ohm Widerstände für Spannungsteiler
• Verschiedene Spannungsquellen für Messungen

 

Was geht?

Der Arduino kann mehr als nur eine Spannungsquelle messen. Mit der WPF Anwendung können vier Spannungsquellen gleichzeitig gemessen werden. Natürlich geht mehr, doch die weiteren sollen für die Schnittstelle I²C offen bleiben.

  

WPF Anwendung

Bei meinem letzten Blog Eintrag habe ich am Ende bereits geschrieben, dass ich auch schon die zukünftige WPF Anwendung im GitHub Repository mit hochgeladen habe. Zu dieser Zeit war jedoch die Messung nur an einem Messpunkt möglich.

Mit der Möglichkeit mehrere Spannungen zu messen, ändert sich der Programmcode für den Arduino. Ich habe das soweit ausgebaut, dass nun vier Messungen gleichzeitig möglich sind.

 

Arduino Code Änderung

Damit die vier Messungen auch übertragen werden, muss die Übertragung erweitert werden. Wie beim ersten, müssen die drei weiteren INPUT Eingangswerte ebenfalls aufbereitet und dann in das zu versendete Array geschrieben werden.

 #define PIN_Input_1 A0  
 #define PIN_Input_2 A1  
 #define PIN_Input_3 A2  
 #define PIN_Input_4 A3  
 void setup() {  
  Serial.begin(115200);  
  Serial.println("Volatage Measuerment Logger Started");  
  pinMode(PIN_Input_1, INPUT);  
  pinMode(PIN_Input_2, INPUT);  
  pinMode(PIN_Input_3, INPUT);  
  pinMode(PIN_Input_4, INPUT);  
 }  
 void loop() {  
  int16_t rawMeasurement1 = analogRead(PIN_Input_1);  
  int16_t rawMeasurement2 = analogRead(PIN_Input_2);  
  int16_t rawMeasurement3 = analogRead(PIN_Input_3);  
  int16_t rawMeasurement4 = analogRead(PIN_Input_4);  
  byte ba[9];  
  ba[0] = (byte)((rawMeasurement1 >> 8) & 0xff);  
  ba[1] = (byte)(rawMeasurement1 & 0xff);  
  ba[2] = (byte)((rawMeasurement2 >> 8) & 0xff);  
  ba[3] = (byte)(rawMeasurement2 & 0xff);  
  ba[4] = (byte)((rawMeasurement3 >> 8) & 0xff);  
  ba[5] = (byte)(rawMeasurement3 & 0xff); 
  ba[6] = (byte)((rawMeasurement4 >> 8) & 0xff);  
  ba[7] = (byte)(rawMeasurement4 & 0xff);   
  int8_t countedBits = CountBits(rawMeasurement1);  
  countedBits += CountBits(rawMeasurement2);  
  countedBits += CountBits(rawMeasurement3);  
  countedBits += CountBits(rawMeasurement4);  
  ba[8] = (byte)countedBits;  
  Serial.write(ba, 9);  
  delay(20);  
 }  
 int8_t CountBits(int16_t rawMeasurement) {  
  int8_t result = 0;  
  for(int i = 0; i < 16; i++) {  
   result += (int8_t)bitRead(rawMeasurement, i);  
  }  
  return result;  
 }  

Versuchsaufbau

Für den Test werden verschiedene Spannungsquellen eingesetzt:
Eine Schaltung mit einem Lichtsensor,
eine Solarplatte,
Batterie mit Step-Down und
eine weitere Schaltung mit einer Z-Diode. 

Diese vier werden wiederum selbst am Spannungsteiler angeschlossen.

 

Verbindung herstellen

Die Spannungsquellen können vor dem Einschalten/Anschließen des Arduinos angeschlossen werden. Ist der Arduino verbunden, kann die Verbindung zur Anwendung gestartet werden. Hier entsprechend den COM Port auswählen und den Button Connect klicken. Im Diagrammbar sollten nun vier Linien entsprechend der Spannung angezeigt werden.

Problem mit der Diagrammlinie

Aktuell besteht mit dem Diagramm das Problem, dass durch nicht genutzte Events die Diagrammlinie nicht aktualisiert wird, wenn sich z.B. der Mauszeiger über dem Steuerelement bewegt.

Loggen starten

Nicht immer schafft man es auf die Anzeige zu schauen und eventuell verpasst man die zu beobachtende Spannung. Deshalb habe ich den Logger mit eingebaut, um hier entgegen zu wirken.

Im Test konnten zehn minütige Aufzeichnungen vorgenommen werden, trotz des CSV Datenformates. Auch, wenn die Datei nur wenige Kilobyte groß ist, ist die Art der Speicherung in performant.

Um die Aufzeichnung anzusehen, muss auf den Tab „Log Data“ gewechselt werden. Dort wird dann der Log-Name ausgewählt, der zuvor zum Speichern verwendet wurde. Die Einträge sind hier nicht nur durchscrollbar, sondern man kann auch auf die nächst Spannungsveränderung springen/wechseln.

 

Unfertig!

Sofern ich wieder Zeit habe, entwickle ich das Programm weiter.
Das richtet sich auch etwas nach meinem eigenen Bedarf.

 
Ihr könnt mir auch in die Kommentare schreiben, welche Funktion man einbringen könnte.

Als nächstes kommt eine Erweiterung der Divisor Einstellung, welche aktuell noch für alle vier verwendet wird.
Die Anzeige im Diagramm mit über 10V ist noch ausbaufähig, da eine höhere Spannung angezeigt werden könnte. 

Neben dem Programm wäre eine vollständige Schutzschaltung schön. Das Thema bin ich bereits angegangen und ich musste feststellen, dass der Bereich größere Kreise zieht als ich gedacht habe.

Nun könnte ich alle meine Vorhaben hier unter hinschreiben, aber dann wäre das nur für heute aktuell. Deshalb packe ich meine offenen Punkte in den Issues.

Offene Aufgaben Liste - Issues

GitHub - VoltageMeasurementLogger

In der Solution befindet sich das Projekt SimpleVoltageMeasurement, das die Grundlage der Spannungsmessung am Arduino und C# Konsolenanwendung abbildet. Das Projekt VoltageMesurementLogger ist die Anwendung, die im Blogeintrag beschrieben wurde.

 

Arduino als einfaches Messgerät

Eigentlich hatte ich einen anderen Text bereits fertig, aber der passte nicht mehr zu dem folgenden Inhalt.
Diesmal geht’s darum einen Arduino als Messgerät einzusetzen und den PC als Anzeigegerät. Natürlich mit dem Ziel eine größere Anwendung zu schreiben, mit welcher man die Messungen aufzeichnen kann.

 

Benötigt

• Arduino
• Breadboard
• 2x 10kOhm Widerstände
• 3x Jumper Kabel
• Eine Anwendung, mit der man die Messungen loggen kann

 

Anforderung

Mit einem Arduino soll eine Spannung an einem Step-Down Modul gemessen werden, welches ich in meinem Crawler verwende. Da die Spannung auch höher als 5V sein kann, muss ein Spannungsteiler eingesetzt werden, der die zu erwartenden Spannung abdeckt. Um aktiv das Spannungsgeschehen zu beobachten, soll das Messergebnis auf dem PC wieder gegeben werden.

 

Arduino als Messgerät

Für ein einfaches Messgerät werden grundsätzlich zwei Widerstände benötigt. Zwar kann man auch direkt messen, aber das schränkt den Messbereich stark ein. In meinem Fall könnte die Spannung bei 7,4V hoch gehen und vielleicht auch drüber. Zudem soll mit den Widerständen auch der Strom begrenzt werden, dass zudem den Arduino vom Durchbrennen schützen soll.

 

Bevor eine Messung stattfindet, wird ein kleines Arduino Programm benötigt, mit dem wir auf dem Serial Monitor einen Wert ausgeben können.

 

 #define PIN_Input A0  
 void setup() {  
  Serial.begin(115200);  
  pinMode(PIN_Input, INPUT);  
 }  
 void loop() {  
  int16_t rawMeasurement = analogRead(PIN_Input);  
  byte ba[3];  
  ba[0] = (byte)((rawMeasurement >> 8) & 0xff);  
  ba[1] = (byte)(rawMeasurement & 0xff);  
  ba[2] = (byte)CountBits(rawMeasurement);  
  Serial.write(ba, 3);  
  delay(20);  
 }  
 int8_t CountBits(int16_t rawMeasurement) {  
  int8_t result = 0;  
  for(int i = 0; i < 16; i++) {  
   result += (int8_t)bitRead(rawMeasurement, i);  
  }  
  return result;  
 } 

 

Simple Consolen Anwendung

Der simple Aufbau ist zunächst ein Vorläufer zu meiner eigentlichen kleinen Anwendung. Die Auswahl des seriellen Port hätte man auch weg lassen können, aber auf den Komfort wollte ich dann doch nicht verzichten.

 

class Program  
 {  
   private static int _rawValue;  
   private static int _divisorValue = 511;  
   private static float _voltage;  
   static void Main(string[] args)  
   {  
     Console.WriteLine("Connect Serial with");  
     string[] ports = SerialPort.GetPortNames();  
     if(!ports.Any()) {  
       Console.WriteLine("No Arduino connected!");  
       return;  
     }  
     for (int index = 0; index < ports.Length; index++) {  
       Console.WriteLine($"Index:{index}, Port: {ports[index]}");  
     }  
     string selectindex = Console.ReadLine();  
     if (!int.TryParse(selectindex, out int indexResult)) {  
       Console.WriteLine("You can only typ the index number!");  
       return;  
     }  
     if(indexResult >= ports.Length) {  
       Console.WriteLine("You can only typ the index number!");  
       return;  
     }  
     var sp = new SerialPort(ports[indexResult], 115200);  
     sp.DataReceived += Sp_DataReceived;  
     sp.Open();  
     while (true) {  
       Console.Clear();  
       Console.WriteLine($"{_rawValue} / {_divisorValue} * 5.0 = {_voltage:N2} V");  
       Thread.Sleep(1000);  
     }  
   }  
   private static void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e)  
   {  
     var sp = (SerialPort)sender;  
     byte[] buffer = new byte[3];  
     if (sp.Read(buffer, 0, 3) != 0) {  
       int result = (buffer[0] << 8) | buffer[1];  
       var b = new BitArray(new int[] { result });  
       bool[] bits = new bool[b.Count];  
       b.CopyTo(bits, 0);  
       if (bits.Sum(s => s ? 1 : 0) != buffer[2])  
       {  
         return;  
       }  
       _rawValue = result;  
       _voltage = result / (float)_divisorValue * 5.0f;  
     }  
   }  
 } 

 

Divisor festlegen

Man bekommt zunächst einen Rohwert, der zunächst nichts aussagt. Würde man direkt die 5V Pin vom Arduino abgreifen und am Eingangspin A0 anschließen, bekäme man einen Wert von 1024. Dieser Wert muss durch 1024 geteilt und dann mit 5,0 Volt multipliziert werden.

 

Spannung = Rohmesswert / Divisor * 5,0

5,0V = 1024 / 1024 * 5,0V

 

Durch den Spannungsteiler verschiebt sich der eigentliche Rohwert, der die 5 Volt darstellt. Statt durch 1024 zu teilen, fällt dieser Wert in meinem Beispiel auf 511.

2,5V = 511 / 1024 * 5,0V

Das bedeutet, der Divisor muss in meinem Fall auf den aktuellen Rohwert angepasst werden, denn die 5V sind jetzt bei einem Rohwert von 511.

 

5,0V = 511 / 511 * 5,0V

 

Zum testen kann nun vom 3,3V Pin die Spannung zum Messen verwendet werden. Hier sollte nun ein Rohwert bei ca. 345 ankommen. Folgendes Ergebnis ergab sich bei meinem Test:

 

3,39V = 346 / 511 * 5,0V

 

Kleiner Anfang

Natürlich sind die Ergebnisse nicht sehr genau, aber für eine einfache Lösung reicht die grobe Messung aus und ist besser als gar kein Messgerät.

Der Spannungsteiler, mit den zwei 10k Ohm Widerständen, kann eine Spannung von maximal 10V angelegt werden.

 

Warnung

Natürlich sollte man immer berücksichtigen, dass die Leistungsgrenzen nicht überschritten werden. Die zu verwendenden Widerständen sollten möglich hochohmig sein, so dass am Arduino Pin kein hoher Strom eingeht.

 

Zielmessung

Kommen wir zum Testaufbau, mit dem wir eine Messung an einem anderem Stromkreis vornehmen können. Wichtig ist, dass der Ground von der anderen Spannungsquelle mit am GND des Arduinos angeschlossen wird.

 

Was kommt als nächstes?

Eine Sache habe ich hier zunächst ausgelassen, und zwar das Aufzeichnen der Messungen. Eigentlich kann ein Mehrwert mit der Funktion gewonnen werden. Andernfalls hätte man auch ein kleines Display für den Arduino einsetzen können und auf das Spannungsergebnis ausgeben würde.

 

In der Solution befinden sich die Consolen Anwendung SimpleVoltageMeasurement und bereits mein neues Projekt VoltageMeasurementLogger, dass das Aufzeichnen der Daten ermöglicht.

GitHub - VoltageMeasurementLogger

Günstiges Radar Modul für Bewegungen

Wieder mal was kleines feines und auch günstiges gefunden im Bereich Sensorik. Das Radar Modul RCWL-0516 kann Bewegungen von Personen wahrnehmen. Genau genommen von jedem Lebewesen und nicht durch bewegte Gegenständen wie Staubsaugerroboter.

Benötigt

• Arduino
• RCWL-0516 (Preislich 6 Stück ab 4€)
• Eine Person die sich  bewegt

 

Anforderung

Herausfinden in welchem Winkel und Entfernungen der Sensor funktioniert.

 

Technische Daten

Im Datenblatt steht mehr, da mir die anderen Details für das Grundlegende zunächst keinen Nutzen bringen.

 

Betriebsspannung: 4V bis 28V und mindestens 3mA

Erkennungsreichweite: ca. 5m bis 9m

Frequenz: 3.2GHz

Ausgang (OUT): geschaltet ca. 2 Sekunden lang

 

PINs:

3V3 => 3,3V Versorgungsspannung (Output)

GND => Ground

OUT => Signal Ausgang Hi-Pegel wenn eine Bewegung wahrgenommen wurde

VIN => Eingang Spannung von 4V bis 28V

CDS => Externer  Lichtabhängiger Widerstand (Ausschalten der Radar Funktion)

 

Optional:

C-  Verlängert den Geschalteten Zustand am Ausgang (OUT)Hierfür wird ein Kondensator benötigt.

R-GN Erkennungsreichweite. Mit einem 1M Ohm Widerstand kann die Reichweite von 7 Meter auf 5 Meter reduziert werden.

CDS Platz für die Installation eines Lichtabhängigen Lichtwiderstandes, um bei Licht die Radar Wahrnehmung auszuschalten.

R-CDS Einstellung für die Empfindlichkeit mit dem Lichtabhängigen Widerstandes. Dient als Spannungsteiler und je kleiner der Widerstand gewählt ist, um so heller muß die Umgebung sein für das Ausschalten der Radar Funktion

Test Programm

Der Code, um den Sensor auszulesen ist sehr simpel. Das Signal, welches über den OUT Ausgegeben wird, ist entweder 0V oder 3,3V. Damit reicht einen PIN für digitales Signal Lesen aus. Analog Signal einlesen bringt uns da keinen Mehrwert, denn hier kann nur ein LOW- oder HIGH-Pegel ausgegeben werden.

 int mRadarInput = 2;  
 void setup() {  
  Serial.begin(115200);  
  pinMode(mRadarInput, INPUT);  
 }  
 void loop() {  
  bool movmentDetect = digitalRead(mRadarInput);  
  Serial.print("Movement: ");  
  Serial.println(movmentDetect, BIN);  
  delay(100);  
 }  

Anschließen

Für den Beispielaufbau werden nur drei Leitungen zum Verbinden des Sensor verwendet. Der Anschluß auf dem 3.3V steht, ist ein OUTPUT und kann verwendet werden, andere Controller zu versorgen. Der CDS Anschluß kann wiederum für ein Lichtsensor verwendet werden, um das Feststellen von Bewegungen abzustellen.

 

 

Entfernung und Winkel

Die Reichweite ist gut für das Feststellen von Bewegungen innerhalb eines Zimmers. Der Sensor kann Bewegungen rund um dem Modul war nehmen, aber Ideal ist wiederum die Seite mit dem Aufgelöteten Chip. Die Wahrnehmung auf Bewegungen wirkt unterschiedlich, aber gut brauchbar.

Typische Gegenstände wie Kunststoff oder Holz schränkt die Funktion nicht ein. Metall hingegen wirkt Abschirmend auf das Radar.

 

Timing

Wenn ich mich bei der Übersetzung vertan habe, dann kann das Timing von 2 Sekunden nur verlängert werden, aber nicht verkürzt.

 

Anwendungsbeispiele

In den meisten Fällen würde man dieses Radar Modul zum Einschalten von Lampen verwenden. Natürlich könnte man da auch Alarmanlagen dafür einsetzen, setzt jedoch einen Raum voraus, in dem keiner sein sollte.

 

Sourcen

Datasheet PDF