Posts mit dem Label Sensor werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Sensor werden angezeigt. Alle Posts anzeigen

Montag, 18. April 2022

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)

 

Montag, 18. Oktober 2021

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

 

Sonntag, 12. September 2021

Sensor Daten über Smart Port versenden mit dem Arduino


Der Empfänger, den ich für meinen FPV RC Crawler verwende, hat einen Smartport an dem z.B. Sensoren angeschlossen werden können. Die Anzahl der verfügbaren Sensoren von Frsky ist übersichtlich, aber speziell für meinen Bedarf war keiner dabei. Wie gut, dass hier bereits eine Lösung mit dem Arduino vorhanden ist und ich dazu auf den Arduino Webseite den Eintrag "S.Port sensor library for FrSky" gefunden habe.

Verwendet

  • Arduino Mini
  • Temperatur Sensor
  • Diode
  • FrSky Empfänger mit Smartport
  • Fernsteuerung mit OpenTX

 

Ziel

Die erfasste Temperatur des Sensors soll auf der Fernsteuerung umgerechnet und auf dem Display angezeigt werden.

 

Funktioniert das wirklich?

Wie bei jeder neuen Sache, prüfe ich mit wenig Aufwand, ob das Zielvorhaben erreichbar ist. Praktisch ein PoC. Im Grunde formuliere ich meine Blogeinträge anfangs als "Proof of Concept", bevor daraus ein Beispiel wird und das gilt auch wieder für diesen Eintrag. Nur diesmal beschreibe ich das Testen mit.

In den Sourcen zur Bibliothek für den SmartPort, sind, wie auch bei den anderen Beispiele Codes vorhanden. Für mich ist der ein feststehender Wert zu wenig und deshalb ändere ich den zu sendenden Wert in der Loop Methode.

 #include <SPort.h>  
 SPortHub hub(0x12, 3);  
 CustomSPortSensor sensor(getSensorData);   
 int mSendingValue = 0;  
 int mCurrentMillis;  
 void setup() {  
  hub.registerSensor(sensor);  
  hub.begin();                
 }  
 void loop() {  
  hub.handle();   
  int current = millis();  
  if(current - mCurrentMillis < 100) {  
    return;  
  }  
  mCurrentMillis = current;  
  mSendingValue++;    
 }  
 sportData getSensorData(CustomSPortSensor* sensor) {  
  sportData data;   
  data.applicationId = 0x5900;        
  data.value = mSendingValue;  
  return data;  
 }  

Ist der Code auf dem Arduino geschrieben, muss eine Verkabelung zum Smartport hergestellt werden. Hierfür soll die Diode verwendet werden, aber vielleicht sollte ich die Beschreibung nochmal durchgehen, wofür die Diode gut ist. (Später habe ich die Diode doch nicht verwendet)

 

 

Sensor einbinden

Die Fernsteuerung mit dem OpenTX Betriebssystem kann nun eingeschaltet werden. Im Menü TELEMETRY (Abschnitt 11 auf der Xlite pro) für Sensoren, kann nun die Suche gestartet werden. Wenn der Arduino mit dem Code als Sensor funktioniert, sollte schon nach wenigen Sekunden der Sensor in OpenTX  gefunden werden.

 


 

Display Wiedergabe

Für den Bildschirm können mehrere Seiten eingerichtet werden, auf denen die Sensor Ergebnisse ausgegeben werden. Dazu muss über das Menü DISPLAY (Abschnitt 12 auf der Xlite pro) der Screen auf "Nums" eingestellt werden und dann muss darunter ein Feld mit "---" auf den neuen Sensor eingestellt werden.

 


Ist die Fernsteuerung auf den Hauptbildschirm geschaltet, muss man in meinem Fall den Stick für eine Sekunde nach unten ziehen, damit das eingerichtete DISPLAY gezeigt wird.

 

 

Echten Sensor anschließen

Das war schon alles, um sich an den SmartPort ran zuhängen. Natürlich macht der Anschluss nur Sinn mit einem echten Sensor.

Für dieses Beispiel verwende ich einen Temperatur Sensor, der über die I²C Schnittstelle angesprochen wird. An der Stelle hätte ich auch einen interessanteren Sensor nehmen können, dennoch soll das Beispiel schlicht bleiben. Und der Code für den Temperatur Sensor lässt sich in wenigen Zeilen eingeben.

 #include <SPort.h>  
 #include <Wire.h>  
 SPortHub hub(0x12, 3);  
 CustomSPortSensor sensor(getSensorData);  
 #define TMP102_ADD 0x48  
 void setup() {  
  Wire.begin();  
  hub.registerSensor(sensor);  
  hub.begin();                
 }  
 void loop() {  
  hub.handle();  
 }  
 sportData getSensorData(CustomSPortSensor* sensor) {  
  sportData data;   
  data.applicationId = 0x5900;  
  int raw = getTemperatureValue();  
  float result = raw * 0.0625;  
  data.value = raw;  
  return data;  
 }  
 int getTemperatureValue() {  
  Wire.beginTransmission(TMP102_ADD);  
  Wire.write(0x00);  
  delay(100);  
  Wire.endTransmission();  
  Wire.requestFrom(TMP102_ADD, 2);  
  while(Wire.available() < 2) { }  
  return ((Wire.read() << 8) | Wire.read()) >> 4;  
 } 


Wert-Ausgabe nur Ganzzahl

Nun haben wir einen Rohwert, der einem so nichts sagt. Eigentlich könnte der Wert am Arduino umgerechnet werden, aber ich hatte aus den Source Code gelesen, dass nur Ganzzahlen übermittelt werden.

 

LUA Script

Die Antwort für das Umrechnen der Ganzzahlen in einen Wert mit Nachkommastellen ist die Unterstützung von Lua Script auf OpenTX. Statt den Rohwert auf dem Display auszugeben, kann dieser durch einen Script umgerechnet werden und dann auf dem Display als lesbaren Wert ausgegeben werden.

Aber kommen wir zunächst zu dem Teil, was eigentlich ein LUA Script haben muss. Im Wesentlichen hilft hier die Dokumentation Telemetry Scripts.

 

Vorraussetzung

  • Das Lua Script muss auf der SD Karte in das Unterverzeichnis "SCRIPTS\TELEMETRY\".
  • Das Script muss die Namenserweiterung ".lua" haben.
  • Der Name des Lua Script darf nicht länger als sechs Zeichen lang sein, ansonsten wird das Script in der DISPLAY Einrichtung nicht angezeigt. Die Namenserweiterung ".lua" wird an der Stelle nicht mit gezählt.

Im Grunde sollte das Script mindestens die 'local function run' enthalten. Die "Init" Funktion ist optional und eigentlich sollte das auch ohne eine Background-Funktion funktionieren. Wichtig ist, dass die Methode am Ende einen Return-Wert ausgibt.

 local function run_func(event)  
      lcd.clear()  
      local receivedValue = getValue('TEMP')  
      local toDecValue = receivedValue * 0.0625;  
      lcd.drawText(10, 10, "Temperature", MIDSIZE)  
      lcd.drawText(10, 25, string.format("%.2f", toDecValue), MIDSIZE)  
      return 0  
 end  
 return { run=run_func }   


Einbinden des Scripts

Nun kann das Script auf die SD Karte und in die Fernsteuerung mit OpenTX gesteckt werden. Nach dem Einschalten kann über das Menü DISPLAY (auf der Xlite Pro befindet sich dieses in Abschnitt 12), auf Screen 1 von Nums gewechselt werden. Rechts von der Script Einstellung, kann man nun das Script myVal.lua auswählen.


 

Anschließen geht’s zurück auf den Hauptscreen. Mit dem 1 bis 2 Sek nach unten gezogenen Stick kann man vom Hauptdisplay auf den gescripteten Bildschirm (Display) wechseln. Fertig!

 

 

Schlusswort

Irgendwie habe ich im Internet keine Beschreibung gefunden, die in wenigen Schritten aufzeigt, was zu tun ist, um einen Wert auf dem Display anzuzeigen. Am Ende ist der Aufbau sehr übersichtlich, aber die kleinen Details, die man wissen muss, halten einen auf.

Natürlich werde ich an den Sensor mehr als nur ein Temperatur Sensor anschließen, schließlich kann man die Lage noch ermitteln und Abstände messen.

Was ich vermisse, ist ein Designer für die Bildschirm Ausgabe. Entweder habe ich den nicht gefunden oder für diesen Zweck gibt’s einfach keinen. Dabei wäre ein Designer nicht schwierig, aber es wäre zeitaufwendig diesen zu entwickeln (womit ich mir praktisch die Frage selbst beantworte).

 

Eintrag zu meinem Repository:

GitHub - ExampleFrskySensor

 

Sourcen

Sonntag, 16. August 2020

Analog Digital Wandler ADS1115 einlesen (Meadow)

Meistens, wenn ich ein Modul finde, das ich noch nicht kenne, dann existiert bereits eine Bibliothek, die in C/C++ geschrieben ist.

Schaut man im .NET Umfeld, dann ist wiederum meistens nichts zu finden. Damit ist mein Interesse geweckt, etwas darüber zu schreiben und natürlich ein Beispiel-Code hier auf meinem Blog zu veröffentlichen.

Seit fast einem Jahr liegt bei mir der Meadow und läuft aktuell mit dem Beispielprogramm. Dieser Controller zielt auf ‚Internet of Things‘- Themen ab und ist der direkte Nachfolger vom Netduino. Im Gegensatz zu dem Netduino, kann mit dem Meadow in der aktuellen C# (8.0) und .NET Framework (4.7.3) Version geschrieben werden. Dies bedeutet auch, dass gegenüber dem veraltetem .NET Micro Framework vieles neu aufgebaut wurde und folglich neue Lösungen geschrieben werden können.

 Benötigt:

  • Meadow
  • Breadboard
  • Jumper Leitungen
  • Potentiometer (oder alternative ein Widerstand und ein Lichtempfindlicher Widerstand)
  • ADS1115

 

Kurzes über den AD Wandler

Bevor ich mit der Zielbeschreibung loslege, müssen einige Details zu dem AD Wandler genannt werden. Beispielsweise, wie hoch darf die Eingangsspannung sein, die auf den vier Eingängen angelegt wird?

Betriebsspannung (VDD)

2V bis 5,5V

Stromaufnahme (Continuous Mode)

150uA

Industrieschnittstelle

I²C

Adresse

0x48 (Kann geändert werden durch Pin Select)

Eingänge

4

Abtastrate

8 bis 860

Eingangsspannung

-0,3V bis +0,3V über der Betriebsspannung (VDD)

Eingangsstrom

10mA bei fortlaufender Messung, 100mA bei einzel Messung

Für manche Anwendung ist auch die Betriebstemperatur wichtig, die hier von -40°C bis +125°C sein darf.


Anforderung

An einem Potitiometer soll die anliegende Teilspannungshöhe geändert werden. Die abgeleitete Teilspannung soll am Eingang A0 eingehen. Über einen Methoden Aufruf soll der Eingang eingelesen und dessen Wert über die Output Konsole ausgegeben werden.

 

Schaltungsaufbau

Im folgendem Bild ist zu sehen, dass ich kein Potitiometer verwende (schlichtweg, weil ich keinen hatte). Alternativ verwende ich einen 10k Ohm Widerstand und einen üblichen Lichtempfindlichen Widerstand (Lichtsensor 30 - 90 KOhm).


Verwenden von bestehenden Informationen

Zuerst wollte ich den bestehenden C++ Code migrieren nach C# und .NET Framework. Das bedeutet im Grunde, dass ich die Methodennamen und die #define Direktiven mit dessen Biteinstellungen (HEX Werte) direkt übernehme. Aber nach und nach stellte ich fest, dass einige Inhalte sich auf andere Module wiederum bezogen und ich immer wieder im Datenblatt nach sehen musste, was eigentlich die einzelne Biteinstellung für das Modul bedeutet. Ein Beispiel ist die Standard Einstellung 128SPS (Samples per second) für den ADS1115 Modul, aber im Adafruit Code steht etwas von 1600SPS.

Das Gute daran ist, man erarbeitet sich selbst eine Lösung, wie die Einstellungen abgebildet werden. Das macht den Aufbau der Klasse einfacher und die Beschreibungen zielgenauer.


Programm code

Im folgenden Beispiel aus dem ‚SimpleCode‘-Branch wurde nur das übernommen, was den Standard- Einstellungen entsprach. Z.B. Bitstellungen, die mit 0 belegt sind (bzw. in HEX 0x00 Wert) mussten nicht sein, da das Anlegen der Konfiguration immer mit 0 beginnt. Der folgende Code ist aus der Klasse ‚SimpleAds1115‘ und hat für den Abruf eine öffentliche Methode ‚ReadSingleInputValue‘ zum Abruf der anliegenden Spannung. Die Parameter-Eingabe bestimmt, welcher Eingang gelesen wird.

 internal class SimpleAds1115 : App<F7Micro, SimpleAds1115>  
 {  
   private readonly II2cPeripheral _i2CPeripheral;  
   public SimpleAds1115()  
   {  
     var i2CBus = Device.CreateI2cBus();  
     this._i2CPeripheral = new I2cPeripheral(i2CBus, 0x48);  
   }  
   internal ushort ReadSingleInputValue(AdsInput input)  
   {  
     // disable the comparator  
     // Single-shot mode (default)  
     // Operational status/single-shot conversion start  
     // - Begin a single conversion  
     ushort config = 0x8103;  
     config |= (ushort)input;  
     byte[] data = new byte[] { (byte)(config >> 8), (byte)(config & 0xff) };  
     this._i2CPeripheral.WriteRegisters(0x01, data);  
     Thread.Sleep(9);  
     var result = this._i2CPeripheral.ReadRegisters(0x00, 2);  
     return (ushort)((result[0] << 8) | result[1]);  
   }  
 }  

Vollumfänglich wird später die Klasse ‚Ads1115‘, die zu dem jetzigen Zeitpunkt nicht fertig ist.


Auf den Meadow schreiben

Sobald die Anwendung über Deploy auf dem Meadow geschrieben wurde, kann über das Fenster 'Output' das Ergebnis der anliegenden Spannung gelesen werden. Mit der Static Methode ‚GetVoltage‘ wird der gelesene Wert umgerechnet in Volt. Den Wert 22610 entnahm ich bei einem Eingangssignal von 5V. An der Stelle könnt Ihr den zu kalibrierenden Wert ersetzen, wenn bei Euch mit 5V ein anderer Wert gemessen wird.

 


Vorsicht mit der maximalen Eingangsspannung

In Standard Einstellungen sind die Eingänge bis 6,144V. Bei dieser Einstellung sollte nicht mehr als 0,3V anliegen, weil dies zur einer Beschädigung des Moduls führen könnte.


Fazit

Zunächst das Offensichtliche:  wenn das eigene Projekt mehr Analog-Digital Wandler benötigt, dann ist dieses Modul genau richtig. In einem I²C Bus können bis zu vier Module adressiert werden. Doch dieses Modul hat noch weitere Funktionen, um sich auf die Bedingungen eines Projektes besser anzupassen. Die Eingänge können auf gezielte Maximal-Spannungen eingestellt werden. Die Anzahl der Messungen pro Sekunde gehen bis zu 860SPS (Samples per second). Die vier Eingänge werden durch ein Multiplex Funktion angesprochen, so das von vier Eingänge auf zwei Eingänge umgestellt werden kann. Mit dem einstellbaren Komparator kann auf spezifische Bedingung reagiert werden.

 

Meadow Code
Github – ExampleAds1115 (SimpleCode Branch)

Sonntag, 10. Dezember 2017

Von Händlern, Kisten und Münzen (Arduino Esplora, Part 8)


Ok, so richtiger Handel wird hier nicht stattfinden. Dafür reicht der Speicher nicht. Oder? In erster Linie sollen nur Grund Funktionen Umgesetzt werden. Ziel wird sein, wenn die Figur vor dem Händler oder einer Kiste steht, dann sollte sich der Inhalt Zeigen. Anschließend kann ein Objekt Ausgewählt und in die eigene Tasche übertragen werden. Leider passt das nicht alles in einen Blogpost, so dass der Inhalt mit der Waren Anzeige in einem späteren Post kommt.

Anforderung
Beim Händler können Gegenstände erworben werden und diese in Kisten abgelegt werden. Das erfordert einige mehr Programmcodezeilen und daher muss an der Stelle wieder eine neue Seite  mit dem Namen 'TraderComponent' angelegt werden.


Am Anfang werden die Werte für Händler und Kisten hinterlegt, die später über den Flashspeicher abgerufen werden. Die Münzen werden hier ebenfalls abgelegt als Funktionsvariable, wird aber erst in einen späteren Post weiter behandelt. (im Folgender Programmcode sind Kommentare und Bilddaten gekürzt, ggf. schaut ihr am besten in die Github Sourcen)

 // # Coins, im Besitz  
 int16_t coins = 25;  
 int16_t lastStateCoins = 0;  
 // # Common Text   
 // Begruessungstext (Sollte immer verschieden sein.)  
 const PROGMEM char traderStartText[] = "Hallo, was darf ich ihnen verkaufen?";  
 // Wenn zu wenig Muenzen zum Kaufen da sind  
 const PROGMEM char traderNotEnough[] = "Du hast nicht genug Muenzen.";  
 // Frage zum Kauf  
 const PROGMEM char traderYouWantToBuy[] = "Kaufen?";  
 // # Common Sprite  
 // Bild vom Handler / Die Farbe des Shirts, kann veraendert werden.  
 const PROGMEM byte traderSpriteFrontMen[160] = { … };  
 const PROGMEM byte traderSpriteFrontWomen[160] = { … };  
 const PROGMEM byte boxSpriteFront[100] = { … };  
 const PROGMEM byte coinSpiteIcon[49] = { … };  
 // # TRADER  
 // temp Variablen zum zwischen laden.  
 char traderName[1];  
 char traderdescription[1];  
 byte traderItems[4];  
 // '0' bedeutet immer nicht belegt.  
 // #######################################  
 // ID 1  
 // Name des Handlers  
 const PROGMEM char trader01Name[5] = "Surie";  
 // Kurze Beschreibung  
 const PROGMEM char trader01Description[11] = "Verkaeferin";  
 // Dinge zum verkauf  
 const PROGMEM byte trader01Items[4] = { 2, 0, 0, 0 }; // 2 = Kamera  
 // 0 = Taschenplaetze werden wie angegeben befullt.  
 // Stellen werden Stellenweise in Bit herausgenommen  
 byte trader01ItemsClear = 0;  
 // # Box  
 // '0' bedeutet immer nicht belegt.  
 // #######################################  
 // ID 1  
 // Name des Handlers  
 const PROGMEM char box01Name[11] = "Meine Kiste";  
 // Kurze Beschreibung  
 const PROGMEM char box01Description[25] = "Dinge die man so braucht.";  
 // Dinge zum verkauf  
 const PROGMEM byte box01Items[4] = { 3, 0, 0, 0 }; // 3 = Foto  
 void memCopyItems(byte arrayContent[], byte traderItemsClear) {  
   if(traderItemsClear == 128) {  
   traderItemsClear-= 128;  
   traderItems[0] = 0;  
  }  
  else { traderItems[0] = pgm_read_byte_near(arrayContent + 0); }  
  if(traderItemsClear &gt;= 64) {  
   traderItemsClear-= 64;  
   traderItems[1] = 0;  
  }  
  else { traderItems[1] = pgm_read_byte_near(arrayContent + 1); }  
  if(traderItemsClear &gt;= 32) {  
   traderItemsClear-= 32;  
   traderItems[2] = 0;  
  }  
  else { traderItems[2] = pgm_read_byte_near(arrayContent + 2); }  
  if(traderItemsClear &gt;= 16) {  
   traderItemsClear-= 16;  
   traderItems[3] = 0;  
  }  
  else { traderItems[3] = pgm_read_byte_near(arrayContent + 3); }  
 }  
 void drawTrader(int16_t traderId, int16_t positionX, int16_t positionY) {  
  if(!mapFigureRerender) {  
   return;  
  }  
  mapFigureRerender = false;  
  switch(traderId) {  
   case(1): { // Farbe des Haenderls/in  
    spriteHairColor1 = 0xEEEC; spriteHairColor2 = 0xE662; // hell Braun 1, hell braun 2  
    spriteShirtColor1 = 0xD69A; spriteShirtColor2 = 0xB596; // hell grau, grau  
    spritePantsColor1 = 0x0418; spritePantsColor2 = 0x0312; // Blau 1, blau  
    memCopy(traderSpriteFrontWomen);             // sprite einer Weiblichen figur  
    memCopyItems(trader01Items, trader01ItemsClear);     // Taschen Inhalt  
    break;  
   }  
   case(2): { // Farbe des Haenderls/in  
    spriteHairColor1 = 0xD615; spriteHairColor2 = 0xBD30; // hell Braun 1, hell braun 2  
    spriteShirtColor1 = 0xD69A; spriteShirtColor2 = 0xB596; // hell grau, grau  
    spritePantsColor1 = 0x0418; spritePantsColor2 = 0x0312; // Blau 1, blau  
    memCopy(traderSpriteFrontMen);  
    break;  
   }  
   default: { break; }  
  }  
  drawTile(positionX, positionY, 10, 16, tempArray, false);  
 }  
 void drawBox(int16_t boxId, int16_t positionX, int16_t positionY) {  
  switch(boxId) {  
   case(1): {  
    boxColor = 0xDCFE;  
    break;  
   }  
   default: { break; }  
  }  
  memCopy(boxSpriteFront);  
  drawTile(positionX, positionY, 10, 10, tempArray, false);  
 }  
 void drawCoinsStatus(bool redraw) {  
  if(coins != lastStateCoins || redraw) {  
   EsploraTFT.fillRect(2, 2, 30, 9, mapNumberToColor(1));  
   memCopy(coinSpiteIcon);  
   drawTile(3, 3, 7, 7, tempArray, false);  
   writeValue(12, 3, coins, false);  
   lastStateCoins = coins;  
  }  
 }  

Der Händler oder Händlerin sollten für die Kollisionsabfrage den selben Raum einnehmen, wie die eigene Spielfigur. Damit dies funktioniert und der Händler nicht wie ein Karten Block (Kachelgröße) registriert wird, ist eine kleine Erweiterung an der Methode "CanEnterArea" mit "checkCollideOther" notwendig. Etwas abwegig ist die Abfrage der Position, weil diese wiederum über das Byte Array der Karte weiterhin abgefragt wird. Dafür habe ich eine relativ simple Lösung (ggf. in den Github Source schauen)

boolean checkCollideOther(boolean resultColide, int positionX, int positionY) {
  // anderes bewegbares objekt
  if(resultColide) {

    int overlap = 4;
    resultColide = checkCollide(positionX, positionY, mapFigurePositionX + (overlap / 2), mapFigurePositionY + (overlap), 10 - overlap, 16 - (overlap * 2));

    // zum testen Fenster oeffnen
    showWindow = !resultColide;
    menueNavigation = showWindow;
  }

  return resultColide;
}

Message Box
Der Text bekommt sein Platz in einem eigenen Fenster Bereich. Für diese Funktion wird ebenfalls eine weiter Seite angelegt mit dem Namen "WindowComponent". Das Fenster (MessageBox) wird angezeigt, sobald man mit seiner gesteuerten Figur in den Kollisionsradius des Händlers kommt.
Solange der Dialog offen ist, sollte die Figur nicht mehr bewegbar sein und mit dem Joystick kann nur noch in den Taschenplätzen Navigiert werden. Nachdem der Spieler die Schließen-Option Auswählt, verschwindet das Fenster und die Figur sollte sich wieder frei bewegen können.
Was im folgenden Code nicht zu sehen ist, ist die Ausführung des Schließen der MessageBox über den Button 2 bzw. Switch 2.

// Legt ein Fenster in den Vordergrund
bool lastStateShowWindow = false;
bool windowHasRendered = false;

void drawWindow(bool rightSide) {
  if(lastStateShowWindow != showWindow && !showWindow) {
    lastStateShowWindow = showWindow;
    drawStack(true);
  }

  lastStateShowWindow = showWindow;
  
  if(!showWindow) {
    windowHasRendered = false;
    return;
  }

  if(windowHasRendered) {
    return;
  }
  
  // Mitte des Bildschirm schreiben
  int sizeX = 100; int sizeY = 40;
  int winPosX = (EsploraTFT.width() / 2) - (sizeX / 2);
  int winPosY = (EsploraTFT.height() / 2) - (sizeY / 2);

  EsploraTFT.fillRect(winPosX, winPosY, sizeX, sizeY, mapNumberToColor(0));
  EsploraTFT.drawRect(winPosX, winPosY, sizeX, sizeY, mapNumberToColor(18));
  EsploraTFT.drawRect(winPosX + 2, winPosY + 2, sizeX - 4, sizeY - 4, mapNumberToColor(18));

  // Text schreiben
  writeText(winPosX + 5, winPosY + 5, "Hallo!");
  writeText(winPosX + 5, winPosY + 28, "Schliessen [2]");
   windowHasRendered = true;
}


Das Stehenbleiben der Figur muss wiederum auf der Hauptseite festgelegt werden. Dazu muss die Funktion für das Laufen erweitert werden, damit die Figur sich erst nach der Option "Schließen" bewegen kann. Zudem müssen alle Inhalte nach dem Schließen neu gerendert werden mit der  Methode 'drawStack'.

void loop() {
  …  
  // Wenn sich X oder Y Position unterscheiden, dann den zu bewegenden Punkt neu zeichnen.
  if(!menueNavigation && lastPosX != lastPosXtemp || lastPosY != lastPosYtemp) {

    drawStack(false);
  }
  else if(menueNavigation) {
    menueNavigateWithDelay();
  }

  drawWindow(lastPosX > EsploraTFT.width() / 2);
  drawCoinsStatus(false);
}

Der Dialog ist noch nicht ganz fertig. Die Taschenplätze sollten mit dem Joystick erreichbar sein. Das fehlt derzeitig auch für den Rucksack. Dies würde jedoch den Rahmen des Posts sprengen und kommt daher im übernächsten. Für den nächsten Part wird der Programmcode dringend aufgeräumt, auf dass ich näher eingehen will.



Sonntag, 29. Oktober 2017

Ich packe in meinen Rucksack (Arduino Esplora, Part 7)


Was wäre ein Abenteuer ohne einen Rucksack, in dem man seine Gefundenen Gegenstände einsammeln kann. Um diese Funktion Übersichtlich zu halten, wird der Rucksack sechs Plätze haben. Im Vorfeld muss festgelegt werden, wie zunächst die Informationen im Rucksack gehalten werden. Auch hier wird weiterhin eine Datenbanklose Lösung erzielt. Die Gegenstände müssen als Abstrakt betrachtet werden, so dass diese auf wesentliche Informationen eingeschränkt wird.

Ein wichtiger Punkt wird sein, die Funktionsvariablen entsprechend zu kommentieren. Das wird später hilfreich sein, die Informationen auch wieder zu zuordnen.

Ein Objekt sollte Grundlegende Eigenschaften haben:

  • Name
  • Bild (ein 16x16 Pixel Sprite)
  • Beschreibung (sollte nur für bestimmte Gegenstände verwendet werden)
  • Verwendungszweck

Damit der Gegenstand Zugeordnet werden kann, ist zusätzlich eine Identifikationsnummer erforderlich oder auch kurz ID. Diese wird z.B. für den Rucksack Funktion verwendet. Allerdings muss die ID Nummer nicht als Funktionsvariable angelegt werden und steht nur als Kommentar zu den verwendeten Daten.

 // ID 01  
 // Name  
 const PROGMEM char itemKey01[10] = "Schluessel";  
 // Icon / Bild  
 const PROGMEM byte itemKey01Icon[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,10,10,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,10,0,0,10,10,10,10,10,10,10,10,10,10,10,0,0,10,0,0,10,10,0,10,0,0,0,0,10,0,0,0,0,10,0,0,10,0,0,0,0,0,0,0,10,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,10,10,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };  
 // Beschreibung  
 const PROGMEM char itemKey01Description[] = "Oeffnet eine Box";  
 // Verwendungszweck Id =&gt; kombinierte funktions abruf fur position und verknuepfte Box mit der selben Id  
 const PROGMEM uint16_t itemKey01Usage = 1;  
 // #######################################  
 // ID 02  
 // Name  
 const PROGMEM char itemCamera[6] = "Kamera";  
 // Icon / Bild  
 const PROGMEM byte itemCameraIcon[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,9,9,9,9,9,9,1,0,0,0,0,0,1,1,1,1,9,19,19,19,19,9,1,1,1,1,0,1,9,9,9,9,9,9,1,1,9,9,9,9,9,9,1,1,9,9,9,9,1,1,11,11,1,1,9,19,19,9,1,1,9,9,9,9,1,11,11,11,11,1,9,19,19,9,1,1,9,9,9,1,11,11,11,11,11,11,1,9,9,9,1,1,9,9,9,1,11,11,11,11,11,11,1,9,9,9,1,1,9,9,9,9,1,11,11,11,11,1,9,9,9,9,1,1,9,9,9,9,1,1,11,11,1,1,9,9,9,9,1,1,9,9,9,9,9,9,1,1,9,9,9,9,9,9,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };  
 // Beschreibung  
 const PROGMEM char itemCameraDescription[] = "Mach ein paar Fotos!";  
 // Verwendungszweck  
 const PROGMEM uint16_t itemCameraUsage = 2;  

Der Name ist klar, Bild muss sein und Beschreibung zu einem Objekt ist auch hilfreich. Aber wie sieht der Einsatz für die Eigenschaft 'Verwendungszweck' aus? Im Programmcode wird dort eine Nummer stehen. Hier kommt die Kollisionsabfrage ins Spiel.

Ein Fallbeispiel
Die Figur hat den Gegenstand 'Schlüssel' und kann damit eine Bestimmte Tür öffnen. Über die Kollisionsabfrage wird geprüft, ob das Hindernis eine Tür ist. Wenn ja, dann wird der Rucksack nach einem Objekt abgefragt, dass dem Verwendungszweck entspricht.


Weiteres zum Verwendungszweck, kommt im späteren Abschnitt und bleiben zunächst bei der Umsetzung Gegenstände einzusammeln.

Der Rucksack
Als erstes sollten die Taschenplätze im Unteren Bildschirm Bereich abgebildet werden. Im Aus übersichtlichen Gründen wird im Programmcode eine weitere Seite (Tab) angelegt mit dem Namen 'BackpackComponent'. Für die Anforderungen kommen einige Funktionen hinzu, um ein Item in den Rucksack zu schreiben, abzurufen oder zu entfernen.

// Grundeinstellung des Rucksackes
#define backpackPlacesCount 6
uint16_t backPlaces[backpackPlacesCount] = { 0, 0, 0, 0, 0, 0 };
byte tempIcon[256];

// … Item Objekte …

// Kopiert das array aus dem flash in den Arbeitsspeicher
void setItemIconToTemp(byte icon[]) {
  for(int index = 0; index < 256; index++) {
    tempIcon[index] = pgm_read_byte_near(icon + index);
  }
}

// Pruefen ob das Item bereits vorhanden ist
boolean isItemInBackback(uint16_t itemId) {

  for(byte index = 0; index < 6; index++) {
    if(backPlaces[index] == itemId) { return true; }
  }
  return false;
}

// Legt das Item in die Tasche ab und Zeichnet es in einen offen Taschenplatz
bool setItemToBackpack(uint16_t itemId) {

  if(isItemInBackback(itemId)) { return false; }
  
  // id ablegen in ersten freien Taschenplatz
  byte place = 0;
  for(byte index = 0; index < sizeof(backPlaces); index++) {
    if(backPlaces[index] == 0) {
      backPlaces[index] = itemId;
      place = index;
      break;
    }
  }
  
  byte relationPlaceX = 0;
  byte relationPlaceY = 0;
  setItemRelationPlace(place, &relationPlaceX, &relationPlaceY);

  // Abruf des Icon zu dem Item
  boolean isArrayCopy = true;
  switch(itemId) {
    case(1): { setItemIconToTemp(itemKey01Icon);  break; } // Schluessel
    case(2): { setItemIconToTemp(itemCameraIcon); break; } // Fotoapparat
    case(3): { setItemIconToTemp(itemPhoto01Icon); break; } // Foto
    default: { isArrayCopy = false; break; } // Nicht belegt, darf aber auch nicht eintreten
  }

  if(isArrayCopy) { drawTile(relationPlaceX, relationPlaceY, mapTileSize, mapTileSize, tempIcon, false); }
  else { EsploraTFT.fillRect(relationPlaceX, relationPlaceY, mapTileSize, mapTileSize, 0xF800); }
  
  // einen Rahmen darueber zeichnen
  EsploraTFT.drawRect(relationPlaceX, relationPlaceY, mapTileSize, mapTileSize, mapNumberToColor(12));

  return true;
}

// Holt die anfangs Position des Taschenplatzes das auf dem Bildschirm gerendert werden soll.
void setItemRelationPlace(byte place, byte* relationPlaceX, byte* relationPlaceY) {

  if(place == 0 || place == 1 || place == 2) { *relationPlaceY = 96; }  // erste Zeile
  else if(place == 3 || place == 4 || place == 5) { *relationPlaceY = 112; }  // zweite Zeile

  if(place == 0 || place == 3) { *relationPlaceX = 0; } // erste Spalte 
  else if(place == 1 || place == 4) { *relationPlaceX = 16; } // zweite Spalte
  else if(place == 2 || place == 5) { *relationPlaceX = 32; } // dritte Spalte
}

// Prueft die Karten Id mit einem Objekt aus dem Rucksack.
bool getItemToUsed(int16_t mapUsageId) {

  int16_t itemId = 0;

  // hole itemId aus der Karteneigenschaft ab.
  if(mapUsageId == mapBarrierUsageDoor01) {
    itemId = 1; // Id des zu verwendenden Schlussels
  }

  // pruefe die Tasche, ob das Item vorhanden ist und dann aus dem inventar nehmen
  for(byte index = 0; index < sizeof(backPlaces); index++) {

    //       Item einmalig verwenden
    if(itemId != 0 && backPlaces[index] == itemId) {

      // Verwendungszweck
      if(mapUsageId == mapBarrierUsageDoor01) {

        mapBarrierDoorIsOpen = true;
        backPlaces[index] = 0; // aus dem Inventar entfernen
      }
    }
  }
  if(mapUsageId == mapBarrierUsageDoor01 && mapBarrierDoorIsOpen == true) {
    return true;
  }
   return false;
}

Die Tasche ist nun da. Jetzt fehlt noch das Einsammeln, dass mit Hilfe der Kollisionsabfrage ermöglicht. Bisher wurden nur die Werte für Begehbar und Wand geprüft. Auf der Karte kommt nun ein weiterer Wert hinzu, das für ein einzusammelndes Objekt steht. Damit wir diese Stelle wiedererkennen, muss auch das Rendern der Karte noch angepasst werden.

 ...
void renderMap(int positionX, int positionY, boolean renderAll) {

  // zum probieren wird zunächst ein Grid gerendert.
  byte index = 0;
  for(byte y = 0; y < mapTileCountY; y++) {
    for(byte x = 0; x < mapTileCountX; x++) {

      if(((positionX >= (int)(x * mapTileSize) - (int)mapTileSize && positionX <= (int)(x + 1) * (int)mapTileSize && 
          positionY >= (int)(y * mapTileSize) - (int)mapTileSize && positionY <= (int)(y + 1) * (int)mapTileSize)) || 
          renderAll) {
            byte bTile = pgm_read_byte_near(mapContent + index);

            // TODO: Kartenspezifische abhangigkeit, 
            //       Eigenschaften andern sich mit Kartenwechsel
            if(bTile == 2 && mapKeyIsGet) { bTile = 0; }
            if(bTile == 5 && mapBarrierDoorIsOpen) { bTile = 0; }
           
           renderMapTile(x, y, bTile);
      }
      index++;
    }
  }
}
...

Momentan werden die zwei Werte noch direkt in der Funktion 'renderMap' aufgerufen. Die ergänzende Ausführung ist Simple. Solange sich noch die Objekte an ihren Stellen befinden, werden die Kacheln in der vorgesehenden Farbe eingefärbt. Die Funktion 'renderMapTile' benötigt daher weitere 'case´s'.

...
void renderMapTile(byte x, byte y, byte mapSegment) {
  
  byte mapTileColorNumber = 0;
  switch(mapSegment) {
    case(1): { mapTileColorNumber = 10; break; }
    case(2): { mapTileColorNumber = 12; break; }
    case(5): { mapTileColorNumber = 13; break; }
    default: { mapTileColorNumber = 15; break; }
  }

  EsploraTFT.fillRect(x * mapTileSize, y * mapTileSize, mapTileSize, mapTileSize, mapNumberToColor(mapTileColorNumber));
}
...

Einsammeln und Verwenden
Die Kacheln, an dem eine Tür oder ein Schlüssel liegt, erfüllen zwei Eigenschaften. Die Kachel ist weiterhin begehbar und hat ein Objekt. Wurde das Objekt aufgenommen, wird jedoch im Karten Array der Wert nicht auf '0' gesetzt. Denn die Karte wird immer aus dem Flashspeicher geladen und kann nur gelesen werden. Deshalb werden neue Funktionsvariablen angelegt die den Status der Kachel wiedergeben. Das wird bereits in der Funktion 'renderMap' erledigt. Später erfüllen die Variablen auch für andere Karten dieselbe Rolle. Die Information wird jedoch für die Karte hinfällig, wenn sie verlassen wird. Aber dazu in einen späteren Post.

Die Kollisionsabfrage 'checkCollideNeighbor' wurde erweitert, um den Wert '2' und '5'. Die Werte '3' und '4' werden jetzt noch nicht verwendet, sollen aber später die selbe Eigenschaft haben, wie der Wert '2'. Der folgende Vorgang prüft ähnlich wie bei einer Kollision mit einer Wand. Allerdings wird hier nach einem Objekt geprüft, dass in der zu betretenden Kachel vorhanden ist.

 ...
  if(bTile == 2) {

    resultColide = checkCollide(positionX, positionY, mapOffsetX, mapOffsetY);

    // Abruf des Objektes, dass zu der Karte gehoert an der Position.
    if(!resultColide) {
      if(setItemToBackpack(1)) {
        mapKeyIsGet = true;
      }
      // nicht blockieren
      resultColide = true;
    }
  }
...

Der Wert '5' benötigt ein anderes Vorgehen, hält sich jedoch ebenfalls simpel. Auch hier wird vorher abgefragt, ob ein Hindernis besteht. Wenn nicht, dann prüfe ob die Tür offen ist oder der Schlüssel die Tür öffnet. In diesem Fall verschwindet der braune Block.

...
  if(bTile == 5) {

    resultColide = checkCollide(positionX, positionY, mapOffsetX, mapOffsetY);

    // Uebergabewert des Verwendungswecks > Tuer oeffnen.
    // kollision aufheben
    if(!resultColide) {
      
      // ID 1 ist der Schlüssel und entscheidet,
      // ob die Tuer sich oeffen laest.
      resultColide = getItemToUsed(1); 
    }
  }
...

Animationslos verschwindet die Tür. Hier färbt sich die braune Kachel in hell grün (sieht leider mehr grau aus), sowie die anderen Kacheln die begehbar sind.
So dass sollte Inhaltlich vom Blogpost reichen. Das Thema ist länger geworden als vorgesehen und dabei habe ich einiges noch gekürzt. Alles weiter sowie Kommentar Beschreibungen sind in den Sourcen eingetragen, die ich wieder auf Github hoch geladen habe.


Lange noch nicht fertig
Dass die Grundfunktionen noch nicht reichen, dürfte klar sein und viele würden lieber ein Schwert ziehen und Monster bekämpfen. Aber, wie bereits ein weiser Mann Sprach: "Wie soll das Schwert richtig geschwungen werden, wenn das nicht mal mit einem Stock geht".

Nächster Post: Von Händler, Kisten und Münzen (Arduino Esplora, Part 8)


Ameisen Simulation und andere Dinge

Wer lange sich schon mit C# beschäftig, hat sicherlich schon mal was von AntMe gelesen oder gehört. Diese Idee hatte ich aufgegriffen und mi...