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

[ethanak]

To mam pytanie. Jak sobie wyobrażasz prawidłowe działanie programu, jeśli nie możesz wykryć impulsu krótszego niż 50 ms?Podstawowym błedem jest to, że Twój program przez jakiś czas nie reaguje na impulsy z czujnika. Poczytaj o przerwaniach, na ten temat napisano już grube gigabajty we wszystkich możliwych językach z kazachskim i swahili włącznie.

Wspomniałem o tym, że w ten sposób (jaki zastosowałeś) impulsów się nie liczy?

[farmaceuta]

21 minut temu, Gintek napisał:

 Wygląda na to że winne jest sumowanie czasów impulsu i przerwy między impulsami. Bo jak jest brana pod uwagę tylko długość impulsu to wtedy licznik drogi działa poprawnie.

Juz ustalilismy ze masz blad roznego rozmiaru w zaleznosci od tego gdzie umiescisz czujnik...musisz obliczyc i stan aktywy i nieaktywny zeby bylo wiadomo ze jeden obrot to w rzeczywistosci jeden obrot(360°) a nie np. 347° bo przez 13° czujnik byl nieaktywny...kolejna sprawa jak kolega @ethanak pisal, sprawdzanie stanu czujnika musi sie odbywac bez blokowania czym kolwiek...bez delay()..najlepiej wlasnie na przerwaniach...ale puki co to ja bym te floaty powyrzucal i jakos znormalizowal te obliczenia...przyjmij jako jednoste cm i tego sie trzymaj, a zamiana na km tylko na koncu na float...

[Gintek]

36 minut temu, ethanak napisał:

To mam pytanie. Jak sobie wyobrażasz prawidłowe działanie programu, jeśli nie możesz wykryć impulsu krótszego niż 50 ms?Podstawowym błedem jest to, że Twój program przez jakiś czas nie reaguje na impulsy z czujnika. Poczytaj o przerwaniach, na ten temat napisano już grube gigabajty we wszystkich możliwych językach z kazachskim i swahili włącznie.

Wspomniałem o tym, że w ten sposób (jaki zastosowałeś) impulsów się nie liczy?

To jak się liczy te impulsy? Ja nie jestem biegły w tych sprawach dlatego kupiłem gotowy zestaw z programem i chcę go tylko przerobić pod swoje potrzeby. Nie wiem dlaczego autor tego programu zrobił tak a nie inaczej.

[Gintek]

21 minut temu, farmaceuta napisał:

Juz ustalilismy ze masz blad roznego rozmiaru w zaleznosci od tego gdzie umiescisz czujnik...musisz obliczyc i stan aktywy i nieaktywny zeby bylo wiadomo ze jeden obrot to w rzeczywistosci jeden obrot(360°) a nie np. 347° bo przez 13° czujnik byl nieaktywny...kolejna sprawa jak kolega @ethanak pisal, sprawdzanie stanu czujnika musi sie odbywac bez blokowania czym kolwiek...bez delay()..najlepiej wlasnie na przerwaniach...ale puki co to ja bym te floaty powyrzucal i jakos znormalizowal te obliczenia...przyjmij jako jednoste cm i tego sie trzymaj, a zamiana na km tylko na koncu na float...

To właśnie mam ogarnięte i prędkość pokazuje prawidłowo bez znaczenia gdzie umieszczę czujnik od środka obrotu. Problem polega na tym że jak to zrobiłem to zliczanie kilometrów zgłupiało i nie ważne czy liczy w metrach kilometrach czy centymetrach. Coś powoduje że na 10 impulsów, zliczonych jest tylko 3 a przed moją modyfikacją było to 10 na 10 przy tym samym ustawieniu delay 50. Zliczanie impulsów polega na tym jeśli czas impulsu jest większy od 1000 mikrosekund to dodaj 1. Na zdrowy rozum powinno działać a nie działa.

[farmaceuta]

Jeden impuls zliczasz wtedy kiedy wykonal sie jeden obrot...i wtedy nie ma problemu...ej tam..wklej caly ten kod zmodyfikowany bo ja sie juz pogubilem calkiem...

[ethanak]

15 minut temu, Gintek napisał:

Nie wiem dlaczego autor tego programu zrobił tak a nie inaczej.

Bo próbujesz połączy przepis na jajecznicę z kiełbasą z przepisem na sandacza po żydowsku. Autor (nie tego programu, a kawałka programu który uprzejmie raczyłeś skopiować bez zrozumienia jak to działa) zrobił coś w ten a nie inny sposób, że bez jakichś dodatkowych rzeczy to działało.

Pytanie, czego oczekujesz od połączenia tych dwóch przepisów: sandacza z kiełbasą  czy jajecznicy po żydowsku? Bo w ten sposób, w który to robisz wyjdzie najwyżej jakaś niejadalna breja.

[Gintek]

Podam taki przykład, nie dawno chciałem zlecić wykonanie programu do sterowania siłownikiem liniowym. Znalazłem w ogłoszeniu osobę która tym się zajmuje zawodowo. Po rozmowie telefonicznej ustaliliśmy cenę od razu zapłaciłem z góry i pan zaczął pracę nad programem według moich założeń. Po kilku rozmowach telefonicznych x wiadomościach wyjaśniających zasadę działania programu a nawet nagraniu filmiku instruktażowego ten pan nie zrozumiał o co chodzi tylko powiedział że moje założenia są nie realne do zrobienia i że tylko on swój czas zmarnował. Na szczęście oddał kasę bo tak się umieliśmy z początku. Ale ja tym się nie zraziłem i znalazłem kolejną osobę która zgodziła się zrobić ten program. Po jednej rozmowie telefonicznej i kilku wiadomościach miałem już gotowy prototyp programu na tych samych założeniach co przedstawiałem dla pierwszego pana. Po dwóch poprawkach program działa tak jak to sobie wymyśliłem i na dodatek za mniej niż połowę ceny co chciał pierwszy pan. Więc proszę nie pisać że czegoś nie można zrobić bo to nie jest komputer jakiegoś promu kosmicznego.

[farmaceuta]

5 minut temu, Gintek napisał:

Więc proszę nie pisać że czegoś nie można zrobić bo to nie jest komputer jakiegoś promu kosmicznego.

Nie da to sie majtek przez glowe ubrac...prawie wszystko inne sie da...to nie chodzi o to ze sie nie da tylko ten program ma pewne luki ktore trzeba usunac bo w przeciwnym razie jie bedzie dzialal tak jak sie zalozylo a tylko bedzie dzialal podobnie z pewnym bledem...wklej ten kod caly

[ethanak]

6 minut temu, Gintek napisał:

proszę nie pisać że czegoś nie można zrobić

Nikt nie pisze że nie można. Można, ale nie bezmyślnie sklejając ze sobą kawałki różnych programów nawet nie starając się zrozumieć co one robią.

7 minut temu, Gintek napisał:

o nie jest komputer jakiegoś promu kosmicznego

Jak myślisz, ile błędów zawierał program Apollo 11? Nie podam linka, sprawdź sobie sam w góglu.

 

[Gintek]

4 minuty temu, farmaceuta napisał:

Nie da to sie majtek przez glowe ubrac...prawie wszystko inne sie da...to nie chodzi o to ze sie nie da tylko ten program ma pewne luki ktore trzeba usunac bo w przeciwnym razie jie bedzie dzialal tak jak sie zalozylo a tylko bedzie dzialal podobnie z pewnym bledem...wklej ten kod caly

Jak usiądę przed komputerem to wkleje

[Gintek]

/* 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;
int zmienna1, zmienna, zmienna2;
char m_str2[6];
char m_str1[6];
String m1_str, m2_str;
int pin = 5;
unsigned long duration;
unsigned long duration1;
float r_kola = 0.0369;                                             //promień koła w metrach
float d_kola;
//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;
unsigned long czas_e1;            //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;
//zmienne do pomiaru obrotow
//input_pin = D5
float count2, count3;
int zmienna3, zmienna4, zmienna5;
char m_str[6];
char m_str3[6];
String m3_str, m4_str;

void setup(void) {
  u8g2.begin(); 
  Serial.begin(9600);
   
  //pinMode(pin, INPUT_PULLUP);                                   //linia do współpracy z kontaktronem
  pinMode(pin, INPUT);                                            //linia do współpracy z hallotronem
  d_kola = r_kola * 2 * PI;                                    //obwód kola
}

void loop(void) {
  Speed();
  Temperatura();
  d_total = readFromEEPROM();
  Dystans();
  Czas();
  Obroty();
  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);
      //równanie wyniku pomiaru do ostatniej cyfry
      if (m3_str.length() == 1) {                                   //dla wyniku 1-cyfrowego
      u8g2.drawStr(55, 63, m_str3);
      u8g2.drawStr(49, 63, m_str);}
      if (m3_str.length() == 2 ) {                                  //dla wyniku 2-cyfrowego
      u8g2.drawStr(55, 63, m_str3);
      u8g2.drawStr(43, 63, m_str);}
      if (m3_str.length() == 3 ) {                                 //dla wyniku 3-cyfrowego
      u8g2.drawStr(55, 63, m_str3);
      u8g2.drawStr(36, 63, m_str);}
      if (m3_str.length() == 4 ) {                                 //dla wyniku 3-cyfrowego
      u8g2.drawStr(55, 63, m_str3);
      u8g2.drawStr(35, 63, m_str);}  
      
      if (m3_str.length() == 4 ) {u8g2.drawStr(40, 63, m_str);}   //dla wyniku 4-cyfrowego  
     
        //wypisanie długosci etapu
      u8g2.drawStr(1,7,de_str);
      //u8g2.drawStr(11,7,".");
      u8g2.drawStr(13,7,de1_str);
       
      u8g2.drawStr(27,7,"m"); 
      //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() );
   
}

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
  duration1 = pulseInLong(pin, HIGH, 2000000);
  //Serial.println(count2);
   Serial.println(lok);
   Serial.println(duration+duration1);
  if (duration>1000){
    lok++;
   czas_e = czas_e +duration;    
  } 
count = 36 * (duration + duration1) / 100000; 
count1 = 1296* 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);
  //Serial.println(Vo);
  R2 = R1 * (1024.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/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;
}

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++;
  }
  strcpy(sekundy_str, u8x8_u8toa(sekundy, 2));   
  strcpy(minuty_str, u8x8_u8toa(minuty, 2)); 
  strcpy(godz_str, u8x8_u8toa(godz, 2));   
}
void Obroty (void){
 if (FreqCount.available()) { count2 = FreqCount.read();}//odczyt częstotliwości 
  Serial.println(count3);
  count3 = count2;                                           //zamiana obr/sek na obr/min
  zmienna3 = count3;
  zmienna4=zmienna3/10;
  zmienna5=zmienna3%10;
  sprintf(m_str,"%d",zmienna4);
  sprintf(m_str3,"%d", zmienna5);                                   //konwersja liczby do char (stringu)
  m3_str = String(m_str);
  m4_str = String(m_str3);

 
       
      
} 

 

[ethanak]

1 godzinę temu, Gintek napisał:

program działa tak jak to sobie wymyśliłem i na dodatek za mniej niż połowę ceny co chciał pierwszy pan

Więc czego jeszcze chcesz i po kiego grzyba zawracasz nam głowę jakimiś wypocinami? Działa? Działa. Zapłaciłeś? No to się ciesz, że masz tanio i działa. Czego jeszcze chcesz - udowodnić nam tutaj, że ten pan któremu zapłaciłeś jest lepszy od nas? No to udowodniłeś - bo my tu tracimy czas na wyjaśnianie Ci jakichś najprostszych rzeczy, a gościu po prostu napisał bzdeta, zgarnął kasę i w ten sposób pokazał, jak się powinno postępować z takimi jak Ty. Czyli jest lepszy...

Mam nadzieję, że następnym razem ograniczysz swoją bytność na forum do działu "praca oferowana".

 

[Gintek]

15 minut temu, ethanak napisał:

Więc czego jeszcze chcesz i po kiego grzyba zawracasz nam głowę jakimiś wypocinami? Działa? Działa. Zapłaciłeś? No to się ciesz, że masz tanio i działa. Czego jeszcze chcesz - udowodnić nam tutaj, że ten pan któremu zapłaciłeś jest lepszy od nas? No to udowodniłeś - bo my tu tracimy czas na wyjaśnianie Ci jakichś najprostszych rzeczy, a gościu po prostu napisał bzdeta, zgarnął kasę i w ten sposób pokazał, jak się powinno postępować z takimi jak Ty. Czyli jest lepszy...

Mam nadzieję, że następnym razem ograniczysz swoją bytność na forum do działu "praca oferowana".

 

Człowieku co ty bredzisz czytaj ze zrozumieniem. Po drugie nie podoba się to nie pomagaj czy ktoś ci kazał, i trochę kultury. 

Edytowano Sierpień 17, 2021 przez Gintek

[blaberk]

Dnia 17.08.2021 o 21:04, Gintek napisał:

Człowieku co ty bredzisz czytaj ze zrozumieniem. Po drugie nie podoba się to nie pomagaj czy ktoś ci kazał, i trochę kultury. 

Witam..
Proponuję cofnąć się do pierwszego postu w którym Gintek zadaje pytanie. 
Jest tu podstawowy błąd popełniony przez autora pytania.
Otóż myli on promień koła z obwodem koła.
Jeżeli zajrzymy do oryginalnego programu (cytowanego przez autora), zauważymy
że obok liczby 0,231 - jest komentarz, że jest to promień koła.
Jest to promień koła roweru typu "składak" oczywiście w [m]. Liczbę tę należy samemu zmienić w zależności od posiadanego roweru.

Tymczasem w dalszej dyskusji, operuje się pojęciem - obwód koła.
Nawet jeden z dyskutantów dziwi się, co to za małe koło - że musi mieć około 7cm promienia!

Następny błąd jaki popełnia autor pytania, to zamiana metrów na centymetry.
Otóż program dlatego był pisany w standardowych jednostkach, żeby nie trzeba było korygować wzorów obliczeniowych.
Po to wymyślono układ SI. 
Na centymetry i inne jednostki możemy zamieniać, jak już mamy wynik końcowy.

Co do dokładności odczytu czasu.
Choć Arduino daje dwie komendy do czytania czasu:
pulseIn() oraz pulseInLong(), to jednak najlepszy wynik dało zastosowanie gotowej biblioteki - <FreqCount.h>
Wynika to z tego, że koło w rowerze kręci się bardzo wolno i nawet pulseInLong() dawało błędne wyniki.

Jestem autorem tego programu. Nie mówię że jest on doskonały.
We wstępie do stron z których można pobrać w/w program napisałem:
"Programy nie są celowo "dopięte na ostatni guzik" - mają bowiem tylko ułatwić start pisania własnego programu."

Nieprawdą też jest to, co napisał jeden z dyskutantów, że "nachapałem się kasy". 
Otóż kolego nie. Programy były pisane gratis i są udostępniane za darmo po to, by łatwiej sprzedać wyświetlacze
Arduino-DEM. Wyświetlacze te zakupiłem kilka lat temu dla klienta, który potem z nich zrezygnował.
Cała ta akcja z programami i kitami Arduino-DEM były tylko w celu odzyskania kasy za zakupione wyświetlacze.

Oczywiście zachęcam do poprawiania tego programu i pisania własnych.
Z tego powodu ta dyskusja ma sens.
Jednak proszę - nie mylmy promienia koła z jego obwodem.

Edit: sprawdziłem przed chwilą w/w program w internecie. Otóż autor pytania korzysta ze starej wersji tego programu.
Nowa wersja (10.01.2019) nie zawiera biblioteki <FreqCount.h> a do określania czasu korzysta z komendy pulseInLong().

Edytowano Grudzień 22, 2021 przez blaberk
sprawdzenie oryginału programu w internecie