Błędny odczyt prędkości w liczniku rowerowym Arduino-Dem

[Gintek]

Witam zakupiłem sobie taki zestaw https://blaberk.com.pl/arduino/arduino_licznik_rower.html i wszystko byłoby dobrze żeby ten licznik nie przekłamywał pokazywanej prędkości. Doszedłem do wniosku że wina leży w miejscu umieszczenia magnesu z czujnikiem. Im dalej od środka koła tym prędkość pokazywana jest większa. Licznik dokonuje pomiaru na podstawie długości czasu między impulsami. I mimo że obroty są stałe to im bardziej się odsuwa magnes od osi koła czas impulsu maleje co za tym idzie pokazywana prędkość rośnie. Takie zjawisko uniemożliwia praktyczne zastosowanie tego urządzenia. Docelowo licznik ma być zamontowany w ciągniku a czujnik z magnesem jest zamontowany przy wale napędowym. Minimalna częstotliwość jeden impuls na sekundę a maksymalna 2000 impulsów na sekundę. Na jeden pełny obrót wału ciągnik pokonuje drogę 23cm. Za wszelką pomoc byłbym wdzięczny bo już siedzę nad tym od kilku dni. Program trochę sam modyfikowałem.

/* Arduino-DEM jako licznik rowerowy
Rysowanie bitmapy skali 
 * FreqCount - Example with serial output
 * http://www.pjrc.com/teensy/td_libs_FreqCount.html
*/

#include <Arduino.h>
#include <U8g2lib.h>
#include <EEPROM.h>
#include <FreqCount.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, 11, 8, 13, 12, U8X8_PIN_NONE);

#define skala_1_width 104
#define skala_1_height 41
static const unsigned char skala_1_bits[] PROGMEM = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8,
   0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff,
   0x0b, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x2f,
   0x00, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xbf, 0x00,
   0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x02, 0xa0,
   0x00, 0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9e, 0x02,
   0xa0, 0x00, 0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x81,
   0x02, 0xa0, 0x00, 0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1c,
   0x80, 0x02, 0xa0, 0x00, 0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x80,
   0x05, 0x80, 0x02, 0xa0, 0x00, 0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x00,
   0x60, 0x09, 0x80, 0x04, 0xa0, 0x00, 0x28, 0x00, 0x0a, 0x80, 0x00, 0x00,
   0x00, 0x18, 0x0a, 0x80, 0x04, 0xa0, 0x00, 0x28, 0x00, 0x0a, 0x80, 0x00,
   0x00, 0x00, 0x06, 0x12, 0x80, 0x04, 0xa0, 0x00, 0x28, 0x00, 0x0a, 0x80,
   0x00, 0x00, 0x00, 0x01, 0x14, 0x00, 0x05, 0xa0, 0x00, 0x28, 0x00, 0x0a,
   0x80, 0x00, 0x00, 0xc0, 0x00, 0x24, 0x00, 0x05, 0xa0, 0x00, 0x28, 0x00,
   0x0a, 0x80, 0x00, 0x00, 0x20, 0x00, 0x28, 0x00, 0x05, 0xa0, 0x00, 0x28,
   0x00, 0x0a, 0x80, 0x00, 0x00, 0x48, 0x00, 0x48, 0x00, 0x05, 0xa0, 0x00,
   0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x94, 0x00, 0x50, 0x00, 0x05, 0xa0,
   0x00, 0x28, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x23, 0x01, 0x90, 0x00, 0x05,
   0xbf, 0xff, 0xef, 0xff, 0xfb, 0xff, 0x00, 0x80, 0x40, 0x02, 0xa0, 0x00,
   0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0x04, 0x20,
   0xf9, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x09,
   0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
   0x12, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
   0x00, 0x24, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x30, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x44, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x9a, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x21, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x80, 0x40, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc0, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x16, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0x08,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
   0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00 };

#define skala1a_width 13
#define skala1a_height 9
static const unsigned char skala1a_bits[] PROGMEM  = {
   0x30, 0x16, 0xf8, 0x08, 0xf8, 0x03, 0xfc, 0x07, 0xfc, 0x03, 0xfe, 0x01,
   0xfe, 0x01, 0xff, 0x00, 0xff, 0x00 };

#define skala2a_width 13
#define skala2a_height 11
static const unsigned char skala2a_bits[] PROGMEM  = {
   0x20, 0x02, 0xf0, 0x04, 0xf8, 0x19, 0xfc, 0x03, 0xfe, 0x0f, 0xfe, 0x1f,
   0xff, 0x0f, 0xff, 0x07, 0xfc, 0x01, 0xf1, 0x00, 0x47, 0x00 };

#define skala3a_width 18
#define skala3a_height 14
static const unsigned char skala3a_bits[] PROGMEM  = {
   0x00, 0x09, 0x00, 0x80, 0x13, 0x00, 0xe0, 0x27, 0x00, 0xf0, 0x4f, 0x00,
   0xf8, 0x9f, 0x00, 0xfc, 0x3f, 0x01, 0xfe, 0x7f, 0x02, 0xff, 0xff, 0x00,
   0xfe, 0xff, 0x01, 0xf8, 0xff, 0x03, 0xf3, 0x7f, 0x00, 0xe7, 0x1f, 0x00,
   0x8f, 0x07, 0x00, 0x3f, 0x01, 0x00 };

#define skala4a_width 18
#define skala4a_height 16
static const unsigned char skala4a_bits[] PROGMEM  = {
   0x00, 0x2c, 0x00, 0x00, 0x4f, 0x00, 0xc0, 0x5f, 0x00, 0xf0, 0x9f, 0x00,
   0xf8, 0xbf, 0x00, 0xfe, 0x3f, 0x01, 0xff, 0x7f, 0x01, 0xfe, 0x7f, 0x02,
   0xfc, 0xff, 0x02, 0xf9, 0xff, 0x00, 0xf3, 0xff, 0x01, 0xe7, 0xff, 0x01,
   0xcf, 0xff, 0x03, 0x9f, 0xff, 0x03, 0x3f, 0x3f, 0x00, 0x7f, 0x06, 0x00 };

#define skala5a_width 15
#define skala5a_height 17
static const unsigned char skala5a_bits[] PROGMEM  = {
   0x00, 0x38, 0x80, 0x3f, 0xf8, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xfe, 0x3f,
   0xfe, 0x3f, 0xfc, 0x3f, 0xfd, 0x7f, 0xf9, 0x7f, 0xfb, 0x7f, 0xf3, 0x7f,
   0xf7, 0x7f, 0xe7, 0x7f, 0xef, 0x7f, 0xcf, 0x7f, 0xdf, 0x01 };

#define skala6a_width 13
#define skala6a_height 16
static const unsigned char skala6a_bits[] PROGMEM  = {
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f,
   0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f,
   0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0x7e, 0x00 };

#define skala7a_width 13
#define skala7a_height 16
static const unsigned char skala7a_bits[] PROGMEM  = {
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f,
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f,
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f };

#define skala8a_width 13
#define skala8a_height 17
static const unsigned char skala8a_bits[] PROGMEM  = {
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f,
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f,
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f };

#define skala9a_width 13
#define skala9a_height 18
static const unsigned char skala9a_bits[] PROGMEM  = {
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f,
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f,
   0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f, 0xff, 0x1f };

//input_pin = D5
//Zmienne do pomiaru prędkości 
float count, count1, count2;
int zmienna1, zmienna, zmienna2;
char m_str2[6];
char m_str1[6];
String m1_str, m2_str;
int pin = 5;
unsigned long duration;
  //                                              //promień koła w metrach
float d_kola = 0.231;
//zmienne do obliczenia długosci drogi
int lok;                                                          //liczba obrotów koła 
float d_etapu, de_km;                                             //długość etapu, odległość w km
int d_total;                                                      //odległość całkowita od początku
char d_tot_str[6];
int de_int,  de_int1, de_dz;
char de_str[3], de1_str[3];
//zmienne do pomiaru czasu
byte godz, minuty, sekundy;
unsigned long czas_e;                                             //całkowity czas etapu
char godz_str[3], minuty_str[3], sekundy_str[3];
//zmienne do pomiaru temperatury
int ThermistorPin = 0;
int Vo;                                                           //napięcie zmierzone na wejsciu A0
float R1 = 10000;                                                 //wartość rezystora zewn. = 10koHm
float logR2, R2, T, Tc, Tf;
float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
char mt_str[3], dt_str[2];
byte mt, dt;
 

void setup(void) {
  u8g2.begin(); 
  Serial.begin(9600);
   FreqCount.begin(1000);
  //pinMode(pin, INPUT_PULLUP);                                   //linia do współpracy z kontaktronem
  pinMode(pin, INPUT);                                            //linia do współpracy z hallotronem
                                      //obwód kola
}

void loop(void) {
  Speed();
  Temperatura();
  d_total = readFromEEPROM();
  Dystans();
  Czas();
  sprintf(d_tot_str," %d km", d_total); 
  u8g2.firstPage();
  do {
      Rysuj_skale();
      //wypisanie prędkości
      u8g2.setFont(u8g2_font_logisoso16_tn);
      
      //równanie wyniku pomiaru do ostatniej cyfry//wyciete
      if (m1_str.length() == 1 ) {
        u8g2.drawStr(100, 63, m_str2);
        u8g2.drawStr(95,63,".");
        u8g2.drawStr(85,63, m_str1);}   //dla wyniku 1-cyfrowego
      if (m1_str.length() == 2 ) {
        u8g2.drawStr(100, 63, m_str2);
        u8g2.drawStr(95,63, ".");
        u8g2.drawStr(75,63, m_str1);}   //dla wyniku 2-cyfrowego
      if (m1_str.length() == 3 ) {
      u8g2.drawStr(100, 63, m_str2);
      u8g2.drawStr(95,63, ".");
       u8g2.drawStr(65, 63, m_str1);}   //dla wyniku 3-cyfrowego
      if (m1_str.length() == 4 ) {
        u8g2.drawStr(100, 63, m_str2);
        u8g2.drawStr(95,63, ".");
       u8g2.drawStr(55, 63, m_str1);}   //dla wyniku 4-cyfrowego// wyciete
      u8g2.setFont(u8g2_font_profont11_tf);
      


      
      //wypisanie długosci etapu
      u8g2.drawStr(1,7,de_str);
      u8g2.drawStr(11,7,".");
      u8g2.drawStr(16,7,de1_str);
      u8g2.drawStr(31,7,"."); 
      u8g2.drawStr(40,7,"km"); 
      //wypisanie kilometrażu całkowitego
      u8g2.drawStr(70,7,d_tot_str);
      //wypisanie czasu etapu
      u8g2.drawStr(1,18,godz_str);
      u8g2.drawStr(11,18,":");
      u8g2.drawStr(16,18,minuty_str); 
      u8g2.drawStr(27,18,":"); 
      u8g2.drawStr(32,18,sekundy_str); 
      //wypisanie temperatury     
      u8g2.drawStr(1,29,mt_str);
      u8g2.drawStr(11,29,".");
      u8g2.drawStr(17,29,dt_str); 
      u8g2.drawGlyph(22,29,176);
      u8g2.drawStr(30,29,"C"); 
   } while ( u8g2.nextPage() );
   delay(50);
}

void Rysuj_skale(void) {
u8g2.drawXBMP(24,22,skala_1_width,skala_1_height,skala_1_bits);                          //pusta skala
if ( zmienna1 >= 1) {u8g2.drawXBMP(24,55,skala1a_width,skala1a_height,skala1a_bits); }     //1-segment
if ( zmienna1 >= 3) {u8g2.drawXBMP(29,46,skala2a_width,skala2a_height,skala2a_bits); }     //2-segment
if ( zmienna1 >= 6) {u8g2.drawXBMP(35,37,skala3a_width,skala3a_height,skala3a_bits); }    //3-segment
if ( zmienna1 >= 9) {u8g2.drawXBMP(45,30,skala4a_width,skala4a_height,skala4a_bits); }    //4-segment
if ( zmienna1 >= 13) {u8g2.drawXBMP(58,26,skala5a_width,skala5a_height,skala5a_bits); }    //5-segment
if ( zmienna1 >= 17) {u8g2.drawXBMP(73,25,skala6a_width,skala6a_height,skala6a_bits); }    //6-segment
if ( zmienna1 >= 21) {u8g2.drawXBMP(87,24,skala7a_width,skala7a_height,skala7a_bits); }    //7-segment
if ( zmienna1 >= 25) {u8g2.drawXBMP(101,23,skala8a_width,skala8a_height,skala8a_bits);}    //8-segment
if ( zmienna1 > 30 ) {u8g2.drawXBMP(115,22,skala9a_width,skala9a_height,skala9a_bits);}    //9-segment
//u8g2.setFont(u8g2_font_open_iconic_app_2x_t);
//u8g2.drawGlyph(1,35,64);
u8g2.setFont(u8g2_font_profont11_tf);
u8g2.drawHLine(24,63,8);
u8g2.drawStr(17,64,"0");
u8g2.drawStr(26,42,"5");
u8g2.drawStr(52,27,"10");
u8g2.drawStr(82,21,"20");
u8g2.drawStr(111,19,"30");
u8g2.drawStr(115,53,"km");
u8g2.drawHLine(113,54,15);
u8g2.drawStr(118,63,"h");
}

void Speed(void){
  duration = pulseInLong(pin, LOW);                             //pomiar czasu 1 obrotu koła w us
   if (FreqCount.available()) { count2 = FreqCount.read();}//odczyt częstotliwości
  Serial.println(count2);
   Serial.println(duration);
  if (count > 1){
    lok++;
    czas_e = czas_e + 1;    
  } 
  count = 36 * duration / 10000;                                 //przeliczenie czasu na godzinę(skrócona zależność)
  count1 = 500 * d_kola / count;
  zmienna=count1*10;
  zmienna1=zmienna/10;//obliczenie prędkosci w km/h
  zmienna2=zmienna%10;
  sprintf(m_str1,"%d", zmienna1);
  sprintf(m_str2,"%d", zmienna2);//konwersja liczby do char (stringu)
  m1_str = String(m_str1);
  m2_str = String(m_str2);//zamiana char na string
}

void Temperatura(void){
  Vo = analogRead(ThermistorPin);
  R2 = R1 * (1023.0 / (float)Vo - 1.0);
  logR2 = log(R2);
  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
  Tc = T - 273.15;  
  mt = int (Tc);                                                 //dwie pierwsze cyfry temperatury
  dt = 10 * (Tc - mt);                                           //część dziesiętna
  strcpy(mt_str, u8x8_u8toa(mt, 2));    
  strcpy(dt_str, u8x8_u8toa(dt, 1));   
}

void Dystans(void){
   d_etapu = lok * d_kola;                                 //długość etapu w metrach   
   de_km = d_etapu/1000;
     
   de_int = int(de_km);                                          //długość etapu w km
   if (de_int > de_int1) {
     d_total++;                                                  //zwiększenie licznika kilometrów całkowit.
     EEPROM.write(0,145);
     EEPROM.write(1, highByte(d_total));
     EEPROM.write(2, lowByte(d_total));
   }                              
   de_dz = int((de_km - de_int)*100);
   strcpy(de_str, u8x8_u8toa(de_int, 2));   
   strcpy(de1_str, u8x8_u8toa(de_dz, 2)); 
   strcpy(de1_str, u8x8_u8toa(de_dz, 2));
   de_int1 = de_int;  
}

int readFromEEPROM(){
  byte high = EEPROM.read(1);
  byte low = EEPROM.read(2);
  return (high << 8) + low;
}

void Czas(void){
  if (czas_e >= 100){
    sekundy++;
    czas_e = czas_e - 1000;
  }
  if (sekundy > 60){
    sekundy = 1;
    minuty++;
  }
  if (minuty > 60){
    minuty = 1;
    godz++;
  }
  strcpy(sekundy_str, u8x8_u8toa(sekundy, 2));   
  strcpy(minuty_str, u8x8_u8toa(minuty, 2)); 
  strcpy(godz_str, u8x8_u8toa(godz, 2));   
}

 

[farmaceuta]

1 godzinę temu, Gintek napisał:

Im dalej od środka koła tym prędkość pokazywana jest większa. Licznik dokonuje pomiaru na podstawie długości czasu między impulsami. I mimo że obroty są stałe to im bardziej się odsuwa magnes od osi koła czas impulsu maleje co za tym idzie pokazywana prędkość rośnie. 

Nic nie maleje...jedyne co sie zmienia to predkosc magnesu, im dalej od osi to jego predkosc jest wieksza, ale przy stalej predkosci kola to bez roznicy gdzie jest magnes bo i tak jeden impuls wystapi co jeden obrot kola...no chyba ze ten czujnik liczy tylko impuls i oblicza czas do nastepnego impulsu (co by bylo glupie) bo tracisz dokladnosc o drugi stan ktory tez czas zajmuje...ja widze dwa rozwiazania...

po wykryciu impulsu zapisujesz aktualny czas i natychmiast zaczynasz liczyc nastepny nawet jesli twoj czujnik wciaz jest aktywny...wtedy jest bez roznicy gdzie jest magnes, bo jak wiadomo im blizej osi magnes tym dluzej impuls jest "aktywny" bo jego predkosc jest mniejsza...

Drugi sposob to liczenie czasu miedzy zmianami stanu...czyli liczysz czas "aktywny" i nieaktywmy czujnika i dalej obliczenia...

No i oczywiscie trzeba pamietac o wprowadzeniu do obliczen obwodu kola, no ale to napewno wiesz...

 

[Gintek]

Dziękuję za podpowiedź, zsumowałem oba czasy stanu wysokiego i niskiego i wygląda na to że będzie dobrze. Nie potrafię jeszcze sobie poradzić z naliczaniem czasu przejazdu który uruchamia się po ruszeniu wskazania licznika. Wygląda to tak że im prędkość jest większa tym czas szybciej leci.

[farmaceuta]

jak nie masz rtc to ja bym kombinowal na millis()...czyli licze ms i w wolnym czasie przeliczam je na sekundy minuty etc...nie wiem czy dobrze rozumiem, ale chcesz mierzyc czas od ruszenia do zatrzymania tak? Jak tak to robisz jakis warunek ze jesli czujnik aktywny to zacznij liczyc czas do momentu az wystapi za duza przerwa do nastepnego stanu aktywnego i wtedy przelicz (tzn zatrzymaj dalsze liczenie przejazdu)

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[Gintek]

Teraz to wygląda tak

  if (duration > 1000){
    lok++;
    czas_e = czas_e + duration;

void Czas(void){
  if (czas_e >= 1000){
    czas_e = czas_e - 1000;
    sekundy++;

  }
  if (sekundy > 60){
    sekundy = 1;
    minuty++;
  }
  if (minuty > 60){
    minuty = 1;
    godz++;
}

gdzie duration to czas impulsu i to właśnie to uruchamia zegar i to by się zgadzało ale dlaczego czas przyspiesza wraz ze wzrostem prędkości.

Edytowano Sierpień 9, 2021 przez Gieneq

[farmaceuta]

Ale ty duration liczysz w us czy ms??

[Gintek]

us

[farmaceuta]

No teraz chyba masz blad w tych obliczeniach bo liczysz..duration > 1000 a 1000us to 1ms a nie sekunda...

[Gintek]

Tu chodzi raczej o to że jak jest duration >1000 to uruchamia się odliczanie czasu i zaczyna się pomiar drogi. Potem te duration jest dodawane do odliczanych sekund dlatego wraz ze wzrostem częstotliwości impulsów czas szybciej leci. I właśnie nie wiem jak to rozdzielić żeby uruchamiało czas ale nie było doliczane do czasu.

Edytowano Sierpień 9, 2021 przez Gintek

[farmaceuta]

9 godzin temu, Gintek napisał:

 I właśnie nie wiem jak to rozdzielić żeby uruchamiało czas ale nie było doliczane do czasu.

Poprostu licz sobie predkosc jak wyzej...a dla czasu stworz osobne zmienne ktore beda liczyc czas...

[Gintek]

Witam ponownie teraz jest problem z naliczaniem przejechanej drogi. Chodzi o to że program zaniża faktycznie przejechaną drogę. Nie wiem co jest grane bo jak policzę kalkulatorem według wzoru z programu to wychodzi prawidłowo. Za obliczanie drogi odpowiada dokładnie ten kod. d_kola to jest obwód koła który wynosi 0,231m a lok to jest ilość impulsów. Mógłby ktoś podpowiedzieć co jest źle.

void Dystans(void){
   d_etapu = lok * d_kola;                                 //długość etapu w metrach   
   de_km = d_etapu/100;
   
     
   de_int = int(de_km);                                          //długość etapu w km
   if (de_int > de_int1) {
     d_total++;                                                  //zwiększenie licznika kilometrów całkowit.
     EEPROM.write(0,145);
     EEPROM.write(1, highByte(d_total));
     EEPROM.write(2, lowByte(d_total));
   }                              
   de_dz = int((de_km - de_int)*100);
   strcpy(de_str, u8x8_u8toa(de_int, 2));   
   strcpy(de1_str, u8x8_u8toa(de_dz, 2)); 
  
   de_int1 = de_int;  
}

int readFromEEPROM(){
  byte high = EEPROM.read(1);
  byte low = EEPROM.read(2);
  return (high << 8) + low;
}

 

[ethanak]

1 godzinę temu, Gintek napisał:

obwód koła który wynosi 0,231m

Jakiś mały ten rowerek... 7 cm koło... jesteś pewien że operujesz metrami a nie np. dekametrami (bo przecież kilometr ma 1000m a nie 100)?

[Gintek]

Proszę przeczytać mój pierwszy post tam jest wszystko opisane. A co do czemu 100 a nie 1000 to ja to celowo zmieniłem na 100 żeby naliczało mi co 1 metr a nie co 10 metrów.

[ethanak]

OK zwracam honor. Ale w programie używasz nazw sugerujących użycie jednostek "metr/kilometr" a nie "centymetr/metr", tak więc bez czytania jakichś dodatkowych wyjaśnień raczej ciężko się zorientować, że np. de_km to odległość w metrach 😉

Życzę powodzenia w poprawianiu programu za dwa lata.

 

[farmaceuta]

d_etapu = lok * d_kola;                                 //długość etapu w metrach   
   de_km = d_etapu/100;
   
     
   de_int = int(de_km);  

Rzutujesz do int cos co chyba jest po przecinku tak??