Arduino stopwatch


Op 18 augustus 2019 12:48:46 schreef fcapri:
als je graag wil stoeien met arduino's, zou je een aantal nano's kunnen gebruiken en 1 nano per display zetten.

dan kan je serieel gewoon de data doorsturen vanuit je mega en zullen de nano's zelf afhandelen hoe ze het scherm aansturen.
beetje overkill maar een nano kost tegenwoordig maar ongeveer 1,3-1,5€ meer en je zal direct veel bijleren

Ik ben daar wel voorstander van, heel hard zelfs, maar ik vrees dat de TS er nog niet klaar voor is en iets zoekt die af is.
Die modules zijn wel goedkoop maar er is nog heel veel werk aan, niet voor beginners.

LDmicro user.
Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Arco, volgens de TS zijn ze 12V/4w = 300mA/seg is dat niet wat veel voor die drivers? sorry worden gemultiplext, was dat even vergeten...

[Bericht gewijzigd door MGP op 19 augustus 2019 21:26:56 (26%)]

LDmicro user.

Bedankt allemaal voor de reactie, leuk om te lezen wat allemaal de mogelijkheden zijn. Wel vind ik het moeilijk wat ik nu het beste kan doen. Inmiddels zelf een ontwerpje gemaakt hoe ik het graag wil uit laten zien (zie foto). Hier heeft de stopwatch 5 digits omdat men niet boven de 9:59:59 uitkomt en dus zonde is van de ruimte.

Nu het denk gedeelte. Zelf leek mijn een arduino een goede oplossing alleen loop ik met dit projectje vast. Na wat geknutseld te hebben met een matrix display bord leek mij dit ook wel te doen zijn...

Wat ik al aangaf er zijn hier en daar wel wat voorbeeldjes te vinden alleen kan ik ze niet koppelen aan wat mijn wensen zijn :?

Wat MGP al zegt het ontwerpen van een besturing zal ik mij nog niet mee redden.

Op 19 augustus 2019 20:57:58 schreef MGP:
[...]
Ik ben daar wel voorstander van, heel hard zelfs, maar ik vrees dat de TS er nog niet klaar voor is en iets zoekt die af is.
Die modules zijn wel goedkoop maar er is nog heel veel werk aan, niet voor beginners.

bprosman

Golden Member

Even niet lettende op de overkill, maar als ik echt beginner was zou ik me niet wagen aan multiplexen (timing kritisch), of schuifregisters (serieel klokken etc.). Ik zou dan lekker alles parallel doen.

Het schema van deKees wat betreft de ULN, maar ipv de schuifregisters zou ik parallel registers als een 74LS374 of 74LS574 gebruiken.
TS heeft een ATMega, pennen genoeg, data parallel zetten op de registers en een ATMega IO pin per IC om in te "Latchen".

Dan ben je qua timing zo goed als onafhankelijk.

Mocht er belangstelling zijn voor deze methode wil ik wel een schema'tje tekenen.

De jongere generatie loopt veel te vaak zijn PIC achterna.

Op 19 augustus 2019 20:13:56 schreef flipflop: Je hebt nog maar 17% van het licht over.

Multiplexen van dit soort displays is zo oud als de weg naar de Peel. Tried, proven en tested technology. Wordt dagelijks overal voor gebruikt. Je LED-rekenmachientje uit 1972 deed het ook al.

Don't Panic!

Klopt, multiplexen is goedkoop en goed te doen.

Maar gaat wel ten koste van de licht opbrengst. Dat rekenmachientje uit 1972 was volledig nutteloos buiten in de zon.

En tegenwoordig kosten de chips bijna niks meer.
Ik zou in dit geval een klein printje maken om een enkele digit aan te sturen, met een schuifregister en een ULN erop. Dan kun je er zoveel achter elkaar zetten als je maar wilt met een klein aantal draden tussen de digits.

Als je alles parallel wilt aansturen dan krijg je 50 draden vanaf je arduino. Kan ook wel maar is veel bewerkelijker en een extra digit gaat niet meer.

bprosman

Golden Member

Als je alles parallel wilt aansturen dan krijg je 50 draden vanaf je arduino. Kan ook wel maar is veel bewerkelijker en een extra digit gaat niet meer.

50 is wat overdreven :-)

8 Datalijnen (naar iedere digit).
2 Voedingslijnen (naar iedere digit).
1 Clock en evt reset.

Kom ik op 12 per digit, waarvan er 10 (data en voeding) doorgelust kunnen worden.

De jongere generatie loopt veel te vaak zijn PIC achterna.

Als je aan zoiets begint moet je al redelijk goed kunnen programmeren of toch zeker wat ervaring hebben.

De K8063 van Velleman heb ik altijd een heel goed ontwerp gevonden waarvan je hier in de handleiding het schema kunt zien.
https://www.velleman.eu/downloads/0/illustrated/illustrated_..._k8063.pdf
Het programma moet niet zo uitgebreid zijn als ze hier voorstellen, met dipswitchen/soldeercontacten zou je het het adres kunnen instellen.

Zelfs zonder adressering kan het ook en serieel in en out gebruiken en gewoon aan elkaar koppelen, 4 of 5 cijfers serieel doorschuiven werkt ook prima

Met een nano is dat goed te doen.

Maak 1 segment en probeer dat aan de praat te krijgen want als je teveel hooi op uw vork neemt zal de goesting rap over zijn.

LDmicro user.

Op 20 augustus 2019 23:58:54 schreef bprosman:
Even niet lettende op de overkill, maar als ik echt beginner was zou ik me niet wagen aan multiplexen (timing kritisch), of schuifregisters (serieel klokken etc.). Ik zou dan lekker alles parallel doen.

Het schema van deKees wat betreft de ULN, maar ipv de schuifregisters zou ik parallel registers als een 74LS374 of 74LS574 gebruiken.
TS heeft een ATMega, pennen genoeg, data parallel zetten op de registers en een ATMega IO pin per IC om in te "Latchen".

Dan ben je qua timing zo goed als onafhankelijk.

Mocht er belangstelling zijn voor deze methode wil ik wel een schema'tje tekenen.

Dat zou super zijn. Die moeten aangestuurd worden door een arduino?

zou ik me niet wagen aan multiplexen (timing kritisch)

Is juist weinig timing kritisch! (wat sneller of langzamer maakt weinig uit)
Als je daar een timer voor gebruikt is dat trouwens rotsvast in een paar regels code. Pseudo voorbeeld (timer bijv. iedere 2mS):

pic basic code:


TimerInt:  

  portA = 0
  PortB = digitdata[digcount]
  PortA = 1 << digcount
  Inc(digcount)

End TimerInt 

[Bericht gewijzigd door Arco op 21 augustus 2019 11:13:55 (33%)]

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Zo moeilijk is een shuifregister niet:

code:


void ShiftByte(char Segments)
{  for(int i = 0; i < 8; i++)
   {  digitalWrite(LED_DATA, (Segments & 0x01) ? HIGH : LOW);
      digitalWrite(LED_CLOCK, HIGH);
      Segments >>= 1;
      digitalWrite(LED_CLOCK, LOW);
   } 
}

Een complete funktie om het display aan te sturen kan er dan zo uitzien:

code:



// Map arduino pin numbers to 74HC595 shift register.
#define LED_DATA  1  // Serial data input for shift register

#define LED_CLOCK 2  // Idle low
                     // High puls shifts data in shift register

#define LED_LATCH 3  // Idle Low
                     // High pulse writes data from shift register to outputs.


void ShiftByte(char Segments)
{  for(int i = 0; i < 8; i++)
   {  digitalWrite(LED_DATA, (Segments & 0x01) ? HIGH : LOW);
      digitalWrite(LED_CLOCK, HIGH);
      Segments >>= 1;
      digitalWrite(LED_CLOCK, LOW);
   } 
}


struct SegmentTableEntry
{  char Ascii;
   char Segments;
};

SegmentTableEntry SegmentTable[] = 
{  { '0', 0b11111100 },
   { '1', 0b01100000 },
   { '2', 0b11011010 },
   { '3', 0b11110010 },
   { '4', 0b01100100 },
   { '5', 0b10110110 },
   { '6', 0b10111110 },
   { '7', 0b11100000 },
   { '8', 0b11111110 },
   { '9', 0b11110110 },
   { ' ', 0b00000000 },
   { '-', 0b00000010 }, 
};

#define NR_ENTRIES(a) (sizeof(a)/sizeof(a[0]))

// Convert Ascii code to segments through table
char GetSegments(char c)
{  for(int i = 0; i < NR_ENTRIES(SegmentTable); i++)
   {  if(SegmentTable[i].Ascii == c)
      {  return SegmentTable[i].Segments;
      }
   }
   
   // Special code for characters that are not in the SegmentTable. 
   return 0b10010010;
}

void UpdateDisplay(char *pBuffer, int NrDigits)
{  pinMode(LED_DATA,  OUTPUT);
   pinMode(LED_CLOCK, OUTPUT);
   pinMode(LED_LATCH, OUTPUT);

   digitalWrite(LED_LATCH, LOW);
   digitalWrite(LED_CLOCK, LOW);

   // Send all data to the shift registers
   for(int i = 0; i < NrDigits; i++)
   {  char Segments = GetSegments(pBuffer[i]);
      ShiftByte(Segments);
   }
   
   // Move data from shift register to output drivers
   digitalWrite(LED_LATCH, HIGH);
   digitalWrite(LED_LATCH, LOW);
}

Klopt, multiplexen is goedkoop en goed te doen.
Maar gaat wel ten koste van de licht opbrengst. Dat rekenmachientje uit 1972 was volledig nutteloos buiten in de zon.

Je kunt een led van 50 jaar geleden niet met een moderne versie gelijkstellen... ;)
Moderne HE leds en displays geven echt nog heel erg veel licht bij multiplexen...

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Ik dacht meteen aan een MAX7219 of een MAX7221 die de verbinding legt tussen een Arduino en een 7-segment display. Deze Ic's communiceren met de Arduino over een SPI-bus en ze regelen ook de benodigde stroom die elke digit nodig heeft. Maar daar je segmenten zijn opgebouwd uit 11 LEDs op 12volt denk ik dat het dan beter is om de uitgangen van het IC met een driver zoals een ULN2803 te verbinden. Dit ic kan tot 500mA per kanaal leveren wat wel ruim voldoende is om 11 LEDs te sturen.

Deze link zou je al op weg moeten helpen om je leds aan te sturen.

http://www.learningaboutelectronics.com/Articles/Max7219-4-d...ircuit.php

Depeet

@arco:

In je schema gebruik je een UDN2981. Bij Digikey zie ik dat dit verouderd is. Als we op onze dienst iets moeten ontwerpen proberen we om verouderde IC te mijden. Niet omdat ze slecht zijn maar omdat we de componenten na 10 jaar nog goed kunnen verkrijgen. Ik weet het, 10 jaar is binnen elektronica een eeuwigheid.

Als vervanger voor een UDN2981 kan je een TBD62083 gebruiken. Voor een ULN2803 is TBD62783 een alternatief. Qua pinout en specificaties zijn ze compatible en de dropvoltage is kleiner.
De TBD zijn MOSFETS terwijl een ULN bipolair is.

Depeet
Jochem

Golden Member

Multiplexen kan, en is ook bij displays gebruikelijk. Maar de situatie van TS is wel iets unieker dan het gros van de toepassingen.

Normaal ga je bij multiplexen de stroom verhogen. In geval van TS wil je dat zeker, want de lichtopbrengst is extra belangrijk omdat het bij wedstrijden goed zichtbaar moet blijven.

Omdat TS segmenten heeft met ingebouwde weerstand moet je dan dus de spanning gaan opvoeren. Als je 6 segmenten multiplext dan wordt dat wel heel gortig, want dan zou je toch ergens in de richting van 6x12V moeten gaan. Maar zelfs bij een beperktere spanning (zeg 48V) wordt het allemaal al lastig met je drivers.

Verder is TS een beginner, en het zou kunnen dat hij bij het programmeren van software (of het aansluiten van hardware) iets verkeerd doet, waardoor een voor iets langere duur een segment aan blijft. Dat segment is dan binnen een mum van tijd stuk.

Ik denk dat dat 2 goede redenen zijn om in dit geval schuifregisters te gebruiken in plaats van te multiplexen.

Heb geduld: alle dingen zijn moeilijk voordat ze gemakkelijk worden.

De 2981 is nog gewoon 'active' en in productie: https://www.microchip.com/wwwproducts/en/MIC2981
(zelf gebruik ik meestal losse transistoren)

Ik zie trouwens nergens staan dat er weerstanden in die segmenten zitten?

[Bericht gewijzigd door Arco op 21 augustus 2019 13:40:34 (21%)]

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Op 21 augustus 2019 13:37:52 schreef Arco:
De 2981 is nog gewoon 'active' en in productie: https://www.microchip.com/wwwproducts/en/MIC2981
(zelf gebruik ik meestal losse transistoren)

Ik zie trouwens nergens staan dat er weerstanden in die segmenten zitten?

Ik kijk altijd bij mijn "elektronicaboer". Als die verouderd meldt, wil dat natuurlijk niet zeggen dat ze niet meer leverbaar zijn. Maar ik hou er wel rekening mee dat ze binnen een aantal jaren niet meer worden geproduceerd.
Die TBD's heb ik toevallig gevonden met een vorig projectje. Vond ook drivers die konden sinken en sourcen. Maar een 32-pin SOIC is nou niet echt voor iedereen weggelegd. Ik moet er al helemaal niet aan beginnen :-)

Zondag om 12:35 schreef TS

"Ik wil het graag voor buiten gebruiken, elk digit is inderdaad 4 watt dus zal elk segment 50mA zijn. Hier is geen voorschakelweerstand meer nodig 12V en klaar."

Daar hoeven we dus rekening meer mee te houden ;-)

Depeet

Veel leveranciers (bijv. Farnell) geven soms op dat onderdelen obsolete zijn.
Ze vermelden er dan niet bij dat ze nog wel leverbaar zijn van 20 andere merken... :(

De MIC2981 is nu van Microchip, dus obsolete zal die niet echt gauw worden.

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com
Jochem

Golden Member

Op 21 augustus 2019 13:37:52 schreef Arco:
Ik zie trouwens nergens staan dat er weerstanden in die segmenten zitten?

TS zegt dat ze op 12V werken zonder voorschakelweerstand. Dan concludeer ik dat die intern zitten (een echte stroombron per segment zullen ze wel niet gedaan hebben).

Heb geduld: alle dingen zijn moeilijk voordat ze gemakkelijk worden.

Op 21 augustus 2019 11:43:23 schreef deKees:
Zo moeilijk is een shuifregister niet:

code:


void ShiftByte(char Segments)
{  for(int i = 0; i < 8; i++)
   {  digitalWrite(LED_DATA, (Segments & 0x01) ? HIGH : LOW);
      digitalWrite(LED_CLOCK, HIGH);
      Segments >>= 1;
      digitalWrite(LED_CLOCK, LOW);
   } 
}

Een complete funktie om het display aan te sturen kan er dan zo uitzien:

code:



// Map arduino pin numbers to 74HC595 shift register.
#define LED_DATA  1  // Serial data input for shift register

#define LED_CLOCK 2  // Idle low
                     // High puls shifts data in shift register

#define LED_LATCH 3  // Idle Low
                     // High pulse writes data from shift register to outputs.


void ShiftByte(char Segments)
{  for(int i = 0; i < 8; i++)
   {  digitalWrite(LED_DATA, (Segments & 0x01) ? HIGH : LOW);
      digitalWrite(LED_CLOCK, HIGH);
      Segments >>= 1;
      digitalWrite(LED_CLOCK, LOW);
   } 
}


struct SegmentTableEntry
{  char Ascii;
   char Segments;
};

SegmentTableEntry SegmentTable[] = 
{  { '0', 0b11111100 },
   { '1', 0b01100000 },
   { '2', 0b11011010 },
   { '3', 0b11110010 },
   { '4', 0b01100100 },
   { '5', 0b10110110 },
   { '6', 0b10111110 },
   { '7', 0b11100000 },
   { '8', 0b11111110 },
   { '9', 0b11110110 },
   { ' ', 0b00000000 },
   { '-', 0b00000010 }, 
};

#define NR_ENTRIES(a) (sizeof(a)/sizeof(a[0]))

// Convert Ascii code to segments through table
char GetSegments(char c)
{  for(int i = 0; i < NR_ENTRIES(SegmentTable); i++)
   {  if(SegmentTable[i].Ascii == c)
      {  return SegmentTable[i].Segments;
      }
   }
   
   // Special code for characters that are not in the SegmentTable. 
   return 0b10010010;
}

void UpdateDisplay(char *pBuffer, int NrDigits)
{  pinMode(LED_DATA,  OUTPUT);
   pinMode(LED_CLOCK, OUTPUT);
   pinMode(LED_LATCH, OUTPUT);

   digitalWrite(LED_LATCH, LOW);
   digitalWrite(LED_CLOCK, LOW);

   // Send all data to the shift registers
   for(int i = 0; i < NrDigits; i++)
   {  char Segments = GetSegments(pBuffer[i]);
      ShiftByte(Segments);
   }
   
   // Move data from shift register to output drivers
   digitalWrite(LED_LATCH, HIGH);
   digitalWrite(LED_LATCH, LOW);
}

Zijn hier nog bepaalde bibliotheek bestanden voor nodig?

Lees die code nou even, dan zie je dat toch vanzelf?! Zie je ergens functies oid die niet in de code zelf staan?

ps, quote van die hele lap is niet zo nuttig.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
bprosman

Golden Member

Lees die code nou even, dan zie je dat toch vanzelf?! Zie je ergens functies oid die niet in de code zelf staan

Ik gok dat TS tenauwernood weet wat een functie is :?

De jongere generatie loopt veel te vaak zijn PIC achterna.

Weet jij het? aangezien de TS een beginner is kun je het hem misschien eens uitleggen of uitleggen waar hij moet op letten om dat te zien :p

LDmicro user.

Het lijkt me dat ie toch wel iets van Arduino weet, gezien de ambitie van zo'n project. Dan zul je toch een beetje moeten kunnen programmeren. We wachten het eerst maar even af.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein