INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Kettenoeler = EEPROM, serielle Kommunikation, externer Interrupt
19.01.2016, 12:21
Beitrag #1
Kettenoeler = EEPROM, serielle Kommunikation, externer Interrupt
Grüß euch,
Ich habe für mich, um zu lernen, ein Projekt gestartet, in dem alles vorkommt, wie in der Überschrift beschrieben.
Nachdem ich nicht Sinn und Ziellos Programmierern wollte, habe ich mir ein Thema gewählt, das mich persönlich betrifft Big Grin

Da wird das auslesen und setzen von Variablen über die serielle Schnittstelle praktiziert,
das Beschreiben und Auslesen des EEPROM,
und das verwenden eines externen Interrupt.
Alles spannende Themen für mich :-)

Möglicherweise muss der Eine oder Andere von euch auch in regelmäßigen Abständen die Kette seines Motorrades schmieren.

Natürlich gibt es einige Hersteller, die die nötige Elektronik und Mechanik zur Automatisierung anbieten. Das kommt für mich aber nicht in Frage, da lernt man ja nichts dabei.
Dann gibt es noch die Rehtronik, das ist eine freie Variante, zum nachbauen.
Dort habe ich mir KnofHof und Ideen geholt.

Die Anforderungen:
Ich muss die Wegstrecke messen
die Ölmenge und Ölintervalle bestimmen
Es muss so flexibel sein, das es an jedes Fahrzeug angepasst werden kann,
Die Konfiguration soll via Handy funktionieren

Mein Code dazu
Code:
/*
*
*
* Kommando zum setzen der Werte:
* {"command":"setvalues", "raddurchmesser":2.156, "streckeoelen":10, "anzmagnete":3, "Pumpstoesse":5,}
* {"command":"setvalues", "streckeoelen":3}
* Es müssen allerdings nicht alle Werte angegeben werden.
* Die tatsächlich übergebenen Werte werden gesetzt.
*
* Kommando zum holen der aktuellen Werte:
* {"command":"getvalues"}
* {"command":"getvalues", "values":["raddurchmesser","streckeoelen"]}
* Result:
* {"result":"getvalues", "raddurchmesser":1.780, "streckeoelen":10, "anzmagnete":1, "Pumpstoesse":0}
* Es werden immer alle Werte geliefert.
*
* Kommando zum Entlüften der Pumpe:
* {"command":"entluften"}
*
* Kommando zum Lesen der Default-Values:
* {"command":"getdefaultvalues"}
* {"result":"getdefaultvalues", "raddurchmesser":1.780, "streckeoelen":10, "anzmagnete":1, "Pumpstoesse":0}
*/

// eingebundene Libraries

#include <SoftwareSerial.h>
#include <ArduinoJson.h>
#include <EEPROMex.h>

// Variablen und Pin Definitionen -----------------------------------------------------------------------------------------

const byte HallsensorPin = 2;        // Pin 2 ist HallsensorPin für Sensor
int ImpulsHallgeber = 0;             // Zählt die Impulse vom Hallsensor


// Variabe für Jason - serielle Kommunikation
float Raddurchmesser = 0;       // in m Raddurchmesser in m
int StreckeOelen = 0 ;          // in m  nach welcher gefahrenen Strecke soll geschmiert werden
byte AnzMagnete = 10 ;          // Wie viele Magnete/Impulse je Radumdrehung)
byte Pumpstoesse = 0;           // Anzahl der Pumpvorgänge bei einem Ölvorgang

// Pumpe
const byte PumpePin = 13;            // Da ist die Pumpe angeschlossen

// Berechnet
float AnzahlImpOelen = 0;            // Anzahl der Impulse vom Hallsensor bei der Erreichung, ein Ölintervall beginnt

// Speicheradressen der Variablen für EEPROMx
byte addrPumpstoesse = 0;
byte addrAnzMagnete = 1;
byte addrStreckeOelen = 2;
byte addrRaddurchmesser = 4;


// --------------------------------------------------------------------------------------------------------------------------

void setup() {

// Konfiguration serielle Schnittstelle
  Serial.begin(9600);

// Einlesen der Werte aus dem EEPROM
Raddurchmesser = EEPROM.readFloat(addrRaddurchmesser);      
StreckeOelen = EEPROM.readInt(addrStreckeOelen);          
AnzMagnete = EEPROM.readByte(addrAnzMagnete);                
Pumpstoesse = EEPROM.readByte(addrPumpstoesse);


  // Konfiguration Hallsensor Eingang
  pinMode(HallsensorPin, INPUT);      // HallsensorPinspin auf HallsensorPin stellen
  digitalWrite(HallsensorPin, LOW );  // und PullupWiderstand einschalten

  // Konfiguration Pumpenausgang
  pinMode(PumpePin, OUTPUT);          // Da ist die Spule der Pumpe angeschlossen  
  digitalWrite(PumpePin, LOW);        // Die Pumpe an PumpePin wird ausgeschaltet
  
        
// Interrupt konfigurieren
// Interrupt 0 auf Routine Hallsensor setzen  reagiert auf sinkende Flanken an HallsensorPin
  attachInterrupt(digitalPinToInterrupt(HallsensorPin), Hallsensor, RISING);

// Berechnen der Schmierintervall
   AnzahlImpOelen = (StreckeOelen/Raddurchmesser)*AnzMagnete;



}                                                      



// Hauptprogramm --------------------------------------------------------------{"command":"setvalues", "streckeoelen":3}---------------------------------
void loop() {  
  

  // Konfiguration Jason
  if (Serial.available() > 0) {
    String json = "";
    // read the incoming byte:
    //incomingByte = Serial.read();
    json = Serial.readString();
              
    StaticJsonBuffer<200> jsonBuffer;
    JsonObject& root = jsonBuffer.parseObject(json);
    //const char* command    = root["command"];
    String command    = root["command"];
    
    // Beispiel: {"command":"entluften"}
    if (command.equals("entluften")) {
      Serial.print("Entlueften wird gestartet ...");
    }
    else if (command.equals("getvalues"))
    {
      // Werte als Json zurückliefern ...
      // Beispiel: {"command":"getvalues"}
      // Result: {"result":"getvalues", "raddurchmesser":2.156, "streckeoelen":10, "anzmagnete":3, "pumpstoesse":5}
      StaticJsonBuffer<200> jsonOutBuffer;
      JsonObject& root = jsonBuffer.createObject();
      root["result"] = "getvalues";
      root["raddurchmesser"].set(Raddurchmesser, 3);
      root["streckeoelen"] = StreckeOelen;
      root["anzmagnete"] = AnzMagnete;
      root["pumpstoesse"] = Pumpstoesse;
      root.printTo(Serial);
      
     }
    else if (command.equals("setvalues"))
    {
      // Beispiel: {"command":"setvalues", "raddurchmesser":2.156, "streckeoelen":10, "anzmagnete":3, "pumpstoesse":5}
      if (root.containsKey("raddurchmesser") && root["raddurchmesser"].is<float>()) {
        Raddurchmesser = root["raddurchmesser"];
        EEPROM.updateFloat(addrRaddurchmesser, Raddurchmesser);
        Raddurchmesser = EEPROM.readFloat(addrRaddurchmesser);
        Serial.println("Setze raddurchmesser");
      }
      if (root.containsKey("streckeoelen") && root["streckeoelen"].is<int>()) {
        StreckeOelen = root["streckeoelen"];
        EEPROM.updateInt(addrStreckeOelen, StreckeOelen);
        StreckeOelen = EEPROM.readInt(addrStreckeOelen);
        Serial.println("Setze streckeoelen");
      }
      if (root.containsKey("anzmagnete") && root["anzmagnete"].is<byte>()) {
        AnzMagnete = root["anzmagnete"];
        EEPROM.updateInt(addrAnzMagnete, AnzMagnete);
        AnzMagnete = EEPROM.readByte(addrAnzMagnete);
        Serial.println("Setze anzmagnete");
      }
      if (root.containsKey("pumpstoesse") && root["pumpstoesse"].is<byte>()) {
        Pumpstoesse = root["pumpstoesse"];
        EEPROM.updateByte(addrPumpstoesse, Pumpstoesse);
        Pumpstoesse = EEPROM.readByte(addrPumpstoesse);
        Serial.println("Setze pumpstoesse");
        }
        // Berechnen der Schmierintervalle neu
        AnzahlImpOelen = (StreckeOelen/Raddurchmesser)*AnzMagnete;
        Serial.println("Schmierintervalle neu berechnet");
    
    }
    
    // say what you got:
    Serial.println();
    Serial.print("command: ");
    Serial.println(command);
  }


  if (AnzahlImpOelen < ImpulsHallgeber) {
    detachInterrupt(digitalPinToInterrupt(HallsensorPin));        // Interrupt ausschalten
    
    // Pumpvorgang Starten
    for (int i=0; i<(Pumpstoesse); i++){
      digitalWrite(PumpePin, HIGH);  // Die Pumpe an PIN xxx wird eingeschaltet
      delay(245);  
      digitalWrite(PumpePin, LOW);  // Die Pumpe an PIN xxx wird ausgeschaltet  
      delay(125);
    }
    ImpulsHallgeber = 0 ;
    attachInterrupt(digitalPinToInterrupt(HallsensorPin), Hallsensor, RISING);    // Interrupt wieder einschalten.
    
  }


}                                            
// Ende Hauptprogramm -------------------------------------------------------------------------------------



// InterruptRoutine Hallsensor ------------------------------------------------------------------------
void Hallsensor() {                
detachInterrupt(digitalPinToInterrupt(HallsensorPin));          // Interrupt ausschalten

  ImpulsHallgeber = ImpulsHallgeber + 1 ;
  
attachInterrupt(digitalPinToInterrupt(HallsensorPin), Hallsensor, RISING);    // Interrupt wieder einschalten.

return;
}                                              
// ENDE  InterruptRoutine Hallsensor ------------------------------------------------------------------------------
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Serielle Eingabe zur Steuerung einer RGB-LED Tommy56 5 598 22.07.2016 18:32
Letzter Beitrag: Tommy56
  2 LEDs über serielle Schnittstelle steuern Bill 0 1.010 13.08.2015 16:04
Letzter Beitrag: Bill
  Arduino HC-SR04 Interrupt Lehmann84 11 3.548 24.04.2015 17:04
Letzter Beitrag: Thorsten Pferdekämper
  wieder mal serielle Kommunikation Rettungsmaus 12 2.807 15.10.2014 18:47
Letzter Beitrag: Rettungsmaus
Brick Kommunikation zwischen zwei Arduinos Neuwirth 7 4.071 05.12.2013 10:03
Letzter Beitrag: NoPeanut09
  Arduino steuert SPI EEPROM an milito 0 2.456 27.08.2013 20:26
Letzter Beitrag: milito

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste