Skocz do zawartości

ESP32 - licznik do rowerka treningowego


Pomocna odpowiedź

(edytowany)

Tak jak napisał @kaczakat ...licz czas pełnego obrotu (stan niski/wysoki) i wtedy będziesz miał co obrót aktualna realną prędkość, a nie tak jak teraz 5/10/15/20km itp...tak jak @etet100 wspomniał, tu jest strasznie niska częstotliwość impulsów i wyniki będą kosmicznie zakłamane...

Edytowano przez farmaceuta

Ok, kumam koncepcję z liczeniem czasu. Tylko moja wyobraźnia nie ogarnia co z tym czasem później zrobić, w sensie, jak go wykorzystać do przeliczenia czegoś dalej...😐

13 minut temu, roz napisał:

Tylko moja wyobraźnia nie ogarnia co z tym czasem później zrobić, w sensie, jak go wykorzystać do przeliczenia czegoś dalej...😐

Jeden obrót powiedzmy zajął Ci 0.8s znając czas i obwód koła możesz sobie łatwo wyliczyć ile km jedziesz na h...

float obroty_kola = 3600 / czas_obrotu; //w sekundach 
float km_h = (obroty_kola * obwod_kola) / 1000;  //predkosc km/godzina

 

  • Lubię! 1

Skoro umiesz przeliczyć 3 imp/s, to jak zmierzysz 0.3s to masz 1/0.3=3.33 impulsów/s, f=1/T. 

Możesz po prostu szybciej pedałować i nie martwić się się wskazaniami.

Mając to co teraz możesz też uśredniać, poprzedni pomiar dodajesz do aktualnego i ta suma/2.

5 minut temu, kaczakat napisał:

Skoro umiesz przeliczyć 3 imp/s, to jak zmierzysz 0.3s

Mam mierzyć czas pełnego obrotu, którego nie napisałem w kodzie bo jest to oczywiste że trzeba...ja przyjąłem sekundy jako jednostka czasu (sekundy float) ale czas i tak trzeba mierzyć w milisekundach i albo sobie przeliczyć to później na sekundy (chociaż można też godzinę podać w ms i wtedy nic nie trzeba przeliczać na sekundy, posobow jest tysiąc)

(edytowany)

- za długo siedzisz w przerwaniu to jest esp32 on tego nie lubi.

void IRAM_ATTR counterUp()
{
    unsigned long now = millis();
    if (now < next_pulse)
    {
        return;
    }

    counter++;
    next_pulse = now + 10; // następny impuls za nie mniej niż 10ms
}

- to moje z programu, widzisz jakąś róznicę ?

	// -------- rotary ------------
void IRAM_ATTR  checkPosition()
{
  encoder.tick();           // just call tick() to check the state.
}
	
	// --------- Timer ---
void IRAM_ATTR onTimer() 
{ 
	faceTimer = 1;			// nic wiecej ###
}	
	

 

Edytowano przez 99teki

Hej, po kilkunastu próbach chwilowo wymiękam.

Kod poniżej. Musiałem rozbić na kawałki obliczenia bo leciały wyjątki "integer divided by zero" - po rozbiciu obliczeń na kawałki problem zniknął.

Niestety pomiary skaczą nadal 😞

Wszystkie sugestie przyjmuję.

 

#include <Arduino.h>

#define reed_pin 35

hw_timer_t *timer = NULL;
volatile int oldcnt;
volatile unsigned long old_counter = 1, counter = 0, next_pulse = 0;
//
volatile int revolutions = 0;      // Liczba obrotów koła
unsigned long timeold = 0;         // Czas ostatniego pomiaru
float wheelDiameter = 0.7;         // Średnica koła w metrach
float pi = 3.14159265358979323846; // Wartość liczby pi
float distance = 0;                // Przebyty dystans
float speed = 0;                   // Prędkość

//

void IRAM_ATTR counterUp()
{

    unsigned long now = millis();
    if (now < next_pulse)
    {
        return;
    }

    counter = millis();
    next_pulse = now + 10; // następny impuls za nie mniej niż 10ms
}

void setup()
{
    Serial.begin(115200);
    pinMode(reed_pin, INPUT);
    attachInterrupt(digitalPinToInterrupt(reed_pin), counterUp, FALLING);
}

void loop()
{
    unsigned long timenow = millis();
    if ((counter) > 0)
    {
        //Serial.println(timenow - counter);
        //Serial.print("Counter: ");
        //Serial.println(counter);
        //Serial.print("timenow: ");
        //Serial.println(timenow);
        float tmp = (timenow - counter);
        //Serial.print("tmp: ");
        //Serial.println(tmp);
        float tmp2 = tmp / 1000;
        //Serial.print("tmp2: ");
        //Serial.println(tmp2);
        float obroty = 3600 / tmp2;
        //Serial.print("Obroty: ");
      
        //Serial.println(obroty);
        float test = (obroty * 0.74);
        //Serial.print("test: ");
        //Serial.println(test);
        float km_h = test / 1000;
        //float km_h = (obroty * 0.74) / 1000; // predkosc km/godzina
        Serial.print("km/h: ");
        Serial.println(km_h);
    }
    else
    {
        Serial.println("nic tu nie ma...");
    }

    delay(700);
}
16:46:28:430 -> km/h: 10.74
16:46:29:129 -> km/h: 2.81
16:46:29:830 -> km/h: 6.43
16:46:30:530 -> km/h: 18.12
16:46:31:229 -> km/h: 3.15
16:46:31:930 -> km/h: 4.47
16:46:32:629 -> km/h: 7.14
16:46:33:330 -> km/h: 15.22
16:46:34:030 -> km/h: 95.14
16:46:34:730 -> km/h: 3.92
16:46:35:429 -> km/h: 5.49
16:46:36:130 -> km/h: 8.40
16:46:36:830 -> km/h: 18.50
16:46:37:530 -> km/h: 98.67
16:46:38:229 -> km/h: 3.91
16:46:38:929 -> km/h: 4.69
16:46:39:629 -> km/h: 5.72
16:46:40:329 -> km/h: 6.74
16:46:41:029 -> km/h: 7.09
16:46:41:729 -> km/h: 6.76
16:46:42:429 -> km/h: 6.20
16:46:43:129 -> km/h: 5.31
16:46:43:829 -> km/h: 85.94
16:46:44:529 -> km/h: 16.65
16:46:45:229 -> km/h: 9.06
16:46:45:929 -> km/h: 5.97
16:46:46:629 -> km/h: 43.67
16:46:47:329 -> km/h: 11.68
16:46:48:029 -> km/h: 6.64
16:46:48:729 -> km/h: 39.18
16:46:49:429 -> km/h: 10.41
16:46:50:134 -> km/h: 2.79
16:46:50:829 -> km/h: 1.61
16:46:51:529 -> km/h: 1.13
16:46:52:229 -> km/h: 0.87
16:46:52:929 -> km/h: 0.71
16:46:53:629 -> km/h: 0.60
16:46:54:329 -> km/h: 0.52
16:46:55:029 -> km/h: 0.45
16:46:55:729 -> km/h: 0.41
16:46:56:429 -> km/h: 0.37
16:46:57:129 -> km/h: 0.33
16:46:57:829 -> km/h: 0.31

 

A tutaj po usunięciu delay(700); z kodu:

 

16:54:27:251 -> km/h: 6.85
16:54:27:251 -> km/h: 6.85
16:54:27:251 -> km/h: 6.85
16:54:27:251 -> km/h: 6.85
16:54:27:251 -> km/h: 6.85
16:54:27:251 -> km/h: 6.85
16:54:27:251 -> km/h: 532.80
16:54:27:251 -> km/h: 532.80
16:54:27:251 -> km/h: 532.80
16:54:27:251 -> km/h: 532.80
16:54:27:251 -> km/h: 532.80
16:54:27:251 -> km/h: 532.80
16:54:27:251 -> km/h: 532.80
16:54:27:251 -> km/h: 444.00
16:54:27:251 -> km/h: 444.00
16:54:27:251 -> km/h: 444.00
16:54:27:251 -> km/h: 166.50
16:54:27:251 -> km/h: 166.50
16:54:27:251 -> km/h: 166.50
16:54:27:251 -> km/h: 156.71
16:54:27:251 -> km/h: 156.71
16:54:27:251 -> km/h: 156.71
16:54:27:251 -> km/h: 156.71
16:54:27:251 -> km/h: 156.71
16:54:27:295 -> km/h: 156.71
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 444.00
16:54:27:295 -> km/h: 380.57
16:54:27:295 -> km/h: 380.57
16:54:27:295 -> km/h: 156.71
16:54:27:295 -> km/h: 156.71
16:54:27:295 -> km/h: 156.71
16:54:27:295 -> km/h: 156.71
16:54:27:295 -> km/h: 148.00
16:54:27:295 -> km/h: 148.00
16:54:27:295 -> km/h: 148.00
16:54:27:295 -> km/h: 148.00
16:54:27:295 -> km/h: 148.00
16:54:27:295 -> km/h: 95.14
16:54:27:295 -> km/h: 95.14
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 91.86
16:54:27:295 -> km/h: 66.60
16:54:27:295 -> km/h: 66.60
16:54:27:295 -> km/h: 66.60
16:54:27:295 -> km/h: 66.60
16:54:27:295 -> km/h: 66.60
16:54:27:295 -> km/h: 66.60
16:54:27:295 -> km/h: 64.98
16:54:27:340 -> km/h: 64.98
16:54:27:340 -> km/h: 64.98
16:54:27:340 -> km/h: 64.98
16:54:27:340 -> km/h: 52.24
16:54:27:340 -> km/h: 52.24
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 51.23
16:54:27:340 -> km/h: 42.29
16:54:27:340 -> km/h: 42.29
16:54:27:340 -> km/h: 42.29
16:54:27:340 -> km/h: 42.29
16:54:27:340 -> km/h: 42.29
16:54:27:340 -> km/h: 42.29
16:54:27:340 -> km/h: 42.29

 

Nie rozumiem o co chodzi....

Jak to esp32 liczy!?

    Serial.print("start ");
    Serial.println(pulse_start_time);
    Serial.print("end");
    Serial.println(pulse_end_time);
    
    Serial.print("Czas trwania impulsu: ");
    Serial.print(pulse_end_time - pulse_start_time);
    Serial.println(" milisekund");

///WYNIK:


17:34:49:989 -> start 137532
17:34:49:989 -> end 133855
17:34:49:989 -> Czas trwania impulsu: 4294963619 milisekund

 

(edytowany)

@roz po co Ci timer?? Przerwanie jeszcze rozumiem ale timer'a nie...🤔 Zaraz coś nabazgram może... 

Edit...aha! Używasz tego głupiego kontaktowa a on chyba ma drgania styków więc sposób który zaproponowałem będzie działał źle jeśli nie będzie programowej eliminacji drgania styków...najlepiej jak byś wywalił to dziadostwo i dał czujnik halla...są takie popularne po złotówce? Więc nie ma się nad czym zastanawiać...

Edytowano przez farmaceuta
58 minut temu, roz napisał:
float tmp = (timenow - counter);

W tej operacji obliczasz różnicę czasu pomiędzy chwilą obecną (wynikającą z obiegu pętli loop()) a chwilą uchwyconą przez przerwanie. Jest to wartość w dużej mierze przypadkowa. Powinieneś obliczać różnicę czasu pomiędzy kolejnymi przerwaniami. Masz juz nawet zadeklarowaną zmienną old_counter.

Przed tą linijką 

58 minut temu, roz napisał:
float obroty = 3600 / tmp2;

dobrze jest sprawdzić czy nie dzielimy przez zero.

21 minut temu, roz napisał:

Nie rozumiem o co chodzi....

Jak to esp32 liczy!?

Czas startu jest większy od czasu końca, więc z odejmowania wychodzi liczba ujemna i następuje przepełnienie zmiennej.

Bądź aktywny - zaloguj się lub utwórz konto!

Tylko zarejestrowani użytkownicy mogą komentować zawartość tej strony

Utwórz konto w ~20 sekund!

Zarejestruj nowe konto, to proste!

Zarejestruj się »

Zaloguj się

Posiadasz własne konto? Użyj go!

Zaloguj się »
×
×
  • Utwórz nowe...