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
Programme vom UNO auf nano , mini Pro portieren Probleme
15.04.2016, 16:10
Beitrag #1
Programme vom UNO auf nano , mini Pro portieren Probleme
Grüß euch,
Nur eine frage ;-)
Ich hab ein Programm, das funktioniert auf dem UNO problemlos!
Sobald ich das aber auf einem nano oder mini Pro hochlade geht nichts mehr ?

natürlich wähle ich die richtigen Boards aus, und es wird auch neu compiliert.

Gibts da Unterschiede auf die man achten muss ?

Es sind alles 328er mit 5V und der selben Speicherausstattung.
???????
lg
Andi
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.04.2016, 16:17 (Dieser Beitrag wurde zuletzt bearbeitet: 15.04.2016 16:18 von hotsystems.)
Beitrag #2
RE: Programme vom UNO auf nano , mini Pro portieren Probleme
(15.04.2016 16:10)anwo schrieb:  Ich hab ein Programm, das funktioniert auf dem UNO problemlos!
Sobald ich das aber auf einem nano oder mini Pro hochlade geht nichts mehr ?
Was geht nicht mehr?

Das hochladen oder der Sketch funktioniert nicht?
Ist auch die Frequenz und Spannung identisch?

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.04.2016, 16:18 (Dieser Beitrag wurde zuletzt bearbeitet: 15.04.2016 16:20 von Scheams.)
Beitrag #3
RE: Programme vom UNO auf nano , mini Pro portieren Probleme
Hallo!

Was ist die Fehlermeldung? Was ist dein Code?

(15.04.2016 16:17)hotsystems schrieb:  
(15.04.2016 16:10)anwo schrieb:  Ich hab ein Programm, das funktioniert auf dem UNO problemlos!
Sobald ich das aber auf einem nano oder mini Pro hochlade geht nichts mehr ?
Was geht nicht mehr?

Das hochladen oder der Sketch funktioniert nicht?
Ist auch die Frequenz und Spannung identisch?

Wenns am Uno läuft wird der sketch ok sein Tongue

lg Scheams
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.04.2016, 16:31
Beitrag #4
RE: Programme vom UNO auf nano , mini Pro portieren Probleme
(15.04.2016 16:10)anwo schrieb:  Gibts da Unterschiede auf die man achten muss ?

Sind mir keine bekannt...
außer dass du den Uno und Nano auch direkt über USB betreiben kannst, den ProMini nur über einen zusätzlichen Serial-USB-Wandler.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.04.2016, 16:35 (Dieser Beitrag wurde zuletzt bearbeitet: 15.04.2016 16:39 von anwo.)
Beitrag #5
RE: Programme vom UNO auf nano , mini Pro portieren Probleme
Sind alle mit 16mHz
Alle mit dem 328er
alle mit 5V
Ich kommuniziere via Jason mit dem Board.

Das funktioniert mit dem uno super.
Bis zu einer gewissen Programmversion geht das auch beim Pro mini 328P und dem nano.

Ich hab das Programm natürlich auf dem uno immer weiterentwickelt, und jetzt wo ich die Schaltung mit einem kleinen Pro mini aufbauen will geht das nicht, natürlich hab ich das dann auch noch mit dem nano probiert geht auch nicht.
Den sketch dann für den uno compiliert und hochgeladen geht Huh

Der geht nicht

Code:
/*
* --------------------------------------------------------------------------------------------------------------------------------
* --------------------------------------------------------------------------------------------------------------------------------
*
{"command":"vers"}
Antwort die Version der Software:
Serial.println("Version 4.05 Kettenöler Andreas Worresch");


Parameter zur Anpassung der Ölmenge

{"command":"setvalues","streckeoelen":2000, "pumpstoesse":8,"multiplikatorregen":0.7}
{"command":"getvalues"}
streckeoelen: in Meter,  nach zurücklegen dieser Strecke, wird ein Ölvorgang initiiert.
pumpstoesse: Die Anzahl der Pumphübe = Bestimmung der Ölmenge.
multiplikatorregen: Die “streckeoelen“ wird damit multipliziert, damit verändert sich die Strecke nach der ein Ölvorgang initiiert wird.

{"command":"regen"} wird gestartet mit diesem Kommando, wird es noch einmal gesendet, wird in den Standardmodus gewechselt
Wechsel in den Regen/Offroadmodus und zurück
Die streckeoelen wird mit dem multiplikatorregen multipliziert.



Setzen der Motorradspezifischen Basisdaten:

{"command":"setparam","raddurchmesser":2.156, "anzmagnete":3, "pumpean":245, "pumpeoff":125, "AnzPumpBeh":5000}
{"command":"getparam"}

raddurchmesser = Abrollumfang des Rades in Meter,
anzmagnete = Anzahl der Impulse z.B. Hallsensor/Reedkontakt je Radumdrehung,
pumpean = Zeit die die Pumpe für einen vollständigen Kolbenhub betötigt,
pumpeoff = die Spannungsfreihe Zeit, die notwendig ist, um den Kolben wieder in die Ruhelage zu bewegen, für den nächsten Hub,
AnzPumpBeh = ist dieAnzahl der Pumpvorgänge die notwendig ist, den Ölbehälter nahezu zu leeren, wird verwendet, um anzuzeigen, das Öl nachgefüllt werden muss.

Wartungsfunktionen:
{"command":"entluften"} wird gestartet mit diesem Kommando, wird es noch einmal gesendet, beendet es den Vorgang
Serial.print("Sub - entlüften   ");
Serial.println (ZaelerAnzPumpBeh);

Wenn das System erstmalig befüllt wird, oder oder ist es vollständig entleert, ist es notwendig zu entlüften.
Außerdem, kann dieser Befehl dazu genutzt werden, empirisch zu ermitteln wie viele Pumphübe notwendig sind,  
um den Ölbehälter zu leeren. Wird der Zählerwert als “ AnzPumpBeh“ gesetzt, wird er als Grenzwert für die Warnung Ölbehälter leer verwendet.
Könnte man gleich da in die App einbauen.

{"command":"gefullt"}
Wurde der Ölbehälter gefüllt, müssen die Zähler und Warnungen zurückgesetzt werden


{"command":"getzaeler"}
{"result":"getzaeler","ZaelerAnzPumpBeh":10, ImpulsHallgeber:400}
Liefert, die erkannten Impulse je Radumdrehung = ImpulsHallgeber,
Und die erfolgten Pumphübe = ZaelerAnzPumpBeh

Zum Debuggen kann man diese Zähler auch manuell setzen:

{"command":"setzaeler","ZaelerAnzPumpBeh":8888, "ImpulsHallgeber":5555}

*
*
*
* ---------------------------------------------------------------------------------------------------------------------------------
* ----------------------------------------------------------------------------------------------------------------------------------
*
* Kommando zum setzen der Werte:
* {"command":"setvalues","streckeoelen":2000, "pumpstoesse":8,"multiplikatorregen":0.7}
* {"command":"setvalues", "streckeoelen":3}
* streckeoelen in Meter
* Es müssen allerdings nicht alle Werte angegeben werden.
* Die tatsächlich übergebenen Werte werden gesetzt.
*
* Kommando zum holen der aktuellen Werte:
* {"command":"getvalues"}
* Result:
* {"result":"getvalues","streckeoelen":2000, "pumpstoesse":8,"multiplikatorregen":0.7}
* Es werden immer alle Werte geliefert.
*
*
*  
* Komando zum von Basiswerten für die Pumpe und dem Parameter für die Erhöhung des Schmierintervall
*  
* {"command":"setparam","raddurchmesser":2.156, "anzmagnete":1, "pumpean":75, "pumpeoff":100, "AnzPumpBeh":5000}
* {"command":"setparam","pumpean":50}
* {"command":"setparam","pumpeoff":100}
* Raddurchmesser und streckeoelen in Millimeter
* pumpeon/off im Milisekunden
*
* Kommando zum holen der aktuellen Werte:
* {"command":"getparam"}
* Result
* {"result":"getparam","raddurchmesser":4.444,"anzmagnete":2,"pumpean":333,"pumpeoff":222, "AnzPumpBeh":5000}
*
*
*
* Kommando zum Entlüften der Pumpe:
* {"command":"entluften"}
*
*  * Kommando zum Verringern der Schmierintervalle:
*  {"command":"regen"}
*
*
* Taster Pin 4 (PD4) --- startet Entlüften und Rücksetzen der Warnung Ölbehälter leer -- Pin auf Masse
* Taster Pin 7 (PD7) --- startet Regen/Offroadmodus -- Pin auf Masse
* Taster (Optokoppler) Pin 5 (PD5) --- Erkennung dass die Zündung ausgeschaltet wurde ein ist Pin auf Masse
* BattPin =  PIN 8 (PB0) für die Ansteuerung FET Batterie zuschalten ein ist HIGH
*
* Es fehlt noch die Ansteuerung von LED beim Taster
* PIN A0 == GRÜN == Schönwetter
* PIN A1 == GELB == Schlechtwetter Regen Offroad
* PIN A2 == Rot == Ölbehälter wird leer
*
  */

// eingebundene Libraries

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

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



// Deffinieren der Taster
#define BUTTON_Regen 7
#define BUTTON_Entluften 4
#define ON_OFF 5

// Instantiate a Bounce object
Bounce Regen = Bounce();
Bounce Entluften = Bounce();
Bounce SpannungON_OFF = Bounce();

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

// Variabe für Jason - serielle Kommunikation
float Raddurchmesser = 0;       // in Raddurchmesser in mm
int StreckeOelen = 0 ;          // in m  nach welcher gefahrenen Strecke soll geschmiert werden
byte AnzMagnete = 0 ;          // 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
byte Byte_MultiplikatorRegen = 0; // Variable für die Schnittstelle wird in Float umgewandelt
float MultiplikatorRegen = 0;   // Anzahl AnzahlImpOelen wird damit multipliziert um das Schmierintervall zu ändern, bei Regen Schlamm usw.
unsigned int pumpean = 0;               // default = 245 ms für das einschalten der Pumpe soll einen funktionierenden Pumpenhub ermöglichen
unsigned int pumpeoff = 0;               // default = 125 ms die sicherstellen sollen, das die Pumpe wieder in die Grundstellung komme Ausgeschaltet
unsigned int AnzPumpBeh = 0;           // Anzahl der Pumphübe, bis der Ölbehälter leer ist == konfigurierbar
unsigned int ZaelerAnzPumpBeh = 0;      // Zählt mit zum Vergleich mit AnzPumpBeh = Jene Anzahl von Pumpenhüben die notwendig ist, um den Ölbehälter zu leeren


// Batterie als Spannungsquelle zuschalten Ansteuerung FET über Optokoppler
byte BattPin = 8;         // Da ist der Optokopler - FET Angeschlossen
int StatusBattPin = LOW;  // Staus des Ausaganges für den FET - Anschluss Batterie

// LED PIN für den Taster
const byte GRUEN = A0;
const byte GELB = A1;
const byte ROT = A2;

// Berechnet
unsigned int AnzahlImpOelen = 0;         // Anzahl der Impulse vom Hallsensor bei der Erreichung, ein Ölintervall beginnt als Int
float def_Impulse = 0;            // Anzahl der Impulse Standartmäßig, bei der Erreichung, ein Ölintervall beginnt
float regen_Impulse = 0;          // Anzahl der Impulse bei Regen/Offroad usw., bei der Erreichung, ein Ölintervall beginnt

// Speicheradressen der Variablen für EEPROMx

int addrPumpstoesse = 1; // Byte
int addrAnzMagnete = 2;  //Byte
int addrStreckeOelen = 3; //Int
int addrRaddurchmesser = 5; // Float
int addrMultiplikatorRegen = 9; // Float
int addrPumpean = 13; // int
int addrPumpeoff = 15; // int
int addrImpulsHallgeber = 17; //int
int addrAnzPumpBeh = 19; // int
int addrZaelerAnzPumpBeh = 21; //int

// Funktionen
bool entluft = false;   // Schalter um entlüften ein oder auszuschalten
bool regenen = false;   // Schalter zum verkürzen des Schmierintervall
byte a = 0; // Hilfsvariable für den Taster Regenmodus
// --------------------------------------------------------------------------------------------------------------------------

void setup() {

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

    
  // 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

  // Konfiguration Zuschaltung Batterie über Optokoppler - FET
  pinMode (BattPin, OUTPUT);
  digitalWrite(BattPin, LOW);   // der Optokoppler ist angesteuert, und die Batterie zugeschaltet, zusätzlich zum Zündschloss

  // Konfiguration der LED Ausgänge
  pinMode (GRUEN, OUTPUT);
  digitalWrite(GRUEN, HIGH); // Schönwetter
  pinMode (GELB, OUTPUT);
  digitalWrite(GELB, LOW); // Offroad - Schlechtwetter
  pinMode (ROT, OUTPUT);
  digitalWrite(ROT, LOW); // Ölbehälter leer
  
        
// Interrupt konfigurieren
// Interrupt 0 auf Routine Hallsensor setzen  reagiert auf sinkende Flanken an HallsensorPin
  attachInterrupt(digitalPinToInterrupt(HallsensorPin), Hallsensor, RISING);



// Einlesen der Variablen aus dem EEPROM
waitUntilReady();
Raddurchmesser = EEPROM.readFloat(addrRaddurchmesser);
waitUntilReady();
StreckeOelen = EEPROM.readInt(addrStreckeOelen);        
waitUntilReady();
AnzMagnete = EEPROM.readByte(addrAnzMagnete);                
waitUntilReady();
Pumpstoesse = EEPROM.readByte(addrPumpstoesse);
waitUntilReady();
MultiplikatorRegen = EEPROM.readFloat(addrMultiplikatorRegen);
waitUntilReady();
pumpean = EEPROM.readInt(addrPumpean);
waitUntilReady();
pumpeoff = EEPROM.readInt(addrPumpeoff);
waitUntilReady();
ImpulsHallgeber = EEPROM.readInt(addrImpulsHallgeber);
waitUntilReady();
AnzPumpBeh = EEPROM.readInt(addrAnzPumpBeh);
waitUntilReady();
ZaelerAnzPumpBeh = EEPROM.readInt(addrZaelerAnzPumpBeh);
Serial.print(" ZaelerAnzPumpBeh   ");
Serial.println(ZaelerAnzPumpBeh);
Serial.print("ImpulsHallgeber   ");
Serial.println(addrImpulsHallgeber);

// Berechnen der Schmierintervalle default gutes Wetter kein Offroad oder Regen ;-)

AnzahlImpOelen = (StreckeOelen/Raddurchmesser)*AnzMagnete;
AnzahlImpOelen = (int)AnzahlImpOelen; // Umwandlung in int Nachkommerstellen gehen verloren

// Setup the  button with an internal pull-up :
pinMode(BUTTON_Regen,INPUT_PULLUP);
pinMode(BUTTON_Entluften,INPUT_PULLUP);
pinMode(ON_OFF,INPUT_PULLUP);   // Zündung ein oder aus, wird hier überwacht
pinMode(BattPin,OUTPUT);     // Spannungsversorgung über die Batterie wird hiermit ein und ausgeschaltet
digitalWrite(BattPin,LOW);   // Normalzustand de FET zur Verbindung zu Batt ist deaktiviert, erst wenn die Zündung eingeschaltet wird, wird der Bypass aktiviert, und erst wieder deaktiviert, wenn nach abschalten der Zündung die Zählergespeichert sind.

// After setting up the button, setup the Bounce instance :
Regen.attach(BUTTON_Regen); // nicht nur via Bluetooth kann der Modus geändert werden
Regen.interval(100); // interval in ms

Entluften.attach(BUTTON_Entluften); // nicht nur via Bluetooth kann der Modus geändert werden
Entluften.interval(100); // interval in ms

SpannungON_OFF.attach(ON_OFF); // das Abschalten der Zündung = Off Kettenöler mittels Bounce erkennen
SpannungON_OFF.interval(500); // interval in ms

}                                                      



// Hauptprogramm --------------------------------------------------------------{"command":"setvalues", "streckeoelen":3}---------------------------------
void loop() {  
// Update the Bounce instances :
    Regen.update();
    Entluften.update();
    SpannungON_OFF.update();

// Entlüften aus und einschalten ---  BUTTON_Entluften 4
    if ( Entluften.fell() ) {
            entluft = !entluft;
            ZaelerAnzPumpBeh = 0;
            EEPROM.updateInt(addrZaelerAnzPumpBeh, ZaelerAnzPumpBeh); // Zähler zurücksetzen, da ich davon ausgehe, das beim Entlüften, der Ölbehälter auch gefüllt wird.
            digitalWrite(ROT, LOW); // Ölbehälter leer
            Serial.println("Warnung Ölbehälterfüllstand zurückgesetzt");
       }
      // Funktion entlüften
      if (entluft == true) { pumpen(); }

// Regenmodus ein und aus -- BUTTON_Regen 7
     if ( Regen.fell() ) {
        a = a+1;
        if (a == 1) { schmierintervall_regen();
          
                    }
        if (a == 2) { schmierintervall();
          // AnzahlImpOelen = def_Impulse;
          a = 0;
                     }
         }

  // Get the updated value, Zündung ein oder aus --- BUTTUN 5
    int Status_Zundung = SpannungON_OFF.read();
    StatusBattPin = digitalRead(BattPin);
    if (Status_Zundung == LOW && StatusBattPin == LOW) digitalWrite(BattPin, HIGH);
  

  // Erkennen, ob die Zündung ausgeschaltet wurde -- Taster (Optokoppler) Pin 5 (PD5)  
  // Maßnahmen beim Ausschalten der Zündung, Speichern + Ausschalten-------------
    if ( Status_Zundung == HIGH && StatusBattPin == HIGH) {                    // Status Zündung geht aus HIGH wenn die Zündung abgeschaltet wird. Externe Schaltung mittels Optokoppler
         Serial.println("Aus speichern + off");
         detachInterrupt(digitalPinToInterrupt(HallsensorPin));        // Interrupt ausschalten
         waitUntilReady();
          EEPROM.updateInt(addrImpulsHallgeber, ImpulsHallgeber);  // mit diesem Zähler wird ermittelt ob die Strecke bis zum nächsten Ölinterfall zurückgelegt wird. Damit nicht jedesmal mit 0 begonnen wird, wird er gespeichert.
          ImpulsHallgeber = EEPROM.readInt(addrImpulsHallgeber);
          ImpulsHallgeber = 0; // zum Testen um zu sehen, ob der Zähler wirklich weggeschrieben wird
          Serial.print("AUS - ImpulsHallgeber =  ");
          Serial.println(ImpulsHallgeber);
           waitUntilReady();
          EEPROM.updateInt(addrZaelerAnzPumpBeh, ZaelerAnzPumpBeh); // über diesen Zähler wird festgestellt, ob der Ölbehälter leer ist
          waitUntilReady();
          ZaelerAnzPumpBeh = 0; // zum Testen um zu sehen, ob der Zähler wirklich weggeschrieben wird
          ZaelerAnzPumpBeh = EEPROM.readInt(addrZaelerAnzPumpBeh);
          waitUntilReady();
          Serial.print("AUS - ZaelerAnzPumpBeh = ");
          Serial.println(ZaelerAnzPumpBeh);
          digitalWrite(BattPin, LOW);   // der Letzte schaltet das Licht ab ;-) -- Der FET zur Batterie wird abgeschaltet
          
          }

  // 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")) {
        entluft = !entluft;
        }

     // Beispiel: {"command":"regen"}
    else if (command.equals("regen")) {
          regenen = !regenen;
          if (regenen == false) schmierintervall();
          if (regenen == true) schmierintervall_regen();
         }
    // Beispiel: {"command":"gefullt"}
    else if (command.equals("gefullt")) {
          ZaelerAnzPumpBeh = 0;
          EEPROM.updateInt(addrZaelerAnzPumpBeh, ZaelerAnzPumpBeh);
          digitalWrite(ROT, LOW); // Ölbehälter leer
          Serial.println("Ölbehälterfüllstand zurückgesetzt");
         }
    // Beispiel: {"command":"vers"}
    else if (command.equals("vers")) {
          Serial.println("4.05 Kettenöler AnWo");
         }
    else if (command.equals("getzaeler"))
        {
      // Werte als Json zurückliefern ...
       // Beispiel: {"command":"getzaeler"}
      // Result neu : {"result":"getzaeler","ZaelerAnzPumpBeh":10, ImpulsHallgeber:400}
      StaticJsonBuffer<200> jsonOutBuffer;
      JsonObject& root = jsonBuffer.createObject();
      root["result"] = "getzaeler";
      root["ZaelerAnzPumpBeh"] = ZaelerAnzPumpBeh;
      root["ImpulsHallgeber"] = ImpulsHallgeber;
      root.printTo(Serial);
       }
else if (command.equals("setzaeler"))
    {
      // Beispiel: {"command":"setzaeler","ZaelerAnzPumpBeh":8888, "ImpulsHallgeber":5555}
        
        if (root.containsKey("ZaelerAnzPumpBeh") && root["ZaelerAnzPumpBeh"].is<int>()) {
        ZaelerAnzPumpBeh = root["ZaelerAnzPumpBeh"];
        waitUntilReady();
        EEPROM.updateInt(addrZaelerAnzPumpBeh, ZaelerAnzPumpBeh);
        waitUntilReady();
        ZaelerAnzPumpBeh = EEPROM.readInt(addrZaelerAnzPumpBeh);
      
        Serial.print("Setze ZaelerAnzPumpBeh: ");
        Serial.println(ZaelerAnzPumpBeh);
           }
        if (root.containsKey("ImpulsHallgeber") && root["ImpulsHallgeber"].is<int>()) {
        ImpulsHallgeber = root["ImpulsHallgeber"];
        waitUntilReady();
         EEPROM.updateInt(addrImpulsHallgeber, ImpulsHallgeber);
        waitUntilReady();
        ImpulsHallgeber = EEPROM.readInt(addrImpulsHallgeber);
        Serial.print("Setze ImpulsHallgeber: ");
        Serial.println(ImpulsHallgeber);
           }
    
      }
    
    else if (command.equals("getvalues"))
    {
      // Werte als Json zurückliefern ...
       // Beispiel: {"command":"getvalues"}
      // Result neu : {"result":"getvalues","streckeoelen":3000, "pumpstoesse":7,"multiplikatorregen":50}
      StaticJsonBuffer<200> jsonOutBuffer;
      JsonObject& root = jsonBuffer.createObject();
      root["result"] = "getvalues";
      root["streckeoelen"] = StreckeOelen;
      root["pumpstoesse"] = Pumpstoesse;
      root["multiplikatorregen"] = MultiplikatorRegen;
      root.printTo(Serial);
      
     }
    else if (command.equals("setvalues"))
    {
      // Beispiel: {"command":"setvalues","streckeoelen":3000,"pumpstoesse":7,"multiplikatorregen":50}
        
        if (root.containsKey("streckeoelen") && root["streckeoelen"].is<int>()) {
        StreckeOelen = root["streckeoelen"];
        waitUntilReady();
        EEPROM.updateInt(addrStreckeOelen, StreckeOelen);
        waitUntilReady();
        StreckeOelen = EEPROM.readInt(addrStreckeOelen);
        Serial.println("Setze streckeoelen: ");
           }
      
      if (root.containsKey("pumpstoesse") && root["pumpstoesse"].is<byte>()) {
        Pumpstoesse = root["pumpstoesse"];
        waitUntilReady();
        EEPROM.updateByte(addrPumpstoesse, Pumpstoesse);
        waitUntilReady();
        Pumpstoesse = EEPROM.readByte(addrPumpstoesse);
        Serial.println("Setze pumpstoesse");
        }
        
        if (root.containsKey("multiplikatorregen") && root["multiplikatorregen"].is<float>()) {
       MultiplikatorRegen = root["multiplikatorregen"];
        waitUntilReady();
        EEPROM.updateFloat(addrMultiplikatorRegen, MultiplikatorRegen);
        waitUntilReady();
        MultiplikatorRegen = EEPROM.readFloat(addrMultiplikatorRegen);
        Serial.println("Setze MultiplikatorRegen");
         }
        
     }
     else if (command.equals("getparam"))
      {
      // Werte als Json zurückliefern ...  
      // Beispiel: {"command":"getparam"}
      // Result: {"result":"getparam","raddurchmesser":2.156, "anzmagnete":3, "pumpeoff":245, "pumpeoff":125, "AnzPumpBeh":5000}
      StaticJsonBuffer<200> jsonOutBuffer;
      JsonObject& root = jsonBuffer.createObject();
      root["result"] = "getparam";
      root["raddurchmesser"].set(Raddurchmesser, 3);
      root["anzmagnete"] = AnzMagnete;      
      root["pumpean"] = pumpean;
      root["pumpeoff"] = pumpeoff;
      root["AnzPumpBeh"] = AnzPumpBeh; // Jene Anzahl von Pumpenhüben die Notwendig ist, um den Ölbehälter zu leeren
      root.printTo(Serial);
      }
              
      else if (command.equals("setparam"))  {
        // Beispiel: {"command":"setparam","raddurchmesser":2.156, "anzmagnete":3, "pumpean":245, "pumpeoff":125, "AnzPumpBeh":5000}
      if (root.containsKey("raddurchmesser") && root["raddurchmesser"].is<float>()) {
        Raddurchmesser = root["raddurchmesser"];
        waitUntilReady();
        EEPROM.updateFloat(addrRaddurchmesser, Raddurchmesser);
        waitUntilReady();
        Raddurchmesser = EEPROM.readFloat(addrRaddurchmesser);
        Serial.println("Setze raddurchmesser");
        }
       if (root.containsKey("anzmagnete") && root["anzmagnete"].is<byte>()) {
        AnzMagnete = root["anzmagnete"];
        waitUntilReady();
        EEPROM.updateByte(addrAnzMagnete, AnzMagnete);
        waitUntilReady();
        AnzMagnete = EEPROM.readByte(addrAnzMagnete);
        Serial.println("Setze anzmagnete");
        }
       if (root.containsKey("pumpean") && root["pumpean"].is<int>()) {
        pumpean = root["pumpean"];
        waitUntilReady();
        EEPROM.updateInt(addrPumpean, pumpean);
        waitUntilReady();
        pumpean = EEPROM.readInt(addrPumpean);
        Serial.println("Setze pumpean");
        }
       if (root.containsKey("pumpeoff") && root["pumpeoff"].is<int>()) {
        pumpeoff = root["pumpeoff"];
        waitUntilReady();
        EEPROM.updateInt(addrPumpeoff, pumpeoff);
        waitUntilReady();
        pumpeoff = EEPROM.readInt(addrPumpeoff);
        Serial.println("Setze pumpeoff");
        }
        if (root.containsKey("AnzPumpBeh") && root["AnzPumpBeh"].is<int>()) {
        AnzPumpBeh = root["AnzPumpBeh"];          // Jene Anzahl von Pumpenhüben die notwendig ist, um den Ölbehälter zu leeren
        waitUntilReady();
        EEPROM.updateInt(addrAnzPumpBeh, AnzPumpBeh); // Jene Anzahl von Pumpenhüben die Notwendig ist, um den Ölbehälter zu leeren
        waitUntilReady();
        AnzPumpBeh = EEPROM.readInt(addrAnzPumpBeh); // Jene Anzahl von Pumpenhüben die Notwendig ist, um den Ölbehälter zu leeren
        Serial.println("Setze AnzPumpBeh");
        }

      
         // Berechnen der Schmierintervalle neu
        schmierintervall();
       }
      
      // 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++){
      ZaelerAnzPumpBeh = ZaelerAnzPumpBeh+1;
      digitalWrite(PumpePin, HIGH);  // Die Pumpe an PIN xxx wird eingeschaltet
      delay(pumpean);  
      digitalWrite(PumpePin, LOW);  // Die Pumpe an PIN xxx wird ausgeschaltet  
      delay(pumpeoff);
      if (ZaelerAnzPumpBeh > AnzPumpBeh ) {     // Jene Anzahl von Pumpenhüben die notwendig ist, um den Ölbehälter zu leeren
        digitalWrite(GRUEN, LOW); // Schönwetter
        digitalWrite(GELB, LOW); // Offroad - Schlechtwetter
        digitalWrite(ROT, HIGH); // Ölbehälter leer
      }
            
    }
    ImpulsHallgeber = 0 ;
    attachInterrupt(digitalPinToInterrupt(HallsensorPin), Hallsensor, RISING);    // Interrupt wieder einschalten.
    
    }


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


// ----------- Überprüfung, ob des EEPROM für einen Schreib/lesevorgang bereit ist ---------------------------
void waitUntilReady() {

  while(!EEPROM.isReady()) { delay(1); }
  
}
// ---Ende der Überprüfung --------------------------------------------------------------------------------

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

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

return;
}                                              
// ENDE  InterruptRoutine Hallsensor ------------------------------------------------------------------------------

// Sub - entlüften ----------------------------------------------------------------
void pumpen() {
Serial.print("Sub - entlüften   ");
Serial.println (ZaelerAnzPumpBeh);
digitalWrite(PumpePin, HIGH);  // Die Pumpe an PIN xxx wird eingeschaltet
delay(pumpean);  
digitalWrite(PumpePin, LOW);  // Die Pumpe an PIN xxx wird ausgeschaltet  
delay(pumpeoff);
ZaelerAnzPumpBeh = ZaelerAnzPumpBeh+1;
return;
}  

// ENDE -- Sub - entlüften ---------------------------------------------------------


// Berechnen Schmierintervall ----------------------------------------------------------
void schmierintervall() {

AnzahlImpOelen = (StreckeOelen/Raddurchmesser)*AnzMagnete;
AnzahlImpOelen = (int)AnzahlImpOelen; // Umwandlung in int Nachkommerstellen gehen verloren

digitalWrite(GRUEN, HIGH); // Schönwetter
digitalWrite(GELB, LOW); // Offroad - Schlechtwetter
Serial.print("Schönwetter Imluse bis zum Ölen = ");
Serial.println(AnzahlImpOelen);
return;
}
// END --Berechnen Schmierintervall -----------------------------------------------------+

// Berechnen Schmierintervall Schlechtwetter ----------------------------------------------------------
void schmierintervall_regen() {

AnzahlImpOelen = (StreckeOelen/Raddurchmesser)*AnzMagnete*MultiplikatorRegen;
AnzahlImpOelen = (int)AnzahlImpOelen; // Umwandlung in int Nachkommerstellen gehen verloren
  
digitalWrite(GRUEN, LOW); // Schönwetter
digitalWrite(GELB, HIGH); // Offroad - Schlechtwetter
Serial.print("SSchlechtwetter Imluse bis zum Ölen = ");
Serial.println(AnzahlImpOelen);
return;
}
// END --Berechnen Schmierintervall Schlechtwetter-----------------------------------------------------

der geht noch auf allen boards
Code:
/*
*
*
* Kommando zum setzen der Werte:
* {"command":"setvalues", "raddurchmesser":1.478, "streckeoelen":1235, "pumpstoesse":4}
* {"command":"setvalues", "streckeoelen":3}
* Es müssen allerdings nicht alle Werte angegeben werden.
* Die tatsächlich übergebenen Werte werden gesetzt.
*
*  
* Komando zum von Basiswerten für die Pumpe und dem Parameter für die Erhöhung des Schmierintervall
* {"command":"setparam", "pumpean":245, "pumpeoff":125, "multiplikatorregen":0.5}
*
* Kommando zum holen der aktuellen Werte:
* {"command":"getparam"}
* Result
* {"result":"setparam", "pumpean":245, "pumpeoff":125, "multiplikatorregen":0.5}
*
*
* Kommando zum holen der aktuellen Werte:
* {"command":"getvalues"}
* {"command":"getvalues", "values":["raddurchmesser","streckeoelen"]}
* Result:
* {"result":"raddurchmesser":0.789, "streckeoelen":2345, "anzmagnete":1, "pumpstoesse":4, "multiplikatorregen":0,5}
* Es werden immer alle Werte geliefert.
*
* Kommando zum Entlüften der Pumpe:
* {"command":"entluften"}
*
*  * Kommando zum Verringern der Schmierintervalle:
*  {"command":"regen"}
*
*
*
* 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 = 0 ;          // 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
float MultiplikatorRegen = 0;   // Anzahl AnzahlImpOelen wird damit multipliziert um das Schmierintervall zu ändern, bei Regen Schlamm usw.
int pumpean = 0;               // default = 245 ms für das einschalten der Pumpe soll einen funktionierenden Pumpenhub ermöglichen
int pumpeoff =0;               // default = 125 ms die sicherstellen sollen, das die Pumpe wieder in die Grundstellung komme Ausgeschaltet


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


// Speicheradressen der Variablen für EEPROMx
int addrPumpstoesse = 1;
int addrAnzMagnete = 2;
int addrStreckeOelen = 3;
int addrRaddurchmesser = 7;
int addrMultiplikatorRegen = 11;
int addrPumpean = 15;
int addrPumpeoff =17;

// Funktionen
bool entluft = false;   // Schalter um entlüften ein oder auszuschalten
bool regenen = false;   // Schalter zum verkürzen des Schmierintervall
// --------------------------------------------------------------------------------------------------------------------------

void setup() {

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

  // 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);



// Einlesen der Variablen aus dem EEPROM
waitUntilReady();
Raddurchmesser = EEPROM.readFloat(addrRaddurchmesser);      
waitUntilReady();
StreckeOelen = EEPROM.readInt(addrStreckeOelen);        
waitUntilReady();
AnzMagnete = EEPROM.readByte(addrAnzMagnete);                
waitUntilReady();
Pumpstoesse = EEPROM.readByte(addrPumpstoesse);
waitUntilReady();
MultiplikatorRegen = EEPROM.readFloat(addrMultiplikatorRegen);
waitUntilReady();
pumpean = EEPROM.readInt(addrPumpean);
waitUntilReady();
pumpeoff = EEPROM.readInt(addrPumpeoff);




// Berechnen der Schmierintervalle default gutes Wetter kein Offroad oder Regen ;-)
AnzahlImpOelen = (StreckeOelen/Raddurchmesser)*AnzMagnete;
}                                                      



// Hauptprogramm --------------------------------------------------------------{"command":"setvalues", "streckeoelen":3}---------------------------------
void loop() {  
  
  
  // Funktion entlüften
  if (entluft == true) { pumpen(); }

  // 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")) entluft = !entluft;

     // Beispiel: {"command":"regen"}
    else if (command.equals("regen")) {
          regenen = !regenen;
          if (regenen == false) schmierintervall();
          if (regenen == true) {
            AnzahlImpOelen = AnzahlImpOelen*MultiplikatorRegen;
            Serial.println("Schmierintervalle mit MultiplikatorRegen multipliziert");
              }
    
            }
      
    else if (command.equals("getvalues"))
    {
      // Werte als Json zurückliefern ...
      // Beispiel: {"command":"getvalues"}
      // Result: {"result":"getvalues", "raddurchmesser":2.156, "streckeoelen":10, "pumpstoesse":5,}
      StaticJsonBuffer<200> jsonOutBuffer;
      root["raddurchmesser"].set(Raddurchmesser,3);
      JsonObject& root = jsonBuffer.createObject();
      root["result"] = "getvalues";
      root["raddurchmesser"].set(Raddurchmesser, 3);
      root["streckeoelen"] = StreckeOelen;
      root["pumpstoesse"] = Pumpstoesse;
      root.printTo(Serial);
      
     }
    else if (command.equals("setvalues"))
    {
      // Beispiel: {"command":"setvalues", "raddurchmesser":2.156, "streckeoelen":10, "pumpstoesse":5,}
      if (root.containsKey("raddurchmesser") && root["raddurchmesser"].is<float>()) {
        Raddurchmesser = root["raddurchmesser"];
        waitUntilReady();
        EEPROM.updateFloat(addrRaddurchmesser, Raddurchmesser);
        waitUntilReady();
        Raddurchmesser = EEPROM.readFloat(addrRaddurchmesser);
        Serial.println("Setze raddurchmesser");
      }
      if (root.containsKey("streckeoelen") && root["streckeoelen"].is<int>()) {
        StreckeOelen = root["streckeoelen"];
        waitUntilReady();
        EEPROM.updateInt(addrStreckeOelen, StreckeOelen);
        waitUntilReady();
        StreckeOelen = EEPROM.readInt(addrStreckeOelen);
        Serial.println("Setze streckeoelen: ");
           }
      
      if (root.containsKey("pumpstoesse") && root["pumpstoesse"].is<byte>()) {
        Pumpstoesse = root["pumpstoesse"];
        waitUntilReady();
        EEPROM.updateByte(addrPumpstoesse, Pumpstoesse);
        waitUntilReady();
        Pumpstoesse = EEPROM.readByte(addrPumpstoesse);
        Serial.println("Setze pumpstoesse");
        }
        // Berechnen der Schmierintervalle neu
        schmierintervall();
            
    }
     else if (command.equals("getparam"))
      {
      // Werte als Json zurückliefern ...
      // Beispiel: {"command":"getparam"}
      // Result: {"result":"setparam", "pumpean":245, "pumpeoff":125, "anzmagnete":3, "multiplikatorregen":0.5}
      StaticJsonBuffer<200> jsonOutBuffer;
      JsonObject& root = jsonBuffer.createObject();
      root["result"] = "getparam";
      root["multiplikatorregen"] = MultiplikatorRegen;
      root["pumpean"] = pumpean;
      root["pumpeoff"] = pumpeoff;
      root["anzmagnete"] = AnzMagnete;
      root.printTo(Serial);
      }
              
      else if (command.equals("setparam"))  {
        // Beispiel: {"command":"setparam", "pumpean":245, "pumpeoff":125, "anzmagnete":3, "multiplikatorregen":0.5}
        if (root.containsKey("multiplikatorregen") && root["multiplikatorregen"].is<float>()) {
        MultiplikatorRegen = root["multiplikatorregen"];
        waitUntilReady();
        EEPROM.updateFloat(addrMultiplikatorRegen, MultiplikatorRegen);
        waitUntilReady();
        MultiplikatorRegen = EEPROM.readFloat(addrMultiplikatorRegen);
        Serial.println("Setze MultiplikatorRegen");
         }
        if (root.containsKey("pumpean") && root["pumpean"].is<int>()) {
        pumpean = root["pumpean"];
        waitUntilReady();
        EEPROM.updateInt(addrPumpean, pumpean);
        waitUntilReady();
        pumpean = EEPROM.readInt(addrPumpean);
        Serial.println("Setze pumpean");
        }
        if (root.containsKey("pumpeoff") && root["pumpeoff"].is<int>()) {
        pumpeoff = root["pumpeoff"];
        waitUntilReady();
        EEPROM.updateInt(addrPumpeoff, pumpeoff);
        waitUntilReady();
        pumpeoff = EEPROM.readInt(addrPumpeoff);
        Serial.println("Setze pumpeoff");
        }
        if (root.containsKey("anzmagnete") && root["anzmagnete"].is<byte>()) {
        AnzMagnete = root["anzmagnete"];
        waitUntilReady();
        EEPROM.updateByte(addrAnzMagnete, AnzMagnete);
        waitUntilReady();
        AnzMagnete = EEPROM.readByte(addrAnzMagnete);
        Serial.println("Setze anzmagnete");
        }
       }
      
      // 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(pumpean);  
      digitalWrite(PumpePin, LOW);  // Die Pumpe an PIN xxx wird ausgeschaltet  
      delay(pumpeoff);
      
    }
    ImpulsHallgeber = 0 ;
    attachInterrupt(digitalPinToInterrupt(HallsensorPin), Hallsensor, RISING);    // Interrupt wieder einschalten.
    
    }


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

void waitUntilReady() {

  while(!EEPROM.isReady()) { delay(1); }
  
}

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

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

return;
}                                              
// ENDE  InterruptRoutine Hallsensor ------------------------------------------------------------------------------

// Sub - entlüften ----------------------------------------------------------------
void pumpen() {
Serial.println("Sub - entlüften");
digitalWrite(PumpePin, HIGH);  // Die Pumpe an PIN xxx wird eingeschaltet
digitalWrite(13, HIGH);
delay(pumpean);  
digitalWrite(PumpePin, LOW);  // Die Pumpe an PIN xxx wird ausgeschaltet  
digitalWrite(13, LOW);
delay(pumpeoff);
return;
}  

// ENDE -- Sub - entlüften ---------------------------------------------------------


// Berechnen Schmierintervall ----------------------------------------------------------
void schmierintervall() {
AnzahlImpOelen = (StreckeOelen/Raddurchmesser)*AnzMagnete*MultiplikatorRegen;
Serial.println("Schmierintervalle neu berechnet");
return;
}
// END --Berechnen Schmierintervall -----------------------------------------------------
[/code]



[/code]
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.04.2016, 16:43
Beitrag #6
RE: Programme vom UNO auf nano , mini Pro portieren Probleme
Gibt es denn irgend eine Meldung beim Kompilieren?

Ich vermute, der Speicher wird knapp.

Der Nano und ProMini hat bedingt durch einen anderen Bootloader weniger Speicher (Flash) zur Verfügung.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.04.2016, 16:49 (Dieser Beitrag wurde zuletzt bearbeitet: 15.04.2016 16:49 von anwo.)
Beitrag #7
RE: Programme vom UNO auf nano , mini Pro portieren Probleme
(15.04.2016 16:43)hotsystems schrieb:  Gibt es denn irgend eine Meldung beim Kompilieren?

Ich vermute, der Speicher wird knapp.

Der Nano und ProMini hat bedingt durch einen anderen Bootloader weniger Speicher (Flash) zur Verfügung.

Das könnte es sein, ich hab sowas auch schon befürchtet Confused
Nein es gibt beim compilieren kein Fehlermeldung.
Wo kann ich mit einer Speicheroptimierung beginnen ?
Ich bin da ein wenig unbedarft, das ist mein 2tes Projekt, und Erfahrung im Programmieren hab ich auch nicht gerade Blush

Wenn ich für den Pro mini compiliere bekomme ich folgende Meldung
Sketch uses 17,970 bytes (58%) of program storage space. Maximum is 30,720 bytes.
Global variables use 1,183 bytes (57%) of dynamic memory, leaving 865 bytes for local variables. Maximum is 2,048 bytes.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.04.2016, 16:55
Beitrag #8
RE: Programme vom UNO auf nano , mini Pro portieren Probleme
Das sieht aber gut aus. Der Speicher ist nicht das Problem. Ich habe einen Sketch mit ca. 24.000 Bytes auf dem ProMini laufen.

Du hast aber noch nicht geschrieben, ob sich der Sketch nicht hochladen (auf Nano und ProMini) lässt, oder einfach nicht funktioniert.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Unterschiedliche Programme durch Switch/ Case SpeedShifter 26 604 04.10.2016 15:29
Letzter Beitrag: SpeedShifter
  ArduinoDroid Probleme Brother Tak 1 199 10.09.2016 22:12
Letzter Beitrag: Brother Tak
  Arduino Nano --> ATtiny 84A Mathias 25 886 15.07.2016 16:26
Letzter Beitrag: hotsystems
  Roboter-Bau Probleme blebbens 8 374 12.07.2016 07:35
Letzter Beitrag: Binatone
  Probleme mit sprintf() und dtostrf() GMBU 11 799 22.06.2016 10:52
Letzter Beitrag: GMBU
  Makeblock mit Scratch programmieren- Probleme Keinen Schimmer 6 948 06.05.2016 18:34
Letzter Beitrag: arduinopeter
  Programme lassen sich nicht auf das Gemma Board downloaden! Jack Sparrow 13 562 08.04.2016 10:01
Letzter Beitrag: hotsystems
  Probleme beim Auslesen eines IR Empfängers linuxpaul 7 571 06.03.2016 14:44
Letzter Beitrag: hotsystems
  I²C vom NANO zum PI Probleme mit High/Low Bit Tobias1984 4 328 29.02.2016 00:00
Letzter Beitrag: hotsystems
  Probleme beim auswählen des Ports Levi 11 817 21.02.2016 18:00
Letzter Beitrag: hotsystems

Gehe zu:


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