Show Posts
Pages: [1] 2 3 ... 38
1  International / Deutsch / Jahreszahlformat - RTC Winterzeit-Sommerzeit on: April 19, 2014, 06:59:05 pm
Hallo,

ich bin gerade dabei die Sache mit der RTC anzupassen und nutze dafür den Code von jurs.
Danke erstmal dafür. 1A.

Jetzt bin ich beim testen, ob die Winter/Sommerzeit Feststellung bei mir funktioniert, auf ein Problem gestoßen.
Übergibt man der Funktion die Jahreszahl 4stellig, ist alles i.O.
Übergibt man der Funktion die Jahreszahl 2stellig, funktioniert sie nicht mehr.
Warum?
Die Berechnung der Hilfsvariablen x1 und x2 wird doch unabhängig von allen anderen vorgenommen.
Mit der alten Funktion funktioniert das auch 2stellig.

Und warum werden die Funktionsvariablen year, month, day und hour in der IDE rot dargestellt?
Würde doch bedeuten, diese Namen werden von der IDE intern schon verwendet?

Code:
/*
Arduino Mega2560
I2C RTC DS3231
*/

#include <Wire.h>
#define ds3231_adress  0x68   // Adresse

// boolean i2c_status;

int Sekunde, Minute, Stunde, Wochentag, Tag, Monat, Jahr;

void setup()
{
  Wire.begin();
  Serial.begin(57600);
 
}

void loop()
{
 
 
 if (read_DS3231 (ds3231_adress) == true)     // wenn Fehlerstatus "wahr", dann
   {
    Serial.println("DS3231 I2C Busfehler");
   }
   else                                       // wenn kein Busfehler, dann
     {
      if (Sommerzeit_aktiv(Jahr, Monat, Tag, Stunde) == true)
        {                                     // wenn Sommerzeit, dann
         Serial.print("Sommerzeit"); Serial.print("\t");
         Stunde = Stunde + 1;                 // Sommerzeitkorrektur   
         if (Stunde >=24)
           {
            Stunde = 0;
            Tag = Tag + 1;
           }
        }
        else
          {                                 
           Serial.print("Winterzeit"); Serial.print("\t");
          }         
      Serial.print(Stunde);  Serial.print("\t");
      Serial.print(Minute); Serial.print("\t");
      Serial.print(Sekunde); Serial.print("\t");
      Serial.print(Tag); Serial.print("\t");
      Serial.print(Monat); Serial.print("\t");
      Serial.print(Jahr); Serial.print("\n");
     }
 
 delay(1000);
}
 
 
boolean read_DS3231 (int i2c_adresse)
{
  boolean error = false;                   // Fehlerstatus setzen
  Wire.beginTransmission(i2c_adresse);     // Connect
  Wire.write(0);                           // Anfrage ab/der Register Nummer
  if (Wire.endTransmission() > 0 )         // war Connect fehlerfrei?
   {
    error = true;                          // I2C Busfehler
    return error;                          // Abruch
   }
   
  Wire.requestFrom(i2c_adresse, 7);        // 7 Bytes in Folge anfordern/lesen

  if (Wire.available() > 0 )               // sind Daten vorhanden?
    {
     Sekunde   = bcdToDec(Wire.read() & 0x7F);  // Maske für die ersten 7 Bits alleine
     Minute    = bcdToDec(Wire.read() );
     Stunde    = bcdToDec(Wire.read() & 0x3F);  // Umschaltung auf 24h statt 12h (AM/PM)
                          Wire.read();          // wäre der Wochentag
     Tag       = bcdToDec(Wire.read() );             
     Monat     = bcdToDec(Wire.read() );
     Jahr      = bcdToDec(Wire.read() ) + 2000;
    }   
}


boolean Sommerzeit_aktiv (int year, int month, int day, int hour)
// ausgehend das die RTC in der Zeitzone UTC+1, also "Winterzeit Berlin" dauerhaft läuft
// European Daylight Savings Time calculation by "jurs" for German Arduino Forum
// input parameters: "normal time" for year, month, day, hour
// return value: returns true during Daylight Saving Time, false otherwise
{
  static int x1,x2, lastYear; // Zur Beschleunigung des Codes ein Cache für einige statische Variablen
  int x3;
  if (month<3 || month>10) return false; // keine Sommerzeit in Jan, Feb, Nov, Dez
  if (month>3 && month<10) return true;  // Sommerzeit in Apr, Mai, Jun, Jul, Aug, Sep
  // der nachfolgende Code wird nur für Monat 3 und 10 ausgeführt
  // Umstellung erfolgt auf Stunde utc_hour=1, in der Zeitzone Berlin entsprechend 2 Uhr MEZ
  // Es wird ein Cache-Speicher für die Variablen x1 und x2 verwendet,
  // dies beschleunigt die Berechnung, wenn sich das Jahr bei Folgeaufrufen nicht ändert
  // x1 und x2 werden nur neu Berechnet, wenn sich das Jahr bei nachfolgenden Aufrufen ändert
  if (year!= lastYear)
    { // Umstellungsbeginn und -ende
     x1= 1 + 1 + 24*(31 - (5 * year /4 + 4) % 7); 
     x2= 1 + 1 + 24*(31 - (5 * year /4 + 1) % 7);
     lastYear=year;
   } 
  x3= hour + 24 * day;
  if (month==3 && x3>=x1 || month==10 && x3<x2) return true; else return false;
}



/* Sommerzeit Korrektur, ausgehend das die RTC in der Zeitzone UTC+1, also Winterzeit Berlin dauerhaft läuft
// European Daylight Savings Time calculation by "jurs" for German Arduino Forum
// input parameters: "normal time" for year, month, day, hour
// return value: returns true during Daylight Saving Time, false otherwise  */
/*
boolean Sommerzeit_aktiv()
{
  if (Monat<3 || Monat>10) return false;  // keine Sommerzeit in Jan, Feb, Nov, Dez
  if (Monat>3 && Monat<10) return true;   // Sommerzeit in Apr, Mai, Jun, Jul, Aug, Sep
  if (Monat==3 && (Stunde + 24 * Tag)>=(2 + 24*(31 - (5 * Jahr /4 + 4) % 7)) || Monat==10 && (Stunde + 24 * Tag)<(2 + 24*(31 - (5 * Jahr /4 + 1) % 7)))
    return true;
  else
    return false;
}   
*/

byte bcdToDec(byte val)  // Hilfsfunktion zum Lesen/Schreiben der RTC
// Convert binary coded decimal to decimal number
// Hilfsfunktion für die Echtzeituhr
{
  return ( (val/16*10) + (val%16) );
}
2  International / Deutsch / Re: Verständnisfrage zum Vordefinieren von Variablen on: April 19, 2014, 06:42:17 pm
Hallo,

im Netz steht das auch überall so wie Du schreibst. In meinen Büchern ist das zugegeben allgemein formuliert. Die reden pauschal von Variablen. Ist dennoch für mich nicht logisch warum der Compiler da nochmal unterscheiden soll. Ergibt eigentlich keinen Sinn.

Zum Spass habe ich mal folgenden Code erzeugt und mehrfach resetet, erhalte immer 0.00 

Code:
/*
Arduino Mega2560
*/

void setup()
{
  Serial.begin(57600);
}

void loop()
{
double Temp0 ;
double Temp1 ;
double Temp2 ;
double Temp3 ;
double Temp4 ;
double Temp5 ;
double Temp6 ;
double Temp7 ;
double Temp8 ;
double Temp9 ;
Serial.println(Temp0);
Serial.println(Temp1);
Serial.println(Temp2);
Serial.println(Temp3);
Serial.println(Temp4);
Serial.println(Temp5);
Serial.println(Temp6);
Serial.println(Temp7);
Serial.println(Temp8);
Serial.println(Temp9);

delay(9000);
 
}
3  International / Deutsch / Re: Verständnisfrage zum Vordefinieren von Variablen on: April 19, 2014, 04:06:07 pm
Hallo,

eigentlich werden alle Variablen, egal welche, mit 0 initialisiert wenn nichts definiert ist. Das ist laut meinen Büchern in C Standard.
4  International / Deutsch / Re: Probleme mit dem Zählen *gg* on: April 18, 2014, 04:42:12 pm
Hallo,

Du erwartest jetzt nicht einen komplett Code, oder?
Gibts einen Lösungansatz von Dir selbst?
Woran scheiterst Du konkret z.Z.?
5  International / Deutsch / Re: I2C - RTC DS3231 on: April 18, 2014, 10:25:40 am
Hallo,

so Leute, dass müßte doch nun "save" sein.

Wire.endTransmission und Wire.available sind eingebunden und werden beide abgefragt. Bei endTransmission erfolgt ein vorzeitiger Abbruch. Wenn das fehlerfrei ist, dann sollte eigentlich alles danach auch funktionieren.

Noch irgendwelche Einwände zur I2C Fehlerbehandlung?

Ansonsten frohe Ostern - ist einfach zu kalt bei uns ...   smiley-confuse
Code:
/*
Arduino Mega2560
I2C RTC DS3231
*/

#include <Wire.h>
#define ds3231_adress  0x68   // Adresse

byte Tag, Monat, Jahr;

void setup()
{
  Wire.begin();
  Serial.begin(57600);
  
}

void loop()
{
 if (read_DS3231 (ds3231_adress) == true)     // wenn Fehlerstatus "wahr", dann
   {
    Serial.println("DS3231 I2C Busfehler");
   }
  
 delay(5000);
}


boolean read_DS3231 (int i2c_adresse)
{
  boolean error = false;                   // Fehlerstatus setzen
  Wire.beginTransmission(i2c_adresse);     // Connect
  Wire.write(0x04);                        // Anfrage ab/der Register Nummer
  if (Wire.endTransmission() )         // war Connect fehlerfrei?
   {
    //Serial.println("Error_Transmission");
    error = true;                          // I2C Busfehler
    return error;                          // Abruch
   }
  
  Wire.requestFrom(i2c_adresse, 3);

  if (Wire.available() > 0)            // 3 Bytes in Folge anfordern/lesen
    {
     Tag = Wire.read();             // BCD Format
     Monat = Wire.read();
     Jahr = Wire.read();
    }
  
  byte Tage = bcdToDec(Tag);
  byte Monate = bcdToDec(Monat);
  byte Jahre = bcdToDec(Jahr);
 
  Serial.print(Tage);  Serial.print("  ");  Serial.print(Tage, BIN); Serial.print("  ");
  Serial.print(Monate);  Serial.print("  ");  Serial.print(Monate, BIN); Serial.print("  ");
  Serial.print(Jahre);  Serial.print("  ");  Serial.println(Jahre, BIN);
}


byte bcdToDec(byte val)  // Hilfsfunktion zum Lesen/Schreiben der RTC
// Convert binary coded decimal to decimal number
// Hilfsfunktion für die Echtzeituhr
{
  return ( (val/16*10) + (val%16) );
}
6  International / Deutsch / Re: Wie ein LCD ansteuern ; LMC 1602 I2C ; Tutorial ; Sketch on: April 14, 2014, 10:00:07 am
Hallo,

ich weis nicht wonach Du gesucht hast, dass hier war fix gefunden. Library mit Beispielen ist vorhanden.

http://www.exp-tech.de/Displays/I2C-LCD-1602-Module.html?XTCsid=8eca025f8ef32f57b0e421b6a4551f62


7  International / Deutsch / Re: I2C - PCF8574 Portexpander on: April 14, 2014, 09:53:17 am
Hallo,

Danke Dir und pylon. Werde mir den Code der RTC zusätzlich ausdrucken und wenn ich mal wieder mehrere ruhigen Minuten Zeit habe das nochmal durcharbeiten inkl. der Infos aus dem Thread hier. Denke dann sollte ich klar kommen.






8  International / Deutsch / Re: Transistor Basis Vorwiderstand berechnen on: April 14, 2014, 07:35:07 am
Hallo,

nö, die Vce wurde nicht vergessen. Die typischen 0,1V (Kleinleistungstransisitoren) sind vernachlässigbar in der Berechnung. Es wurde immer vom Sättigungsbereich des Transistors ausgegangen. Wenn Du jetzt sagst, der Transistor soll als Vorwiderstand verwendet werden, dann muß man die Verlustleistung im Auge behalten. Würde ich aber so nicht machen. Wenn der Basisstrom reduziert werden soll, dann sollte man auch den LED Vorwiderstand anpassen und damit dem LED Strom, damit der Transistor in Sättigung bleibt als reiner Schalter.
Der LED-Strom würde ja eh weniger werden, aber der Transisitor würde ansonsten eine unnötig erhöhte Verlustleistung verbraten müssen.

Das Fazit bleibt jedoch bestehen. Anderen Transistor oder eben getaktete Konstandstromquelle. Je nach Vorlieben.
9  International / Deutsch / Re: I2C - PCF8574 Portexpander on: April 14, 2014, 05:15:06 am
Hallo,

entschuldige vielmals. Ich möchte niemanden verärgern. Nur stehen hier im Thread viele Informationen kreuz und quer, teilweise widerlegt, dann wieder korrigiert, dass ich versuche, parallel mit Suche im Internet und meinem Buch, alles zu ordnen wie man es nun absolut richtig macht. Am Ende blick ich beim Thema I2C eben nicht so recht durch. Nur leider sind alle Bsp. immer nur auf ein lesen von einem Byte ausgelegt. Ich werde es zum x-ten mal lesen.
10  International / Deutsch / Re: Transistor Basis Vorwiederstand berechnen on: April 13, 2014, 01:03:50 pm
Hallo,

eine klare Angabe zur Stromverstärkung finde ich nicht im Datenblatt. Laut Datenblatt hat er wohl hfe=30, aber dann noch eine Uce von 1,0V. Ungünstig. Darunter stehen noch 2 Einträge, was jeweils eine Stromverstärkung von 10 ergibt. Nicht so das wahre.

Erstmal zu Deiner Vorwiderstandsberechnung.
Du hast ein Kommafehler in Deiner Rechnung.
2V / 150 Ohm ergibt 13,3mA

mal ausführlich
LED Strom = 150mA
LED Spannung = 3V
Schaltung hat 5V.

Ergibt Spannungsabfall über den LED Vorwiderstand 5V - 3V = 2V
Ergibt Vorwiderstand in Ohm: 2V durch 0,150A = 13 Ohm !
Verlustleistung des Vorwiderstandes: 2V * 0,150A = 0,3W  > sollte also ein 1/2W Typ sein

Strom Ic: 150mA
Angenomme Transistor Stromverstärkung: 10
ergibt erforderlichen Basistrom: 150mA / 10 * 4 = 60mA
(die *4 zur sicheren Übersteuerung das er in die Sättigung geht, kann man auch reduzieren, wenn man an der Schaltung mißt wie es aussieht)

60mA sind immer noch zu viel für den Arduino.

Hast Du noch andere Transistoren? Oder Du nimmst den LED Strom runter.

Edit:
Zur Vollständigkeit, die Berechnung vom Basisvorwiderstand.

Der Transistor Basistrom wären die 60mA aus dem Bsp.
Ube wird immer mit 0,7V gerechnet, weil es einer Diode entspricht.
Das bedeutet, am Vorwiderstand fallen 5V - 0,7 = 4,3V ab.
Widerstand in Ohm wären dann, 4,3V / 0,06A = 72 Ohm rechnerisch (Leistung 4,3*0,06= 0,258W)
1/4W Typ würde noch grenzwertig ausreichen, wenn er nicht in Dauerbetrieb arbeiten muß

So wäre das Rechenprinzip.

Grundlegend würde ich jedoch einen anderen Transistor verwenden. Zum Bsp. einen BC337-40. Da kannste bedenkenlos mit einer Stromverstärkung von 100 rechnen.

11  International / Deutsch / Re: I2C - PCF8574 Portexpander on: April 13, 2014, 12:41:23 pm
Hallo,

zugegebenermaßen bin ich unbedarft rangegangen. Also mach ich nochmal einen Reset.

Dazu gleich eine Frage. Warum wird dann beim lesen so ein Aufriss gemacht mit der Überprüfung, dass da ja nichts schief geht, jedoch beim schreiben wird nichts überprüft? Wenn ich etwas lesen möchte, was soll ich da prüfen? Ich weis doch nicht was drin steht, also kann ich nicht überprüfen ob der Datensatz den ich erhalte der ist der wirklich drin steht, in der Speicherzelle. Wenn ich etwas schreibe, dann könnte ich mittels lesen im Anschluss überprüfen ob das übereinstimmt. Also ob es noch das ist was ich geschrieben hatte. Wird jedoch so nicht gemacht. Ich hoffe ihr versteht meine Gedankengänge.

Also fangen wir nochmal von vorn an. Gehen wir mal weg vom blöden PortExpander und gehen zu einem EEProm.

schreiben wie folgt:

Code:
void schreibeEEprom(int I2C_Adresse, unsigned int SpeicherAdresse, byte data)
{
  Wire.beginTransmission(I2C_Adresse);          // Connect
  Wire.write( (byte)(SpeicherAdresse >> 8)   ); // MSB
  Wire.write( (byte)(SpeicherAdresse & 0xFF) ); // LSB
  Wire.write(data);                             // data Byte zum speichern senden
  Wire.endTransmission();                       // Disconnect


lesen wie folgt:

Code:
byte leseEEprom(int I2C_Adresse, unsigned int SpeicherAdresse)
{
  byte data = 0xFF;
  Wire.beginTransmission(I2C_Adresse);           // Connect
  Wire.write( (byte)(SpeicherAdresse >> 8)   );  // MSB
  Wire.write( (byte)(SpeicherAdresse & 0xFF) );  // LSB
  Wire.endTransmission();                        // Disconnect
  Wire.requestFrom(I2C_Adresse, 1);              // Daten vom Slave anfordern, hier 1 Byte
  if (Wire.available()) data = Wire.read();      // wenn Daten vorhanden, diese lesen
  return data;


wenn ich jetzt mehrere Bytes hintereinander lesen möchte, ist dann folgendes richtig oder sollte ich obige Funktion einfach mehrfach hintereinander aufrufen? Das hier würde dann beim auslesen der RTC auch schneller sein, weil man sich das ständige neu ansprechen des I2C Device auf dem Bus erspart.

Code:
  Wire.beginTransmission(I2C_Adresse);           // Connect
  Wire.write( (byte)(SpeicherAdresse >> 8)   );  // MSB
  Wire.write( (byte)(SpeicherAdresse & 0xFF) );  // LSB
  Wire.endTransmission();                        // Disconnect
  Wire.requestFrom(I2C_Adresse, 3);              // Daten vom Slave anfordern, hier 3 Byte
  if (Wire.available())                          // wenn Daten vorhanden, diese lesen
    {                                     
     data_1 = Wire.read(); 
     data_2 = Wire.read(); 
     data_3 = Wire.read(); 
    }                                   


Und wenn ich die  Wire Transmission auch noch sicher machen möchte, muß ich dann
Wire.endTransmission(true);                        // Disconnect
schreiben?
12  International / Deutsch / Re: Lineare Geschwindigkeitsmessung? (Hallsensor?) on: April 12, 2014, 01:00:46 pm
Hallo,

mir fällt nochwas auf. Die Variable start wird rot marktiert beim kompilieren. Das bedeutet sie wird von der Arduino IDE schon verwendet. Also Namen ändern.

Desweiteren funktioniert Dein Sketch zwar, aber wenn Du nur den 2. Hallsensor ständig schalten würdest, bekommst Du unsinnige Werte, weil Deine Startzeit veraltet ist.

Hab das mal mit if und while geändert. Die Messung startet erst, wenn der erste Hallsensor sein Low Signal liefert. Egal was vorher der 2. Sensor macht. Dann wird mittels while gewartet bis der 2. Sensor sein Low Signal liefert. Damit ist die Messung beendet. Die LED signalisiert jetzt das eine Messung läuft, nicht mehr das ein einzlner Sensor geschalten hat. Jetzt kannst Du weitere Sensoren mittels while einbauen um vielleicht Zwischenergebnisse von Teilstrecken zu erhalten.

sollte eigentlich funktionieren:

Code:
const int HallSens_1 = 9;     
const int HallSens_2 = 12;     
const int ledPin =  13;     

unsigned long time_1, time_2, elapsed;

void setup() {
 
  pinMode(ledPin, OUTPUT);      // initialize the LED pin as an output:
  pinMode(HallSens_1, INPUT);   // initialize the hall effect sensor pin as an input:
  pinMode(HallSens_2, INPUT);   // initialize the hall effect sensor pin as an input:
 
  Serial.begin(9600); 
}

void loop() {
 
  if (digitalRead(HallSens_1) == LOW)   // start Stopwatch, wenn 1. Hallsensor auf LOW   
    {
     time_1 = micros();                 // 1. Zeitnahme
     digitalWrite(ledPin, HIGH);        // turn LED on "Messung gestartet"
         
     while (digitalRead(HallSens_2) == HIGH) {}  // wenn 2. Hallsensor auf HIGH, warten bis wieder LOW
     time_2 = micros();                          // 2. Zeitnahme
     
     digitalWrite(ledPin, LOW);         // turn LED off "Messung beendet"
     
     // Berechungen und Ausgaben 
     elapsed = time_2 - time_1;        // Differenz bilden
     Serial.print("Start: "); Serial.print(time_1);  Serial.println(" microseconds");
     Serial.print("Ende: ");  Serial.print(time_2);  Serial.println(" microseconds");
     Serial.print("Dauer: "); Serial.print(elapsed); Serial.println(" microseconds");
    }   
   
}  // Ende loop
13  International / Deutsch / Re: Lineare Geschwindigkeitsmessung? (Hallsensor?) on: April 12, 2014, 11:36:49 am
Hallo,

in Deiner Meßfunktion werden 2 Meßwerte gespeichert. start und finished. Diese sind immer vorhanden, brauchst Du ja immer für jede Messung. Was Du damit machst, ist dann Deine Sache.

  start=micros();
  finished=micros();   

Diese werden bei Dir z.Z. am Ende miteinander verrechnet und Du bekommst immer nur die Differenz der beiden angezeigt. Wenn Du die Start und Endzeit sehen möchtest, mußt Du diese nur zusätzlich ausgeben lassen.

Serial.print("Start: "); Serial.print(start);
Serial.print("Ende: "); Serial.print(finished);
14  International / Deutsch / Re: I2C - PCF8574 Portexpander on: April 12, 2014, 11:23:35 am
Hallo,

habe mich heute nochmal mit I2C beschäftigt. Man kann zwar vielen fragen und lesen, verstehen kommt erst später mit probieren.

Also. Wenn ein I2C Device nur ein Register hat, üblicherweise 0x00, dann sind diese Zeilen ausreichend?  

Code:
byte lesen_PCF8574(int I2C_Adresse)
{
  byte data = 0xFF;
  if (Wire.requestFrom(I2C_Adresse, 1)) data = Wire.read();           // ein Byte (8 Bit) anfordern
  return data;
}  

Wenn ein I2C Device mehrere Register hat, zum Bsp. RTC DS3231, dann muß man mit  Wire.beginTransmission() arbeiten, wenn man mittendrin und nicht unbedingt bei Register 0x00 anfangen möchte zu lesen?  Das Wire.available() kann man weiterhin weglassen? Scheint ja zu funktionieren. So korrekt?

Code:
Wire.beginTransmission(ds3231_adress);   // Connect
 Wire.write(0x04);                        // Anfrage der Register Nummer
 Wire.endTransmission();                  // Connect fertig
 Wire.requestFrom(ds3231_adress, 3);      // Wieviel Bytes in Folge auslesen?
  
 byte Tag = Wire.read();                  // die 3 Bytes hintereinander auslesen, BCD Format
 byte Monat = Wire.read();
 byte Jahr = Wire.read();
15  International / Deutsch / Re: Datalogger + WifiWebServer - Problem bei Client anfragen! on: April 11, 2014, 06:50:34 am
Hallo,

wie festgestellt wurde, blockierst Du mit while den Rest vom Code während Du Impulse zählst. Nimmst Du if statt while und kannst damit auf Clientanfragen reagieren, gehen Dir jedoch Impulse verloren, während Du den Client bedienst. Jetzt merkst Du schon, Du kannst eigentlich machen was Du willst, es wird nicht zu 100% perfekt.

Die Frage wäre, wie oft kommt eine Clientanfrage rein? Kann man das abschätzen?

Teurere Lösung:
2. µC nehmen der Imulse zählt und der vom 1. µC abgefragt wird wenn er Zeit hat und damit immer nur den aktuellsten Wert geliefert bekommt.

günstigste Lösung:
bei einem µC bleiben und je nachdem was wichtiger ist, könnte man:
der Impulszählung Vorrang geben, eine Clientanfrage in einer Variable speichern und wenn die Impulszählung fertig ist, fragt man die Variable ab ob eine Anfrage kam, wenn ja bedient man den Client verspätet. Kann natürlich sein der Client bekommt dadurch manchmal einen Timeoutfehler.

oder der Clientanfrage Vorrang geben, man läßt Impulse zählen, sobald eine Clientanfrage reinkommt, bedient man den Client, verwirft damit die Impulsmessung und fängt von vorn an mit der Impulsmessung. Nachteil hier, wenn viele Clientanfragen reinkommen, hat man möglicherweise nie die Möglichkeit eine Messung durchführen zu lassen.

3. Idee wäre, man läßt die Impulse mittels Interrupt zählen.
Also permanent läuft der Code der die Clientanfragen bedienen kann und im "Hintergrund" löst jeder Impuls einen Interrupt aus, dieser zählt in einer kleinen/kurzen Funktion die Impulse. Der Rest der Rechung muß im Hauptsketch erfolgen. Der Code für den Interrupt sollte so kurz wie möglich sein, sonst blockiert er wiederum den loop zu lange. Bzw. im dümmsten Fall dauert die Interruptfunktion länger wie die Zeit zwischen den Impulsen, dann gehen Dir auch Impulse verloren. Ich weis ja nicht wieviel U/min du bekommst. Ein µC Takt dauert 62,5ns.

Das wäre mein Theorieansatz.


Pages: [1] 2 3 ... 38