Arduino Modbus Light fade, Licht faden.

power-dodge · February 10, 2018, 7:12am

Hallo,

ich wollte hier mal im neuen Beitrag das fertige Projekt vorstellen.
Bei diesem hat mir ein Mitglied hier aus dem Forum geholfen.
Oder besser gesagt das wichtigste hat er gemacht, dafür bin
ich Ihn sehr dankbar!

In diesem Projekt wollte ich quasi die Beleuchtung steuern über
IP-Symcon. Dabei aber auch Sensorwerte zu dem Server übermitteln.

Einen Langzeittest habe ich leider noch nicht machen können.

Das alte Thema fing hier an:
Klick

Besonderen Dank an Agmue für die Hilfe!

#include <SPI.h>
#include <Ethernet.h>

#include "Mudbus.h"

// getestet mit Mega2560
const byte ausgaenge[] = {2, 3, 4, 5, 6, 7, 8, 9, 45, 11, 12, 13};
const byte PWM = sizeof(ausgaenge);
const byte R[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; // Indexwerte fuer Mb.R[]
int8_t fadeAmount[PWM];    // how many points to fade the LED by
unsigned long currentTime;
unsigned long loopTime;
int brightness[PWM], altModbuswert[PWM], aktModbuswert[PWM];

int sensorwert; // LM35 Temperatur auslesen.
int temperatur = 0; //Unter d

Mudbus Mb;
//Function codes 1(read coils), 3(read registers), 5(write coil), 6(write register)
//signed int Mb.R[0 to 125] and bool Mb.C[0 to 128] MB_N_R MB_N_C
//Port 502 (defined in Mudbus.h) MB_PORT

void setup()
{
  Serial.begin(9600);
  Serial.println(F("Programmstart"));
  for (byte ausgang = 0; ausgang < PWM; ausgang++)
  {
    fadeAmount[ausgang] = 5;
    brightness[ausgang] = 255;    // Anfangswert "aus"
    altModbuswert[ausgang] = 255; // Anfangswert "aus"
    aktModbuswert[ausgang] = 255; // Anfangswert "aus"
  }
  currentTime = millis();
  loopTime = currentTime;

  uint8_t mac[]     = { 0x90, 0xA2, 0xDA, 0x00, 0x51, 0x06 };
  uint8_t ip[]      = { 192, 168, 178, 70 };
  uint8_t gateway[] = { 192, 168, 178, 1 };
  uint8_t subnet[]  = { 255, 255, 255, 0 };
  Ethernet.begin(mac, ip, gateway, subnet);


  //PWM Frequenz
  //0×01  1      31.374 KHz
  //0×02  8      3.921 Khz
  //0×03  64     490.1 Hz            // default
  //0×04  256    122.5 Hz
  //0×05  1024   30.63 Hz
  //http://playground.arduino.cc/Main/TimerPWMCheatsheet

  TCCR1A = (TCCR1A & 0xF8) | 0x01;
  TCCR0A = (TCCR0A & 0xF8) | 0x01;
  TCCR0B = (TCCR0B & 0xF8) | 0x01;
  TCCR2B = (TCCR2B & 0xF8) | 0x01;
}

void loop()
{
  Mb.Run();
  currentTime = millis();
  //PWM Ausgänge:
  for (byte ausgang = 0; ausgang < PWM; ausgang++)
  {
    altModbuswert[ausgang] = aktModbuswert[ausgang];
    aktModbuswert[ausgang] = Mb.R[R[ausgang]];
    if (altModbuswert[ausgang] != aktModbuswert[ausgang])
    {
      if (brightness[ausgang] < aktModbuswert[ausgang]) {
        fadeAmount[ausgang] = 5;
      } else {
        fadeAmount[ausgang] = -5;
      }
    }
  }
  if (currentTime - loopTime >= 1000) {   // 1,5 Sekunden scheint mir recht lange zu sein
    loopTime = currentTime;  // Updates loopTime
    for (byte ausgang = 0; ausgang < PWM; ausgang++)
    {
      if ((brightness[ausgang] < aktModbuswert[ausgang] && fadeAmount[ausgang] > 0) || (brightness[ausgang] > aktModbuswert[ausgang] && fadeAmount[ausgang] < 0)) {
        brightness[ausgang] += fadeAmount[ausgang];
        analogWrite(ausgaenge[ausgang], brightness[ausgang]);
      }
      //Serial.println();
    }
  }

  // Digitale Eingänge herauslesen und zu Modbus übergeben:
  //Pin31
  Mb.R[14] = digitalRead(31);

  //Pin33
  Mb.R[15] = digitalRead(33);

  //Pin35
  Mb.R[16] = digitalRead(35);

  //Pin37
  Mb.R[17] = digitalRead(37);

  //Pin39
  Mb.R[18] = digitalRead(39);

  //Pin41
  Mb.R[19] = digitalRead(41);

  //Pin43
  Mb.R[20] = digitalRead(43);

  //Pin47
  Mb.R[21] = digitalRead(47);

  //Pin49
  Mb.R[22] = digitalRead(49);

  //Pin53
  Mb.R[23] = digitalRead(53);


  // Analoge Eingänge herauslesen und zu Modbus übergeben:

  //Pin Analog 0
  Mb.R[24] = analogRead(0);

  //Pin Analog 1
  Mb.R[25] = analogRead(1);

  //Pin Analog 2
  Mb.R[26] = analogRead(2);

  //Pin Analog 3
  sensorwert = analogRead(3); // LM35 am Pin A3 12V Netzteil
  temperatur = map(sensorwert, 0, 307, 0, 150);
  Mb.R[27] = temperatur;

  //Pin Analog 4
  sensorwert = analogRead(4); // LM35 am Pin A4 Platine Mega - Modbus
  temperatur = map(sensorwert, 0, 307, 0, 150);
  Mb.R[28] = temperatur;
}

Gruß

mudbus.zip (43.9 KB)

MegaModbusFade.ino (3.6 KB)

power-dodge · February 10, 2018, 11:15am

Hallo,

wenn ich keinen Fehler gemacht habe, habe
dann die richtige Bibliothek hinzugefügt.

Gruß

agmue · February 10, 2018, 4:35pm

Wenn ich bei einer bekannten Suchmaschine "mudbus" eingebe, stoße ich auf eine schon recht alte Programmbibliothek. Ist das die von Dir verwendete?

Dein Programm hätte noch Optimierungsmöglichkeiten, bist Du interessiert?

power-dodge · February 10, 2018, 7:45pm

Hi,

also kann nicht genau sagen ob es dieses ist.
Hab aus meiner Bibliothek den Ordner hier eingefügt...

Also über Verbesserungen würde ich mich ganz
sicher noch freuen und andere bestimmt auch!

Gruß

agmue · February 10, 2018, 9:46pm

Bitte ersatzlos streichen, analogWrite setzt den Ausgang selbständig auf Ausgang:

int modbusersatz() {
  static int wert = 127;
  if (Serial.available())
  {
    wert = Serial.parseInt();
    Serial.print(F("neuer Wert: "));
    Serial.println(wert);
  }
  return wert;
}
...
  pinMode(2, OUTPUT); // Pin 2 des Mega
  pinMode(3, OUTPUT); // Pin 3 des Mega
  pinMode(4, OUTPUT); // Pin 4 des Mega
  pinMode(5, OUTPUT); // Pin 5 des Mega
  pinMode(6, OUTPUT); // Pin 6 des Mega
  pinMode(7, OUTPUT); // Pin 7 des Mega
  pinMode(8, OUTPUT); // Pin 8 des Mega
  pinMode(9, OUTPUT); // Pin 9 des Mega
  pinMode(11, OUTPUT); // Pin 11 des Mega
  pinMode(45, OUTPUT); // Pin 45 des Mega, Led: 10 auf der Platine und Modbus
  pinMode(12, OUTPUT); // Pin 12 des Mega
  pinMode(13, OUTPUT); // Pin 13 des Mega
...
Serial.println(F("PWM-Wert eingeben"));

Wenn Du dies

//Pin 4 = Modbusadresse 4
  {
  altModbuswert[2] = aktModbuswert[2];
  aktModbuswert[2] = Mb.R[4];  // stattdassen Mb.R[2]
  if (altModbuswert[2] != aktModbuswert[2])
  {
    if (brightness[2] < aktModbuswert[2]) {
      fadeAmount[2] = 5;
    } else {
      fadeAmount[2] = -5;
    }
  }
  if (currentTime - loopTime >= 1500) {
    loopTime = currentTime;  // Updates loopTime
    for (byte j = 0; j < PWM; j++)
    {
      if ((brightness[j] < aktModbuswert[j] && fadeAmount[j] > 0) || (brightness[j] > aktModbuswert[j] && fadeAmount[j] < 0)) {
        brightness[j] += fadeAmount[j];
        analogWrite(ausgaenge[j], brightness[j]);
      }
      //Serial.println();
    }
  }
  ausgang++;
  ausgang = ausgang % PWM;
  }

mit diesem

  //Pin 5 = Modbusadresse 5
  {
  altModbuswert[3] = aktModbuswert[3];
  aktModbuswert[3] = Mb.R[5];  // stattdassen Mb.R[2]
  if (altModbuswert[3] != aktModbuswert[3])
  {
    if (brightness[3] < aktModbuswert[3]) {
      fadeAmount[3] = 5;
    } else {
      fadeAmount[3] = -5;
    }
  }
  if (currentTime - loopTime >= 1500) {
    loopTime = currentTime;  // Updates loopTime
    for (byte j = 0; j < PWM; j++)
    {
      if ((brightness[j] < aktModbuswert[j] && fadeAmount[j] > 0) || (brightness[j] > aktModbuswert[j] && fadeAmount[j] < 0)) {
        brightness[j] += fadeAmount[j];
        analogWrite(ausgaenge[j], brightness[j]);
      }
      //Serial.println();
    }
  }
  ausgang++;
  ausgang = ausgang % PWM;
  }

vergleichst, gibt es viele Übereinstimmungen, eine Steilvorlage für eine Schleife.

Ich habe mein Programm etwas verändert. Neu ist die Zuordnung zu den Mb.R-Feldelementen mit dem Feld R. Bei mir heißt das Feld MbR, bei Dir kommt es via Modbus.

Ich hoffe, Du kannst die Schleife für Dein Programm erfolgreich umsetzen:

// getestet mit Mega2560
const byte ausgaenge[] = {2, 3, 4, 5, 6, 7, 8, 9, 45, 11, 12, 13};
const byte PWM = sizeof(ausgaenge);
byte ausgang;
const byte R[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; // Indexwerte fuer Mb.R[]
byte MbR[PWM];
int8_t fadeAmount[PWM];    // how many points to fade the LED by
unsigned long currentTime;
unsigned long loopTime;
int brightness[PWM], altModbuswert[PWM], aktModbuswert[PWM];

void modbusersatz() {
  if (Serial.available())
  {
    byte wert = Serial.parseInt();
    for (byte j = 0; j < PWM; j++)
    {
      MbR[R[j]] = wert;
    }
    Serial.print(F("neuer Wert: "));
    Serial.println(wert);
  }
}

void loop()  {
  currentTime = millis();
  modbusersatz();
  altModbuswert[ausgang] = aktModbuswert[ausgang];
  aktModbuswert[ausgang] = MbR[R[ausgang]];  // stattdassen Mb.R[R[ausgang]]
  if (altModbuswert[ausgang] != aktModbuswert[ausgang])
  {
    if (brightness[ausgang] < aktModbuswert[ausgang]) {
      fadeAmount[ausgang] = 5;
    } else {
      fadeAmount[ausgang] = -5;
    }
  }
  if (currentTime - loopTime >= 40) {
    loopTime = currentTime;  // Updates loopTime
    for (byte j = 0; j < PWM; j++)
    {
      if ((brightness[j] < aktModbuswert[j] && fadeAmount[j] > 0) || (brightness[j] > aktModbuswert[j] && fadeAmount[j] < 0)) {
        brightness[j] += fadeAmount[j];
        analogWrite(ausgaenge[j], brightness[j]);
      }
      //Serial.println();
    }
  }
  ausgang++;
  ausgang = ausgang % PWM;
}

void setup()
{
  Serial.begin(9600);
  Serial.println(F("PWM-Wert eingeben"));
  for (byte j = 0; j < PWM; j++)
  {
    fadeAmount[j] = 5;
    MbR[R[j]] = 255;
    brightness[j] = 255;
    altModbuswert[j] = 255;
    aktModbuswert[j] = 255;
  }
  currentTime = millis();
  loopTime = currentTime;
}

power-dodge · February 11, 2018, 6:26am

Hi,

danke Dir für die Hilfe!!!

Leider habe ich so nicht hin bekommen:

#include <SPI.h>
#include <Ethernet.h>

#include "Mudbus.h"

// getestet mit Mega2560
const byte ausgaenge[] = {2, 3, 4, 5, 6, 7, 8, 9, 45, 11, 12, 13};
const byte PWM = sizeof(ausgaenge);
byte ausgang;
const byte R[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; // Indexwerte fuer Mb.R[]
byte MbR[PWM];
int8_t fadeAmount[PWM];    // how many points to fade the LED by
unsigned long currentTime;
unsigned long loopTime;
int brightness[PWM], altModbuswert[PWM], aktModbuswert[PWM];

void modbusersatz() {
  if (Serial.available())
  {
    byte wert = Serial.parseInt();
    for (byte j = 0; j < PWM; j++)
    {
      MbR[R[j]] = wert;
    }
    Serial.print(F("neuer Wert: "));
    Serial.println(wert);
  }
}


Mudbus Mb;
//Function codes 1(read coils), 3(read registers), 5(write coil), 6(write register)
//signed int Mb.R[0 to 125] and bool Mb.C[0 to 128] MB_N_R MB_N_C
//Port 502 (defined in Mudbus.h) MB_PORT

void setup()
{
  Serial.begin(9600);
  Serial.println(F("PWM-Wert eingeben"));
  for (byte j = 0; j < PWM; j++)
  {
    fadeAmount[j] = 5;
    MbR[R[j]] = 255;
    brightness[j] = 255;
    altModbuswert[j] = 255;
    aktModbuswert[j] = 255;
  }
  currentTime = millis();
  loopTime = currentTime;
 
  uint8_t mac[]     = { 0x90, 0xA2, 0xDA, 0x00, 0x51, 0x06 };
  uint8_t ip[]      = { 192, 168, 178, 70 };
  uint8_t gateway[] = { 192, 168, 178, 1 };
  uint8_t subnet[]  = { 255, 255, 255, 0 };
  Ethernet.begin(mac, ip, gateway, subnet);


  //PWM Frequenz
  //0×01  1      31.374 KHz
  //0×02  8      3.921 Khz
  //0×03  64     490.1 Hz            // default
  //0×04  256    122.5 Hz
  //0×05  1024   30.63 Hz
  //http://playground.arduino.cc/Main/TimerPWMCheatsheet

  TCCR1A = (TCCR1A & 0xF8) | 0x01;
  TCCR0A = (TCCR0A & 0xF8) | 0x01;
  TCCR0B = (TCCR0B & 0xF8) | 0x01;
  TCCR2B = (TCCR2B & 0xF8) | 0x01;
 
  pinMode(2, OUTPUT); // Pin 2 des Mega
  pinMode(3, OUTPUT); // Pin 3 des Mega
  pinMode(4, OUTPUT); // Pin 4 des Mega
  pinMode(5, OUTPUT); // Pin 5 des Mega
  pinMode(6, OUTPUT); // Pin 6 des Mega
  pinMode(7, OUTPUT); // Pin 7 des Mega
  pinMode(8, OUTPUT); // Pin 8 des Mega
  pinMode(9, OUTPUT); // Pin 9 des Mega
  pinMode(11, OUTPUT); // Pin 11 des Mega
  pinMode(45, OUTPUT); // Pin 45 des Mega, Led: 10 auf der Platine und Modbus
  pinMode(12, OUTPUT); // Pin 12 des Mega
  pinMode(13, OUTPUT); // Pin 13 des Mega
}


void loop()

{
  Mb.Run();{
  currentTime = millis();
  //PWM Ausgänge:
  
  //Pin 2 = Modbusadresse 2
  modbusersatz();
  altModbuswert[0] = aktModbuswert[0];
  aktModbuswert[0] = MbR[R[0]];  // stattdassen Mb.R[R[ausgang]]
  if (altModbuswert[0] != aktModbuswert[0])
  {
    if (brightness[0] < aktModbuswert[0]) {
      fadeAmount[0] = 5;
    } else {
      fadeAmount[0] = -5;
    }
  }
  if (currentTime - loopTime >= 40) {
    loopTime = currentTime;  // Updates loopTime
    for (byte j = 0; j < PWM; j++)
    {
      if ((brightness[j] < aktModbuswert[j] && fadeAmount[j] > 0) || (brightness[j] > aktModbuswert[j] && fadeAmount[j] < 0)) {
        brightness[j] += fadeAmount[j];
        analogWrite(ausgaenge[j], brightness[j]);
      }
      //Serial.println();
    }
  }
  ausgang++;
  ausgang = ausgang % PWM;
  }
  {
  
  // Digitale Eingänge herauslesen und zu Modbus übergeben:
  //Pin31
  Mb.R[14] = digitalRead(31);
  //Pin33
  Mb.R[15] = digitalRead(33);
  //Pin35
  Mb.R[16] = digitalRead(35);
  //Pin37
  Mb.R[17] = digitalRead(37);
  //Pin39
  Mb.R[18] = digitalRead(39);
  //Pin41
  Mb.R[19] = digitalRead(41); 
  //Pin43
  Mb.R[20] = digitalRead(43); 
  //Pin47
  Mb.R[21] = digitalRead(47); 
  //Pin49
  Mb.R[22] = digitalRead(49); 
  //Pin53
  Mb.R[23] = digitalRead(53);

  // Analoge Eingänge herauslesen und zu Modbus übergeben:
  //Pin Analog 0
  Mb.R[24] = analogRead(0);
  //Pin Analog 1
  Mb.R[25] = analogRead(1);
  //Pin Analog 2
  Mb.R[26] = analogRead(2);
  //Pin Analog 3
  Mb.R[27] = analogRead(3);
  //Pin Analog 4
  Mb.R[28] = analogRead(4);
  }
}

Vielleicht habe ich was übersehen, ModBus verbindung steht,
da die Daten von anderen Adressen rein kommen.

So aber funktioniert es weiter hin:

aktModbuswert[0] = Mb.R[2];  // stattdassen Mb.R[R[ausgang]]

Gruß

agmue · February 11, 2018, 9:41am

Die Variable ausgang ist der Schleifenindex für loop. Ersetze daher [ 0 ] durch [ausgang].

Außerdem fehlt bei MbR[R[0]] ein Punkt und der Schleifenindex, siehe Kommentar: Mb.R[R[ausgang]]

power-dodge · February 11, 2018, 10:10am

Hi,

Danke Dir für die Antwort!

danke hab jetzt hinbekommen. In Deinem ersten Code war auch
kein Punkt. Daher ist mir gar nicht aufgefallen, oder eher gesagt hab mir nichts
bei gedacht.

Werde gleich auf alle Pins wieder den Code erweitern,
hab auch heute Temperaturumrechnung mit eingebunden.
Poste nach dem Testen den ganzen Code.

Hab da aber ne Frage noch, der W5100 geht mir auf dem Senkel...
Wenn er mit GND oder VCC mit dranhängt, lässt sich Mega nicht flaschen.
Daher ist noch ein Schalter eingebaut, der GND und VCC trennt von den beiden.

Und da ist mir aufgefallen wenn der W5100 nicht dran hängt blinkt die LED13 (Pin13).
Aber auch die anderen Mosfets werden langsam geöffnet und die LED´s werden langsam
heller. Ohne einwirken meiner seist.

So nun die Frage:

Wenn der W5100 nicht mehr verfügbar ist z.B. bei defekt etc. kann
man vielleicht die Pin´s mit nullen als beschreiben lassen?

Stelle mir vor wenn man nicht da ist, der W5100 fehlt aus. Und ganze Beleuchtung
macht was es will...

Der Pin 13 kann weiter blinken kein Problem. so gar gut. Könnte man dann ja
an einer Leuchte sehen das etwas nicht stimmt.

War das so gemeint:

#include <SPI.h>
#include <Ethernet.h>

#include "Mudbus.h"

// getestet mit Mega2560
const byte ausgaenge[] = {2, 3, 4, 5, 6, 7, 8, 9, 45, 11, 12, 13};
const byte PWM = sizeof(ausgaenge);
byte ausgang;
const byte R[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; // Indexwerte fuer Mb.R[]
byte MbR[PWM];
int8_t fadeAmount[PWM];    // how many points to fade the LED by
unsigned long currentTime;
unsigned long loopTime;
int brightness[PWM], altModbuswert[PWM], aktModbuswert[PWM];

int sensorwert; // LM35 Temperatur auslesen.
int temperatur = 0; //Unter d

void modbusersatz() {
  if (Serial.available())
  {
    byte wert = Serial.parseInt();
    for (byte j = 0; j < PWM; j++)
    {
      MbR[R[j]] = wert;
    }
    Serial.print(F("neuer Wert: "));
    Serial.println(wert);
  }
}


Mudbus Mb;
//Function codes 1(read coils), 3(read registers), 5(write coil), 6(write register)
//signed int Mb.R[0 to 125] and bool Mb.C[0 to 128] MB_N_R MB_N_C
//Port 502 (defined in Mudbus.h) MB_PORT

void setup()
{
  Serial.begin(9600);
  Serial.println(F("PWM-Wert eingeben"));
  for (byte j = 0; j < PWM; j++)
  {
    fadeAmount[j] = 5;
    MbR[R[j]] = 255;
    brightness[j] = 255;
    altModbuswert[j] = 255;
    aktModbuswert[j] = 255;
  }
  currentTime = millis();
  loopTime = currentTime;
 
  uint8_t mac[]     = { 0x90, 0xA2, 0xDA, 0x00, 0x51, 0x06 };
  uint8_t ip[]      = { 192, 168, 178, 70 };
  uint8_t gateway[] = { 192, 168, 178, 1 };
  uint8_t subnet[]  = { 255, 255, 255, 0 };
  Ethernet.begin(mac, ip, gateway, subnet);


  //PWM Frequenz
  //0×01  1      31.374 KHz
  //0×02  8      3.921 Khz
  //0×03  64     490.1 Hz            // default
  //0×04  256    122.5 Hz
  //0×05  1024   30.63 Hz
  //http://playground.arduino.cc/Main/TimerPWMCheatsheet

  TCCR1A = (TCCR1A & 0xF8) | 0x01;
  TCCR0A = (TCCR0A & 0xF8) | 0x01;
  TCCR0B = (TCCR0B & 0xF8) | 0x01;
  TCCR2B = (TCCR2B & 0xF8) | 0x01;
 
  pinMode(2, OUTPUT); // Pin 2 des Mega
  pinMode(3, OUTPUT); // Pin 3 des Mega
  pinMode(4, OUTPUT); // Pin 4 des Mega
  pinMode(5, OUTPUT); // Pin 5 des Mega
  pinMode(6, OUTPUT); // Pin 6 des Mega
  pinMode(7, OUTPUT); // Pin 7 des Mega
  pinMode(8, OUTPUT); // Pin 8 des Mega
  pinMode(9, OUTPUT); // Pin 9 des Mega
  pinMode(11, OUTPUT); // Pin 11 des Mega
  pinMode(45, OUTPUT); // Pin 45 des Mega, Led: 10 auf der Platine und Modbus
  pinMode(12, OUTPUT); // Pin 12 des Mega
  pinMode(13, OUTPUT); // Pin 13 des Mega
}


void loop()

{
  Mb.Run();{
  currentTime = millis();
  //PWM Ausgänge:
  
  //Pin 2 = Modbusadresse 2
  modbusersatz();
  altModbuswert[0] = aktModbuswert[0];
  aktModbuswert[0] = Mb.R[R[0]];  // stattdassen Mb.R[R[ausgang]]
  if (altModbuswert[0] != aktModbuswert[0])
  {
    if (brightness[0] < aktModbuswert[0]) {
      fadeAmount[0] = 5;
    } else {
      fadeAmount[0] = -5;
    }
  }
  if (currentTime - loopTime >= 1500) {
    loopTime = currentTime;  // Updates loopTime
    for (byte j = 0; j < PWM; j++)
    {
      if ((brightness[j] < aktModbuswert[j] && fadeAmount[j] > 0) || (brightness[j] > aktModbuswert[j] && fadeAmount[j] < 0)) {
        brightness[j] += fadeAmount[j];
        analogWrite(ausgaenge[j], brightness[j]);
      }
      //Serial.println();
    }
  }
  ausgang++;
  ausgang = ausgang % PWM;
  }
  {
  
  // Digitale Eingänge herauslesen und zu Modbus übergeben:
  
  //Pin31
  Mb.R[14] = digitalRead(31);
  
  //Pin33
  Mb.R[15] = digitalRead(33);
  
  //Pin35
  Mb.R[16] = digitalRead(35);
  
  //Pin37
  Mb.R[17] = digitalRead(37);
  
  //Pin39
  Mb.R[18] = digitalRead(39);
  
  //Pin41
  Mb.R[19] = digitalRead(41);

  //Pin43
  Mb.R[20] = digitalRead(43); 
  
  //Pin47
  Mb.R[21] = digitalRead(47); 
  
  //Pin49
  Mb.R[22] = digitalRead(49); 
  
  //Pin53
  Mb.R[23] = digitalRead(53);


  // Analoge Eingänge herauslesen und zu Modbus übergeben:
  
  //Pin Analog 0
  Mb.R[24] = analogRead(0);
  
  //Pin Analog 1
  Mb.R[25] = analogRead(1);
  
  //Pin Analog 2
  Mb.R[26] = analogRead(2);
  
  //Pin Analog 3
  Mb.R[27] = analogRead(3); 
  
  //Pin Analog 4
  sensorwert = analogRead(4); // LM35 am Pin A4 Platine Mega - Modbus
  temperatur = map(sensorwert, 0, 307, 0, 150);
  Mb.R[28] = temperatur;
  }
}

Gruß

power-dodge · February 11, 2018, 10:47am

Hallo,

so hab da was zusammen geschustert. War das so richtig?
Füge hier bei das Sketch.

Gruß

MegaModbusFade.ino (12 KB)

agmue · February 11, 2018, 11:17am

power-dodge:
War das so richtig?

Nee, Du hast den Sinn der Schleife noch nicht erkannt.

Sketch aus #10 verändert (nicht getestet, da ich die Hardware nicht habe, aber der Kompiler ist zufrieden):

#include <SPI.h>
#include <Ethernet.h>

#include "Mudbus.h"

// getestet mit Mega2560
const byte ausgaenge[] = {2, 3, 4, 5, 6, 7, 8, 9, 45, 11, 12, 13};
const byte PWM = sizeof(ausgaenge);
const byte R[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; // Indexwerte fuer Mb.R[]
int8_t fadeAmount[PWM];    // how many points to fade the LED by
unsigned long currentTime;
unsigned long loopTime;
int brightness[PWM], altModbuswert[PWM], aktModbuswert[PWM];

int sensorwert; // LM35 Temperatur auslesen.
int temperatur = 0; //Unter d

Mudbus Mb;
//Function codes 1(read coils), 3(read registers), 5(write coil), 6(write register)
//signed int Mb.R[0 to 125] and bool Mb.C[0 to 128] MB_N_R MB_N_C
//Port 502 (defined in Mudbus.h) MB_PORT

void setup()
{
  Serial.begin(9600);
  Serial.println(F("Programmstart"));
  for (byte ausgang = 0; ausgang < PWM; ausgang++)
  {
    fadeAmount[ausgang] = 5;
    brightness[ausgang] = 255;    // Anfangswert "aus"
    altModbuswert[ausgang] = 255; // Anfangswert "aus"
    aktModbuswert[ausgang] = 255; // Anfangswert "aus"
  }
  currentTime = millis();
  loopTime = currentTime;

  uint8_t mac[]     = { 0x90, 0xA2, 0xDA, 0x00, 0x51, 0x06 };
  uint8_t ip[]      = { 192, 168, 178, 70 };
  uint8_t gateway[] = { 192, 168, 178, 1 };
  uint8_t subnet[]  = { 255, 255, 255, 0 };
  Ethernet.begin(mac, ip, gateway, subnet);


  //PWM Frequenz
  //0×01  1      31.374 KHz
  //0×02  8      3.921 Khz
  //0×03  64     490.1 Hz            // default
  //0×04  256    122.5 Hz
  //0×05  1024   30.63 Hz
  //http://playground.arduino.cc/Main/TimerPWMCheatsheet

  TCCR1A = (TCCR1A & 0xF8) | 0x01;
  TCCR0A = (TCCR0A & 0xF8) | 0x01;
  TCCR0B = (TCCR0B & 0xF8) | 0x01;
  TCCR2B = (TCCR2B & 0xF8) | 0x01;
}

void loop()
{
  Mb.Run();
  currentTime = millis();
  //PWM Ausgänge:
  for (byte ausgang = 0; ausgang < PWM; ausgang++)
  {
    altModbuswert[ausgang] = aktModbuswert[ausgang];
    aktModbuswert[ausgang] = Mb.R[R[ausgang]];
    if (altModbuswert[ausgang] != aktModbuswert[ausgang])
    {
      if (brightness[ausgang] < aktModbuswert[ausgang]) {
        fadeAmount[ausgang] = 5;
      } else {
        fadeAmount[ausgang] = -5;
      }
    }
  }
  if (currentTime - loopTime >= 1500) {   // 1,5 Sekunden scheint mir recht lange zu sein
    loopTime = currentTime;  // Updates loopTime
    for (byte ausgang = 0; ausgang < PWM; ausgang++)
    {
      if ((brightness[ausgang] < aktModbuswert[ausgang] && fadeAmount[ausgang] > 0) || (brightness[ausgang] > aktModbuswert[ausgang] && fadeAmount[ausgang] < 0)) {
        brightness[ausgang] += fadeAmount[ausgang];
        analogWrite(ausgaenge[ausgang], brightness[ausgang]);
      }
      //Serial.println();
    }
  }

  // Digitale Eingänge herauslesen und zu Modbus übergeben:
  //Pin31
  Mb.R[14] = digitalRead(31);

  //Pin33
  Mb.R[15] = digitalRead(33);

  //Pin35
  Mb.R[16] = digitalRead(35);

  //Pin37
  Mb.R[17] = digitalRead(37);

  //Pin39
  Mb.R[18] = digitalRead(39);

  //Pin41
  Mb.R[19] = digitalRead(41);

  //Pin43
  Mb.R[20] = digitalRead(43);

  //Pin47
  Mb.R[21] = digitalRead(47);

  //Pin49
  Mb.R[22] = digitalRead(49);

  //Pin53
  Mb.R[23] = digitalRead(53);


  // Analoge Eingänge herauslesen und zu Modbus übergeben:

  //Pin Analog 0
  Mb.R[24] = analogRead(0);

  //Pin Analog 1
  Mb.R[25] = analogRead(1);

  //Pin Analog 2
  Mb.R[26] = analogRead(2);

  //Pin Analog 3
  Mb.R[27] = analogRead(3);

  //Pin Analog 4
  sensorwert = analogRead(4); // LM35 am Pin A4 Platine Mega - Modbus
  temperatur = map(sensorwert, 0, 307, 0, 150);
  Mb.R[28] = temperatur;
}

Anstelle x-mal dasselbe zu machen, nutzt Du eine Schleife. Anstelle loop habe ich jetzt doch for genutzt.

Ich hoffe, Du bist nicht enttäuscht, daß der Code jetzt so kurz ist, das läßt Raum für weitere Kreativität

power-dodge · February 11, 2018, 12:14pm

Hi,

danke für das Beispiel. Ich verstehe nur nicht
wo ich dazu den zugehörigen Pin definiere...

So wie es hier ist macht er mir alle Ausgänge auf der Modbusadresse
ansteuern...

for (byte ausgang = 0; ausgang < PWM; ausgang++) //[b]Null steht ja da schon in [0] gebts Fehler
  {[/b]
    altModbuswert[ausgang] = aktModbuswert[ausgang];
    aktModbuswert[ausgang] = Mb.R[R[0]];  [b]Den Modbus ist   klar...[/b]
    if (altModbuswert[ausgang] != aktModbuswert[ausgang])
    {
      if (brightness[ausgang] < aktModbuswert[ausgang]) {
        fadeAmount[ausgang] = 5;
      } else {
        fadeAmount[ausgang] = -5;

Sehe bestimmt den Wald vor lauter Bäume net...

Gruß

agmue · February 11, 2018, 12:17pm

Mb.R[R[0]]

sollte sein

Mb.R[R[ausgang]]

Das Feld R ist eine Konkordanz zwischen dem Ausgangs-Index und dem Modbus-Index.

power-dodge · February 11, 2018, 12:31pm

Hi,

ah das ist ja cool! Danke Dir für die Hilfe!

Das ist ja wirklich sau kurz geworden!!!

Nur mal ne Frage, das fade 1000 greift jetzt auf jeden
Pin richtig?

Cool gemacht!

Gruß

agmue · February 11, 2018, 1:28pm

power-dodge:
fade 1000

Das sagt mir jetzt nichts.

Die Schleifen durchlaufen alle Pins nacheinander. Der Mehraufwand steckt in den Konkordanzen in Form von Feldern. Andererseits, wenn Du Pin 13, der beim Bootloader mitblinkt, ändern möchtest in Pin 44, brauchst Du das an nur einer Stelle zu tun:

const byte ausgaenge[] = {2, 3, 4, 5, 6, 7, 8, 9, 45, 11, 12, 44};

power-dodge · February 11, 2018, 2:59pm

Hi,

danke für die Antwort.
Ja das hab ich verstanden. 1000 meine ich mit 1 Sekunde,
naja müsste ja so sein das es für alle Pins ist.

Gruß

power-dodge · February 18, 2018, 8:26pm

Hallo,

leider funktioniert es leider nicht auf dauer,
nach paar Srunden fangen alle Kanäle zu spinnen
und über das Netzwerk ist es nicht mehr erreichbar.

Kann es sein das der dynamischer Speicher voll wird?
Wenn ja wie verhindert man dieses?

(F sitzt ja schon brav bei Serialprint.

Habe zu dem Problem auch hier mal gefragt:

http://forum.arduino.cc/index.php?topic=518815.msg3612963#msg3612963

Wäre über Tipps sehr dankbar.

Gruß

Alex

Topic		Replies	Views
Fadein, Fadeout über einen bestimmten Zeitraum Deutsch	7	1926	May 6, 2021
LED Fader unterbrechen Deutsch	9	572	May 6, 2021
fade millis Deutsch	13	4465	May 6, 2021
Arduino, PIR, LED, fading mit millis Deutsch	9	1230	May 6, 2021
Ganz von vorn - Getting started :-) Deutsch	14	5088	May 6, 2021

Arduino Modbus Light fade, Licht faden.

Related Topics