Raspberry Laufzeit in millisekunden

[Simo (Gast)]

Hallo,

wie komme ich unter mit C (unter Raspbian auf den Raspberry) an die 
Laufzeit in Millisekunden?

aus der Zum Wörterbuch hinzufügen kenne ich den Befehl millis(); leider 
ist der beim PI nicht Standard implementiert.

Vielen Dank

[Christophe J. (chj)]

https://en.wikipedia.org/wiki/C_date_and_time_functions

[Rolf M. (rmagnus)]

Siehe "man clock_gettime".

[asdf (Gast)]

Simo schrieb:
> aus der Zum Wörterbuch hinzufügen kenne ich den Befehl millis(); leider
> ist der beim PI nicht Standard implementiert.

So weit ich das sehe, ist millis() eine Funktion, die im Arduino 
verwendet wird. Und auf dem PI läuft kein Arduino, sondern Linux.
Weil millis() nicht zum Sprachumfang von C gehört, ist es auch nicht 
sinnvoll, wenn du sagst, daß der PI "nicht standard implementiert" ist.
Schau mal nach den Zeitfunktionen von C. Links dafür hast du ja schon 
bekommen. Und die Suchmaschine wird dir sicher auch einiges verraten. 
Unter anderem auch Beispiele, wie man die C-Funktionen verwendet.

[PittyJ (Gast)]

man gettimeofday

[Johnny B. (johnnyb)]

Wenn ich "Millisekunden" im Zusammenhang mit Raspberry und Raspbian 
höre, läuten bei mir die Alarmglocken.
Raspbian ist kein Echtzeitbetriebssystem, dem muss man sich bewusst 
sein. Selbst wenn es so eine Funktion gäbe, wäre die Genauigkeit nicht 
vorhersehbar.

[Peter II (Gast)]

Johnny B. schrieb:
> Wenn ich "Millisekunden" im Zusammenhang mit Raspberry und Raspbian
> höre, läuten bei mir die Alarmglocken.
> Raspbian ist kein Echtzeitbetriebssystem, dem muss man sich bewusst
> sein. Selbst wenn es so eine Funktion gäbe, wäre die Genauigkeit nicht
> vorhersehbar.

warum sollte die Genauigkeit nicht vorhersehbar sein? Auch eine Rapsi 
hat Timer die sehr genau sind und diese werden dafür nur abgefragt.

Du meinst das Timing eines kompletten Programm, ja das ist nicht auf die 
MS genau vorhersehbar. Aber die Zeit selber ist kein Problem.

[Simo (Gast)]

vielen Dank für die nachrichten...

joa millis() kenn ich von Arduino <- weiß nich was für nen kack ich da 
oben geschrieben habe, aber vermutlich war ich opfer der Autokorrektur 
und habs nicht gemerkt.

Genauigkeit ist nicht so wichtig... ich möchte im 400ms und im 700ms 
takt 2 tools abfrage / starten

dazu brauch ich eine whileschleife die dauerläuft

definiere timer, old1, old2; 
dauer1 = 400;
dauer2 = 700;

while(1){
  timer = JETZT[ms]

  if( old1 + dauer1 < timer ) {
    old1 = timer //update old1
    machwas 1;
  }

  if( old2 + dauer2 < timer ) {
    old2 = timer //update old2
    machwas 2;
  }


}

leider bekomm ichs auf dem PI nicht hin :(

ob das jetzt 50ms eher oder später kommt ist VÖLLIG egal... ebenso kann 
es sein, dass "machwas 1" mit "machwas 2" kollidiert und dann eines auf 
das andere warten muss (das wären dann ~4-6ms), aber das ist völlig 
egal!

Vielen Dank

[Christoph db1uq K. (christoph_kessler)]

Mit Python und pigpio geht es recht genau, ein paar Mikrosekunden sollen 
es angeblich sein. Der Trick ist, schnell zwei Zeitpunkte zu erfassen 
und in Ruhe danach die Zeitdifferenz auszurechnen:

Das hier habe ich vor ein paar Tagen gepostet, aus einem anderen 
Programm umgeschrieben.
https://www.raspberrypi.org/forums/viewtopic.php?f=28&t=134270&start=25

def WaitDRDY():
    start = pi.get_current_tick()
    elapsed = pi.get_current_tick() - start
    # Waits for DRDY to go to zero or TIMEOUT seconds to pass
    drdy_level = pi.read(17) # ADS1256 /DRDY
    while (drdy_level == 1) and (elapsed < 500000):
        elapsed = pi.get_current_tick() - start
        drdy_level = drdy_level = pi.read(17)
    if elapsed >= 800000:
        print("WaitDRDY() Timeout\r\n")

[R. M. (rmax)]

Simo schrieb:

> dazu brauch ich eine whileschleife die dauerläuft

Solche Busy-Loops sind unter Multitasking-Betriebssystemen wie Linux 
meist keine gute Idee, weil sie unnötig Rechenzeit verbraten. 
Stattdessen gibt es Möglichkeiten, einen Prozeß schlafen zu legen "bis 
seine Zeit gekommen ist". Während der Wartezeit kann die CPU dann 
entweder andere Prozesse bearbeiten oder Strom sparen.

Schau Dir mal select() an, damit kann man sowas machen.

[Operator S. (smkr)]

oben genannt wurde ja schon clock_gettime()
nimm nun noch nanosleep hinzu und schon hast du deine wartefunktion ohne 
busy waiting

Wenns dir nicht um die Genauigkeit geht, kannst du auch sowas machen:

struct timespec sleepTime;

sleepTime.tv_nsec = 100000000; //100ms
sleepTime.tv_sec = 0;

int dauer1 = 0;
int dauer2 = 0;
while(1){

  nanosleep(&sleepTime, NULL);

  if(dauer1 > 3 ) {
    dauer1 = 0 //update old1
    machwas 1;
  } else {
    dauer1++;
  }

  if( dauer2 >6 ) {
    dauer2 = 0 //update old2
    machwas 2;
  } else {
    dauer2++;
  }

}

so als quick&dirty Lösung, ansonsten 2 Threads machen mit der jeweils 
eigenen nanosleep Zeit.

[Simo (Gast)]

@Christoph Kessler:
Python kommt nicht in Frage...

@R. Max
Select klingt spannend, leider finde ich nur wenig lösungen dir mir 
helfen, da ich zu schnell im datenbanksektor bin...
evtl. kannst du mir ne genauere erläuterung geben

@Operator S.
die idee ist gut... werde ich nochmal "genauer" verfolgen :) ...

=> trotzalledem würden mich "multithreads" noch mehr interessieren...
wie kann ich zwei sachen "gleichzeitig" abarbeiten, ohne dass diese sich 
in die quere kommen <- bisher habe ich immer nur ein Programm, dass mehr 
oder weniger von oben nach unten abarbeitet ...


Dankööö

[Operator S. (smkr)]

Schau dir pthread an oder generell POSIX Threads. Ist am Anfang etwas 
hakelig wenn man sich nur sequentielle Programmierung gewohnt ist, aber 
wenn mans mal raus hat, ist man auch schneller gewillt threads 
einzusetzen statt alles in einem. Definitiv die Einarbeitungszeit wert, 
auch wenns etwas länger dauern sollte. Nicht aufgeben!
Bei C++ hättest du auch std::thread, wenn das eine Option für dich ist.

[R. M. (rmax)]

Simo schrieb:

> @R. Max
> Select klingt spannend, leider finde ich nur wenig lösungen dir mir
> helfen, da ich zu schnell im datenbanksektor bin...
> evtl. kannst du mir ne genauere erläuterung geben

Hier ertsmal die Doku zu select():
http://man7.org/linux/man-pages/man2/select.2.html

Damit kann man auf Ereignisse ("es sind neue Daten angekommen" bzw. "es 
können Daten abgeschickt werden") auf mehreren Filedeskriptoren (offenen 
Dateien oder Netzwerkverbindungen) gleichzeitig warten und zusätzlich 
einen Timeout setzen, nach dessen Ablauf der Aufruf in jedem Fall 
zurückkehrt. Läßt man die Filedeskriptoren weg und setzt nur den 
Timeout, macht select() im Grunde das gleiche wie nanosleep(), 
allerdings mit einer zeitlichen Auflösung in Mikrosekunden statt 
Nanosekunden.

Als Alternative zu einem festen Takt (einfach, aber unflexibel) oder 
Threads (halte ich hier für Overkill) könntest Du jeweils ausrechnen, 
wieviel Zeit bis zum nächsten Ereignis noch vergehen muß und die Zeit 
für select() oder nanosleep() dementsprechend setzen.

[Christoph db1uq K. (christoph_kessler)]

http://abyz.co.uk/rpi/pigpio/
pigpio läuft auch mit C, das ist nicht an Python gebunden. Im 
Raspbian-Image ist es schon vorinstalliert.
Die Quellen sind auf Github:
https://github.com/joan2937/pigpio