[Arduino] Knipperend Display i.c.m. GPS Snelheidsmeter

[Luppie]

Mijn km/h teller in mijn auto wijkt standaard +/- 10% af van de werkelijke snelheid. Volgens de dealer is dit nog binnen de normen, maar volgens mij is dit knap irritant, dus dacht ik er aan om zelf een oplossing te bouwen in de vorm van een GPS gestuurde KM-Teller.

De onderdelen die ik hiervoor gebruik zijn de volgende:

• Arduino Nano v3.0
• 4 Digit 7 Segment Display
• U-Bloks NEO-6M GPS Module

Nadat ik eerst de GPS module getest heb met de TinyGPSPlus library en de Parser voorbeeldsketch (en netjes output op de serial monitor zag) heb ik de code gestript totdat ik alleen nog maar de snelheid als output kreeg.
Daarna heb ik de voorbeelsketch voor het 7 segment display getest om de werking van het display te testen. Dit werkte ook meteen in 1 keer.

Daarna heb ik beide sketches gecombineerd om de snelheid van de GPS weer te geven op het 7 segment display. Snelheid op het display getest in de auto en het werkt
Echter wel met het volgende probleem: Iedere update van de snelheid knippert het display. (zie video)

Probleem:
[YouTube: https://www.youtube.com/watch?v=z8cYJUXAgwI]

Zelf dacht ik eerst dat de 'smartdelay' in de code het probleem veroorzaakte, maar dit was niet het geval.
Daarna heb ik het volgende stukje code weg gelaten:

C++:

    //Turn off all segments
    lightNumber(10); 
//
//    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
  }

Nu knippert het display niet meer, echter wordt de snelheid ook niet meer weergegeven, alleen 0000 brandt continue.

Zelf loop ik nu vast en weet niet hoe ik de code verder kan aanpassen, zodat het display niet meer knippert.
Wat zie ik over het hoofd en/of hoe kan ik er voor zorgen dat het display niet meer knippert ?

In Fritzing heb ik het schema getekend, hoe ik het geheel heb aangesloten:
De pinnummers uit de voorbeelsketches heb ik aangepast, zodat het display mooi bovenop de Nano past.

Schema:



Dit is de code zoals ik het nu werkend heb (met knipperend display)

C++:

#include <TinyGPS++.h>
#include <SoftwareSerial.h>
int digit1 = 9; //PWM Display pin 1
int digit2 = 8; //PWM Display pin 2
int digit3 = 4; //PWM Display pin 6
int digit4 = 2; //PWM Display pin 8

int segA = A2; //Display pin 14
int segB = A0; //Display pin 16
int segC = A3; //Display pin 13
int segD = 7; //Display pin 3
int segE = 5; //Display pin 5
int segF = A5; //Display pin 11
int segG = A1; //Display pin 15

static const int RXPin = 10, TXPin = 11;
static const uint32_t GPSBaud = 9600;

// The TinyGPS++ object
TinyGPSPlus gps;

// The serial connection to the GPS device
SoftwareSerial ss(RXPin, TXPin);

void setup()
{
  Serial.begin(115200);
  ss.begin(GPSBaud);

  Serial.println(F("Speedometer"));

  pinMode(segA, OUTPUT);
  pinMode(segB, OUTPUT);
  pinMode(segC, OUTPUT);
  pinMode(segD, OUTPUT);
  pinMode(segE, OUTPUT);
  pinMode(segF, OUTPUT);
  pinMode(segG, OUTPUT);

  
  pinMode(digit1, OUTPUT);
  pinMode(digit2, OUTPUT);
  pinMode(digit3, OUTPUT);
  pinMode(digit4, OUTPUT);
  
  pinMode(13, OUTPUT);
}

void loop()
{
  printFloat(gps.speed.kmph(), gps.speed.isValid(), 6, 0);
  Serial.println(F(""));
  smartDelay(1000);
}


void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (ss.available())
      gps.encode(ss.read());
  } while (millis() - start < ms);
}

void printFloat(float val, bool valid, int len, int prec)
{
  if (!valid)
  {
    while (len-- > 1)
    displayNumber(0000);
      Serial.print('*');
    Serial.print(' ');
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1); // . and -
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(' ');
      displayNumber(val);
  }
  smartDelay(0);
}

void displayNumber(int toDisplay) {
#define DISPLAY_BRIGHTNESS  500

#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW

  long beginTime = millis();

  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      break;
    case 2:
      digitalWrite(digit2, DIGIT_ON);
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      break;
    }

    //Turn on the right segments for this digit
    lightNumber(toDisplay % 10);
    toDisplay /= 10;

    delayMicroseconds(DISPLAY_BRIGHTNESS); //Display this digit for a fraction of a second (between 1us and 5000us, 500 is pretty good)

    //Turn off all segments
    lightNumber(10); 
//
//    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
  }

  while( (millis() - beginTime) < 10) ; //Wait for 20ms to pass before we paint the display again
}

//Given a number, turns on those segments
//If number == 10, then turn off number
void lightNumber(int numberToDisplay) {

#define SEGMENT_ON  LOW
#define SEGMENT_OFF HIGH

  switch (numberToDisplay){

  case 0:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_OFF);
    break;

  case 1:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_OFF);
    break;

  case 2:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 3:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 4:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 5:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 6:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 7:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_OFF);
    break;

  case 8:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 9:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 10:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_OFF);
    break;
  }
}
  

[ Voor 0% gewijzigd door Luppie op 28-09-2015 19:46 . Reden: Broken Links aangepast ]

[Dogooder]

Je moet zorgen dat je in je smart delay ook het display blijft updaten, nu update je het display en daarna ga je weer een seconde gps.encode(ss.read()) doen.
Als je de display pinnen niet uitzet dan blijven alle displays geselecteerd, dan staan alle nummers dus op het laatste geschreven getal.

[ Voor 30% gewijzigd door Dogooder op 30-06-2014 13:23 ]

[Damic]

Volgens mij doe je ook nog iets verkeerd met je digitx. Al eens gewoon een teller gemaakt van 0 -> 9999 ofzo, het is maar dat jeje 4 digits gebruikt?

[ThinkPad]

Wat is de originele teller in je auto voor type? Een display, of een mechanische met wijzernaald? In dat laatste geval zou je natuurlijk de naald eraf kunnen halen, stuk gaan rijden met GPS aan, en dan op de goede snelheid erop prikken?

Anders misschien uitlezen via OBD poort? Misschien dat die een meer nauwkeurige waarde teruggeeft?

offtopic:
Pas je eerste [code] tag even aan naar [code=c++] trouwens, maakt het wat leesbaarder

[ Voor 37% gewijzigd door ThinkPad op 30-06-2014 15:25 ]

[Luppie]

Dogooder schreef op maandag 30 juni 2014 @ 13:15:
Je moet zorgen dat je in je smart delay ook het display blijft updaten, nu update je het display en daarna ga je weer een seconde gps.encode(ss.read()) doen.
Als je de display pinnen niet uitzet dan blijven alle displays geselecteerd, dan staan alle nummers dus op het laatste geschreven getal.

Ik heb als volgt geprobeerd in de smartdelay het display te updaten:
(Heb Snelheid in het begin gedeclared als integer en vul hem in de functie printFloat)

C++:

void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (ss.available())
      displayNumber(Snelheid);
      gps.encode(ss.read());
  } while (millis() - start < ms);
}

Maar hij knippert nog steeds, wel een stuk minder erg, dus heb het idee dat ik wel al in de juiste richting zit.

Damic schreef op maandag 30 juni 2014 @ 14:34:
Volgens mij doe je ook nog iets verkeerd met je digitx. Al eens gewoon een teller gemaakt van 0 -> 9999 ofzo, het is maar dat jeje 4 digits gebruikt?

Ik ben begonnen met een teller van 0 -> 9999 en dit werkt gewoon. Alle getallen worden netjes weergegeven op het display. Aan de voorbeeldcode voor het display heb ik ook niks gewijzigd (behalve de pin-assignment)

ThinkPadd schreef op maandag 30 juni 2014 @ 15:18:
Wat is de originele teller in je auto voor type? Een display, of een mechanische met wijzernaald? In dat laatste geval zou je natuurlijk de naald eraf kunnen halen, stuk gaan rijden met GPS aan, en dan op de goede snelheid erop prikken?

Anders misschien uitlezen via OBD poort? Misschien dat die een meer nauwkeurige waarde teruggeeft?

offtopic:
Pas je eerste [code] tag even aan naar [code=c++] trouwens, maakt het wat leesbaarder

Het is inderdaad een teller met een (lichtgevende) naald, maar aangezien het een leaseauto is, ga ik natuurlijk niet het dashboard open halen. Aansluiten op de OBD poort zou een optie kunnen zijn, wil het niet dat ik graag dit probleem wil oplossen en daar ook nog van wil leren.
Ben vrij nieuw met Arduino en al helemaal in het schrijven van goede Code

offtopic:
Code Tags aangepast, dat was in ieder geval leermomentje 1

[Seesar]

Ik kan je niet helpen met de code, maar dit werkt i.i.g. niet en hoef je neit te proberen:

ThinkPadd schreef op maandag 30 juni 2014 @ 15:18:
Een display, of een mechanische met wijzernaald? In dat laatste geval zou je natuurlijk de naald eraf kunnen halen, stuk gaan rijden met GPS aan, en dan op de goede snelheid erop prikken?

offtopic:
Pas je eerste [code] tag even aan naar [code=c++] trouwens, maakt het wat leesbaarder

het is 10% afwijking, geen 10km/u offset; m.a.w. als je die naald verplaatst maak je nieuwe offset en zou je bij 0km/u bijvoorbeeld 10km/u aanwijzen.

het is normaal dat auto's 10% kunnen afwijken, dus bij 10km/u is dat maar 1 km/u, bij 120 is dat 12km/u. Een vaste waarde verplaatsen werkt dus niet en zou je dus -10 hebben als je stilstaat .

[Dogooder]

als een teller van 0->9999 wel goed werkt, doe dan is tussen elke ophoging een gps read (gps.encode(ss.read()); ) en kijk op het display nog steeds goed werkt.
Dan zou je kunnen onderzoeken waar je arduino zich in verslikt en wat dus je delay oplevert.
Ik denk dat je softwareserial niet al te snel is en dat je dus moet zorgen dat je vaker je display update dan dat je op data wacht.

[ Voor 20% gewijzigd door Dogooder op 30-06-2014 17:05 ]

[heggico]

Luppie schreef op maandag 30 juni 2014 @ 16:46:

C++:

void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (ss.available())
      displayNumber(Snelheid);
      gps.encode(ss.read());
  } while (millis() - start < ms);
}

Hm.. pas hier ook mee op. Nu klopt dat namelijk niet meer. Er staat nu eigenlijk dit:

C++:

void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (ss.available()) { displayNumber(Snelheid); }
      gps.encode(ss.read()); //Deze doet hij dus niet meer in de while(ss.available)
  } while (millis() - start < ms);
}

Dit heb je op een aantal andere plekken ook nog staan. Van sommige ben ik alleen niet zeker of het met opzet is gedaan of niet.

[ThinkPad]

Seesar schreef op maandag 30 juni 2014 @ 16:51:
Ik kan je niet helpen met de code, maar dit werkt i.i.g. niet en hoef je neit te proberen:


[...]


het is 10% afwijking, geen 10km/u offset; m.a.w. als je die naald verplaatst maak je nieuwe offset en zou je bij 0km/u bijvoorbeeld 10km/u aanwijzen.

het is normaal dat auto's 10% kunnen afwijken, dus bij 10km/u is dat maar 1 km/u, bij 120 is dat 12km/u. Een vaste waarde verplaatsen werkt dus niet en zou je dus -10 hebben als je stilstaat .

Dan stel je hem toch zo dat je op de meest gebruikte snelheden (50-80-120) zo min mogelijk afwijking hebt? Kwestie van proberen. Dat hij -10 aangeeft zou mij niet zoveel boeien. Pas vanaf 30 is het interessant welke snelheid je rijdt, daaronder is toch op gevoel.

Maargoed, TS heeft een leaseauto dus die vlieger gaat niet op.

[ Voor 4% gewijzigd door ThinkPad op 30-06-2014 18:14 ]

[Luppie]

Dogooder schreef op maandag 30 juni 2014 @ 17:00:
als een teller van 0->9999 wel goed werkt, doe dan is tussen elke ophoging een gps read (gps.encode(ss.read()); ) en kijk op het display nog steeds goed werkt.
Dan zou je kunnen onderzoeken waar je arduino zich in verslikt en wat dus je delay oplevert.
Ik denk dat je softwareserial niet al te snel is en dat je dus moet zorgen dat je vaker je display update dan dat je op data wacht.

Heb nu de display voorbeeldcode gepakt en daar de GPS library aan toegevoegd.
In de loop heb ik de volgende code gezet:

C++:

  nummer = (millis()/1000);
  displayNumber(nummer);
  gps.encode(ss.read());

En inderdaad een knipperend scherm.

[Dogooder]

Ik weet niet of softwareserial er mee om kan gaan, maar het lijkt me dat je dan op interrupt basis moet gaan werken. Kan wellicht twee kanten op. timer interupt welke zorgt dat het display altijd optijd word geupdate. Maar softwareserial moet hiermee om kunnen gaan anders krijg je corrupte data. Of een interrupt op het moment dat er data aanwezig is, kan je de rest van de tijd het scherm updaten.

[Luppie]

Probleem zat inderdaad in de SoftwareSerial.
Na van alles geprobeerd en geleerd te hebben, heb ik nu toch een werkende situatie.

Ik heb de hele code voor het display kunnen vervangen door een 7-segment library, met een bijkomend voordeel, dat nu de Decimal Point ook gebruikt kan worden.

Vervolgens heb ik de SoftwareSerial helemaal weg gelaten en de GPS module op pin 0 & 1 (RX&TX) aangesloten.

Aangepast Schema:


Daarna alle (volgens mij) overbodige code weg gelaten, met als resultaat een niet knipperende KM-teller

Dit is uiteindelijk de code om het werkend te krijgen:

C++:

#include "SevSeg.h"
#include <TinyGPS++.h>

//Instance aanmaken voor GPS en Display
SevSeg sevseg;
TinyGPSPlus gps;

//int Snelheid variable vullen
int Snelheid=8888;

void setup() {
  //Common anode display, dus eerste waarde op 1, (0 voor common cathode)
  //Digit pins zijn verbonden aan 9,8,4,2
  //Segment pins zijn verbonden aan A2,A0,A3,7,5,A5,A1,3
  sevseg.Begin(1,9,8,4,2,A2,A0,A3,7,5,A5,A1,3);
  
  //Helderheid (0 to 100);
  sevseg.Brightness(50);
  
  //Open de seriële poort
  Serial.begin(9600);
}


void loop() 
{
  Snelheid = (gps.speed.kmph());
  sevseg.NewNum(Snelheid,0);  
  sevseg.PrintOutput();
  smartDelay(10);
}


void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (Serial.available())
      gps.encode(Serial.read());
      sevseg.PrintOutput();
  } while (millis() - start < ms);
}

Iedereen bedankt en Special Thanks to Dogooder voor mij in de juiste richting te sturen.

[ Voor 4% gewijzigd door Luppie op 01-07-2014 22:56 ]

[ThinkPad]

Filmpje! Filmpje! Filmpje!

Is trouwens verdomd weinig code! Mijn code om de temperatuur van een DS18B20 temperatuur sensor op een 7seg display is al meer

Je had trouwens ook een kant en klaar display met MAX7219 of TM1638 kunnen gebruiken. Dan zit je ook niet met geknipper. Timing regelen die chipjes namelijk. Je hoeft alleen te zeggen: print karakter XYZ. Scheelt ook draden (bij die MAX7219 heb je 3 stuurdraden, Vcc, en GND).

[ Voor 128% gewijzigd door ThinkPad op 30-06-2014 23:03 ]

[Luppie]

Morgen ! Morgen ! Morgen !

ThinkPadd schreef op maandag 30 juni 2014 @ 22:59:

Is trouwens verdomd weinig code! Mijn code om de temperatuur van een DS18B20 temperatuur sensor op een 7seg display is al meer

Kan je nagaan, ik kan eigenlijk helemaal niet programmeren. Voordeel in dit geval is dat alle code voor het display (en de GPS) in een library zit. Daarmee is de logica en het aansturen mooi gescheiden. Een stuk praktischer.

Had wel naar soortgelijke display's gekeken (en ook naar LCD), maar wil hem inbouwen op de plek waar mijn retro klokje zit (op de foto rechts bovenin)

[ Voor 123% gewijzigd door Luppie op 30-06-2014 23:22 ]

[Luppie]

ThinkPadd schreef op maandag 30 juni 2014 @ 22:59:
Filmpje! Filmpje! Filmpje!

[YouTube: http://youtu.be/ybiWSFywep0]

In het filmpje is 1 kleine glitch te zien (hij gaf heel even onterecht 130km aan), dit kwam doordat de GPS nog maar net een Fix had en nog geen sterk signaal had. Heb hem daarnaast nog gecontroleerd met de GPS van mijn telefoon en ze geven beide dezelfde snelheid aan.

[ThinkPad]

Keurig!

Nu nog een mooie behuizing eromheen. En misschien iets fixen met een LDR zodat hij dimt in de avond/feller overdag?

[Luppie]

Ik ga hem niet in een losse behuizing doen, maar ga kijken hoe ik hem netjes in het dashboard kan bouwen (zonder te boren of te zagen o.i.d.). Ik heb hiervoor 2 opties gezien.

1. Op de plek van het bestaande klokje.
2. Op de plek van de de airbag/gordel verlichting.

In beide gevallen is het makkelijk bereikbaar en ook weer te herstellen, wanneer ik mijn auto weer moet inleveren.

Ondertussen heb ik ook de code nog een beetje aangepast, waardoor de snelheid alleen wordt weergegeven als er meer dan 4 satellieten in zicht zijn. Anders staat het display op 8888

De optie voor een LDR is inderdaad wel een interessante, daar ga ik nu maar verder mee. Bedankt voor de tip.

Dit is de aangepaste code incl, de check op het aantal satellieten:

C++:

#include "SevSeg.h"
#include <TinyGPS++.h>

//Instance aanmaken voor GPS en Display
SevSeg sevseg;
TinyGPSPlus gps;

//int Snelheid variable vullen
int Snelheid=8888;
int Satteliet = 0;

void setup() {
  //Common anode display, dus eerste waarde op 1, (0 voor common cathode)
  //Digit pins zijn verbonden aan 9,8,4,2
  //Segment pins zijn verbonden aan A2,A0,A3,7,5,A5,A1,3
  sevseg.Begin(1,9,8,4,2,A2,A0,A3,7,5,A5,A1,3);
  
  //Helderheid (0 to 100);
  sevseg.Brightness(50);
  
  //Open de seriële poort
  Serial.begin(9600);
}


void loop() 
{
  Snelheid = (gps.speed.kmph());
  Satteliet = (gps.satellites.value());
  if (Satteliet < 5) Snelheid = 8888;
  sevseg.NewNum(Snelheid,0);  
  sevseg.PrintOutput();
  smartDelay(100);
}


void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (Serial.available())
      gps.encode(Serial.read());
      sevseg.PrintOutput();
  } while (millis() - start < ms);
}

[ThinkPad]

Je zou ook aan de hand van de GPS tijd de helderheid kunnen regelen. Dat tussen 18:00 - 7:00 helderheid laag staat, en andere tijden op max. Maar met LDR is wat universeler

Als je trouwens op de plek van het klokje het display wilt plaatsen zou je nog kunnen kijken of je een stukje plexiglas rookglas kunt vinden (van dat zwarte plexiglas wat ook in een settopbox zit bijv.) Dat maakt de leesbaarheid beter.

[ Voor 14% gewijzigd door ThinkPad op 02-07-2014 10:07 ]

[naftebakje]

Als je nog dergerlijke projectjes wil doen (of dit wil uitbreiden), kan ik je toch aanraden om eens interrupts te bekijken. Als je daar eenmaal mee gewerkt hebt, gebruik je dat altijd om dringende of strak getimede zaken af te handelen en kan je gerust een trage/overvolle main-loop hebben.

Interrupts lopen tussen de normale code door, meestal met een timer: als de timer afloopt dan wordt de interrupt gestart (maakt niet uit waar je in de mainloop was), handel je je dringende zaken af, en dan keer je terug naar waar je bezig was in de mainloop. Uiteraard moet je de interrupt kort houden, om de mainloop niet te hard te vertragen.

[ThinkPad]

Kwam net deze tegen: http://hackaday.com/2014/...-this-rgb-led-tachometer/ ook een leuk projectje, OBD gebaseerd.

[Luppie]

Ondertussen ben ik begonnen om het 7-segment display te vervangen door een mooi klein OLED schermpje.
Eerst test ziet er veelbelovend uit.

[YouTube: http://youtu.be/QCe8lUa7aDs]

Binnenkort plaats ik de aangepaste code.

[Damic]

Serieel aangestuurd heb hier ook 2 oledjes liggen een blauw en een wit, weet begot nog niet wat ik ermee gaan doen

[Luppie]

De aangepaste code voor gebruik met het OLED scherm:

C++:

#include <Wire.h>
#include <GOFi2cOLED.h>
#include <TinyGPS++.h>

TinyGPSPlus gps;
GOFi2cOLED GOFoled;

int Snelheid=0;
int Satelliet = 0;
int Tijd = 0;
int GMTOffset = 2;

void setup()   {                  
  //default address is 0x3D.
  GOFoled.init(0x3C);
  // init done
  
  GOFoled.display(); // show splashscreen
  delay(5000);
  GOFoled.clearDisplay();

  Serial.begin(9600);
  
}

void loop() {

        Satelliet = (gps.satellites.value());
        GOFoled.setTextSize(1);
        GOFoled.setTextColor(WHITE);
        GOFoled.setCursor(0,0);
        GOFoled.clearArea(0,0,127,8);
        GOFoled.print("Satellites : ");
        GOFoled.print(Satelliet);

        GOFoled.println();
        GOFoled.setTextSize(1);
        GOFoled.clearArea(0,8,127,8);
        GOFoled.print("Time       : ");
        printTime(gps.time);

        Snelheid = (gps.speed.kmph());  
        GOFoled.clearArea(0,30,127,34);
        GOFoled.setCursor(0,30);
        GOFoled.setTextSize(5);
        GOFoled.print(Snelheid);
        GOFoled.setTextSize(1);
        GOFoled.print("km/h");     
        GOFoled.display(); 
        
   smartDelay(1000);
}

static void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (Serial.available())
      gps.encode(Serial.read());
  } while (millis() - start < ms);
}

static void printTime(TinyGPSTime &t)
{
    char sz[32];

    int hour = t.hour() + GMTOffset;
    if (hour > 23) 
    {hour = hour - 24;}
        
    sprintf(sz, "%02d:%02d:%02d ", hour, t.minute(), t.second());
    GOFoled.print(sz);
 }

[ Voor 38% gewijzigd door Luppie op 27-07-2014 23:34 ]

[ThinkPad]

Mooi Maar ik mis nogsteeds de LDR om de helderheid te regelen

Had trouwens niet verwacht dat die OLED dingen zo simpel aan te sturen waren met Arduino...

[ Voor 33% gewijzigd door ThinkPad op 26-07-2014 00:52 ]

[Luppie]

ThinkPadd schreef op zaterdag 26 juli 2014 @ 00:49:
Mooi Maar ik mis nogsteeds de LDR om de helderheid te regelen

Had trouwens niet verwacht dat die OLED dingen zo simpel aan te sturen waren met Arduino...

In mijn V2 had ik wel een LDR zitten, maar met het OLED scherm vind ik het niet meer zo noodzakelijk.
Had het in V2 opgelost met deze code:

C++:

      int LDRReading = analogRead(LDR_Pin);
      Helderheid = 100;
      if (LDRReading < 800) Helderheid = 80;
      if (LDRReading < 600) Helderheid = 60;
      if (LDRReading < 400) Helderheid = 40;
      if (LDRReading < 200) Helderheid = 20;  
      sevseg.Brightness(Helderheid);

Dit dimt het display in 5 gradaties, naar mate het schemeriger wordt.

Voor gebruik met het OLED scherm kan je dit ook gebruiken op de volgende manier:

C++:

      int LDRReading = analogRead(LDR_Pin);
      Helderheid = 250;
      if (LDRReading < 800) Helderheid = 200;
      if (LDRReading < 600) Helderheid = 150;
      if (LDRReading < 400) Helderheid = 100;
      if (LDRReading < 200) Helderheid = 50;  
     GOFoled.setBrightness(Helderheid);

Zoals je kan zien, kan je heel veel met heel weinig code, door het gebruik van libraries
Hier trouwens heel veel info over het aansturen van een 128x64 OLED:
http://www.geekonfire.com...le=I2C_OLED_Panel(128x64)
(Zelf heb ik mijn OLED bij DX gekocht, om de voorbeelden en library van deze site te gebruiken, dien je GOFoled.init(0x3D); aan te passen naar GOFoled.init(0x3C);
Nu nog eens gaan verdiepen in interupts.

[ Voor 25% gewijzigd door Luppie op 26-07-2014 15:27 ]

[Damic]

na lange tijd alles te hebben liggen, toch maar eens gedacht om eraan te beginnen, lekker alles aansluiten en dan code kloppen. Alles mooi includen en dan compilen. Hu? Niets anders dan errors enzo. Na wat uitzoeken e.d. viel mijn €, Arduino en normaal avride werkt niet tezamen

Nu dus eerst opzoek naar de juiste libs en dan kan ik verder

[ Voor 3% gewijzigd door Damic op 05-10-2014 17:55 ]

[ThinkPad]

Soortgelijk project: http://instructables.com/...I-Gauge-in-With-OEM-Look/

[Damic]

Heb eindelijk het display aan de praat gekregen maar dan via u8glib volledige writeup is op CO te vinden: http://www.circuitsonline.net/forum/view/123789. Nu nog verder doen met de gps zelf, steekt er al half in maar heb hier toch geen fix

@thinpad: oh lijkt me wel leuk om mijn klok door te vervangen.

[ Voor 11% gewijzigd door Damic op 25-12-2014 13:08 ]

[Luppie]

Ik heb mijn eerste testen buiten gedaan (was ook wel lekker weer ) Eerste keer duurde even, maar toch een fix. Je krijgt wel output van je GPS ?

[Stoney3K]

ThinkPadd schreef op maandag 30 juni 2014 @ 22:59:
Filmpje! Filmpje! Filmpje!

Mee eens! Ik wil je natuurlijk wel in één ruk zien optrekken naar 88 dan hè en je in 1985 in de krant zien staan

[Damic]

Heb me dan maar een paar arduino's aangeschaft even testen op de mega 2560

C++:

#include <Wire.h>
#include <GOFi2cOLED.h>
#include <TinyGPS++.h>
 
TinyGPSPlus gps;
GOFi2cOLED GOFoled;
 
int GMTOffset = 1;
int pinDST = 22;
 
static void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do 
  {
    while (Serial.available())
    gps.encode(Serial.read());
  } while (millis() - start < ms);
}
 
static void printTime(TinyGPSTime &t)
{
  char sz[32];int DST =0;
  if (digitalRead(pinDST)==0){DST=1;}
  int hour = t.hour() + GMTOffset+DST;
  if (hour > 23) {hour -= 24;}
  sprintf(sz,"%02d:%02d:%02d ", hour, t.minute(), t.second());
  GOFoled.print(sz);
 }
 
void setup()
{                  
  pinMode(pinDST, INPUT);           // set pin to input
  digitalWrite(pinDST, HIGH);       // turn on pullup resistors
  //default address is 0x3D. 0x3c
  GOFoled.init(0x3D);
  // init done
  Serial.begin(9600); 
}
 
void loop(void)
{
  GOFoled.clearDisplay();
  GOFoled.setTextSize(1);
  GOFoled.setTextColor(WHITE);
  //show sattelites
  GOFoled.setCursor(0,0);
  GOFoled.print("Sattelites: ");
  GOFoled.print(gps.satellites.value());
  //show time
  GOFoled.setTextSize(2);
  GOFoled.setCursor(15,11);
  printTime(gps.time);
  //show speed
  GOFoled.setCursor(0,30);
  GOFoled.setTextSize(5);
  GOFoled.print(gps.speed.kmph());
  //speed text
  GOFoled.setCursor(90,0);
  GOFoled.setTextSize(1);
  GOFoled.print("[km/h]");     
  
  GOFoled.display(); 
  smartDelay(500);
}

geeft

Foto is niet al te helder maar is heel goed leesbaar.

Als je een beetje c kunt dan zie je dat ik via een input selecteer of dat het winter/zomer uur is. op de mega 2560 is dat een pin van 22 tot 53. Ook wat aan geheugen beheer gedaan zodoende dat er minder rommel mee word gecompileerd (van +-17k naar 14.6k ).

*Disclaimer: als je de usb gebruikt dan kan het zijn dat de arduino niet doorstart en dus niets op het scherm toont, verander serial dan naar serial1*

[ Voor 11% gewijzigd door Damic op 28-11-2015 10:43 ]

[Damic]

Voor de nano:

**Zie code volgende post **

Update: 01/11/2015
- snelheid centreert zich automagisch
- een "delay" ingebouwd zodoende dat je niet zelf op de reset knop moet duwen

Update: 28/11/2015
- de delay werkt niet

[ Voor 101% gewijzigd door Damic op 21-04-2019 17:27 . Reden: Snelheid centreerd zich nu automagisch :+ ]

[Damic]

Even kicken

heb de unit wat meer functies gegeven
Uitleg van de ingangen:
Pin 2: DST
Pin 3: kmph/mph
Pin 4: scherm omdraaien
Pin 5: 12/24h notatie
Pin 6: optellen of aftrekken van de uren (UTC offset)
Pin 7: 1h offset
Pin 8: 2h offset
Pin 9: 4h offset
Pin 10: 8h offset

Code voor de nano:

C++:

#include <Wire.h>
//just put these 2 modules in the same directory as the ino file
#include "GOFi2cOLED.h" 
#include "TinyGPS++.h"

TinyGPSPlus gps;
GOFi2cOLED GOFoled;

//pin defines
//Pin 2: DST yes/no
#define pinKmph 3 //kmph or Mph pin
//pin 4: rotate screen 180°
//pin 5: 12 or 24h notation
//pin 6: add or subtract the offset
//pin 7: 1h
//pin 8: 2h
//pin 9: 4h
//pin 10: 8h

volatile int GPSspeed; //stores the current gps speed

static void smartDelay(unsigned int ms)
{
  unsigned long start = millis();
  do
  {
    while (Serial.available())
      gps.encode(Serial.read());
  } while (millis() - start < ms);
}

 int GMToffset()
{
  int result=0;
  if (digitalRead(7) == 0){result++;} //+1h
  if (digitalRead(8) == 0){result+=2;} //+2h
  if (digitalRead(9) == 0){result+=4;} //+4h
  if (digitalRead(10) == 0){result+=8;} //+8h
  if (digitalRead(2) == 0){result++;} //DST
  if (digitalRead(6) == 0){result=-result;} //UTC-
  return result;
}

 void printTime(TinyGPSTime &t)
{
  GOFoled.setTextSize(1);
  GOFoled.setCursor(116, 11);
  int hour = t.hour() + GMToffset();
  if (hour > 23) {hour -= 24;}
  if (digitalRead(5) == 0)
  {
    if(hour>12)
    {
      hour-=12;
      GOFoled.print("PM");
    }else{
      if(hour==0){hour=12;}
      GOFoled.print("AM");
    }
  }
  char sz[10];
  sprintf(sz, "%02d:%02d:%02d", hour, t.minute(), t.second());
 
  GOFoled.setTextSize(2);
  GOFoled.setCursor(15, 11);
  GOFoled.print(sz);
}

void setup()
{
  for(unsigned int i=2;i<=10;i++)
  {
    pinMode(i, INPUT);           // set pin to input
    digitalWrite(i, HIGH);       // turn on pullup resistors
  }
  // start serial
  Serial.begin(9600);
  //start oled: default address is 0x3D or 0x3c
  GOFoled.init(0x3C);
 }

void loop(void)
{
  smartDelay(500);
  GOFoled.clearDisplay();
  if(digitalRead(4)==0){GOFoled.setRotation(2);}else{GOFoled.setRotation(0);}
  //show satelites in the left corner
  GOFoled.setTextSize(1);
  GOFoled.setCursor(0, 0);
  GOFoled.print("Sat.: ");
  GOFoled.print(gps.satellites.value());
  //speed text in the right corner
  if(digitalRead(pinKmph)==0){
    GOFoled.setCursor(92, 0);
    GOFoled.print("[km/h]");
  }else{
    GOFoled.setCursor(98, 0);
    GOFoled.print("[Mph]");
  }
  //show time
  printTime(gps.time);
  //show speed
  GOFoled.setCursor(0, 0);
  GOFoled.setTextSize(5);
  if(digitalRead(pinKmph)==0){
    GPSspeed=round(gps.speed.kmph());
  }else{
    GPSspeed=round(gps.speed.mph());
  }
  //center speed
  if(GPSspeed<10)
  {
    GOFoled.setCursor(50, 30);
  }else if(GPSspeed<100){
    //2 numbers
    GOFoled.setCursor(35, 30);
  }else{
    //3 numbers
    GOFoled.setCursor(20, 30);
  }
  GOFoled.print(GPSspeed);
  GOFoled.display();
}