Arduino stopwatch

Dag Allemaal.

Ik wil graag een 6 digit 7 segmenten stopwatch maken. Ik heb inmiddels al veel gelezen op het dit forum en elders maar ik kom er nog niet helemaal uit. Ik zou graag een arduino board willen gebruiken. Er zijn al veel geschreven programma`s te vinden alleen weet ik ze nog niet te koppelen aan mijn hieronder genoemde nummers

Mijn stopwatch moet kunnen aangeven uren/minuten/seconden. Graag zou ik er een start stop knop op willen en een reset knop. Voor deze stopwatch wou ik graag de volgende nummers gebruiken.(zie afbeelding)
De spanning van deze segmenten zijn 12V en 4 watt per digit.
Heeft iemand hier al eens mee gestoeid of heeft iemand goeie ideeën hier voor?

De segmenten zijn ongeveer 8 inch groot dit omdat ik ze graag voor wedstrijden wil gaan gebruiken.

Alvast bedankt,

Steelwood

6 digits met 7 segmenten. Daarvoor heb je 42 pinnen nodig, en een standaard Arduino heeft er niet zoveel. Dus dan moet je gaan multiplexen, of bijvoorbeeld schuif registers toevoegen.

Is het voor binnen of voor buiten? Binnenshuis is er minder licht nodig dus dan is multiplexen geen probleem. Voor toepassing buiten zou ik eerder de displays parallel aansturen om max lichtopbrengst te krijgen.

En die displays? 12 Volt, 4 Watt is dus 330 mA. Is dat voor alle segmenten samen? Dus 50 mA per segment?

Elk segment heeft 12 leds zie ik. Waarschijnlijk dus 2 x 6. Heeft die al een serie weerstand ingebouwd? Of moet je zelf voor stroombegrenzing zorgen?

En de software aansturing. Heb je al iets op het oog of wil ze zelf gaan programmeren? Welke Arduino wil je gebruiken?

ik heb er al wat mee gespeelt, heb eerst zelf mijn 7segment displays gemaakt op print, daarna een I2C 7segment display gemaakt.

een probleem die je al gaat hebben is de stroom. je zal die displays met een transistor moeten aansturen, de uitgangen van een arduino kunnen niet de stroom leveren voor die leds.

ik hou van werken ..., ik kan er uren naar kijken

Multiplexen zou ik niet aan beginnen met zoveel segmenten. De helderheid gaat dan met een factor 6 achteruit, da's veel. Ik zou gewoon een stel shiftregisters nemen, een 74595 wordt veel gebruikt in de Arduino wereld, dus dan heb je voorbeelden genoeg. Je zult er een aantal nodig hebben die je achter elkaar in serie kunt zetten.
Over elektrische aansturing vd LEDs heb je het niet, dus geen idee of dat ook deel van de vraag is.

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

Bedankt voor jullie reactie.

Het zelf schrijven van een arduino programma ben ik nog geen ster in, wel heb ik al wel veel gestoeid met programmeren van een arduino board met bestaande programma's. Ik heb een arduino mega 2560 in bezit en de standaard uno. Ik verwacht dat de arduino mega 2560 hier een goede optie in zal zijn.

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. Graag zou ik arduino mega 2560 willen gebruiken zodat ik elke segment apart kan aansturen.

Betreft software sturing heb ik nog niet iets toepassend gevonden. Wel is er van alles te vinden. Het moet dus een uren/minuten/seconden stopwatch zijn en veel programma`s zijn minuten/seconden (4 digit stopwatch)

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 hou van werken ..., ik kan er uren naar kijken

Inderdaad, heel klein beetje overkill :) Bedenk ook dat je ze steeds alle 6 moet programmeren bij elke kleine update. Niet doen, lelijk.
@TS, het werken met Arduino heeft als voordeel dat je heel veel voorbeelden hebt, en vaak zelfs een complete oplossing die je zo kunt copieren. Maar als je iets specifieks wilt maken, zul je zelf moeten programmeren. En da's wel zo leuk, want domweg copieren is nou niet echt een uitdaging, wel?
Het best kun je eerst eens een schetsje maken van de schakeling die je wilt maken. Daarna kun je pas gaan programmeren. Dus, besluit eerst hoe je het gaat doen.
- multiplexen: pinnen: 7 voor de segmenten, 6 voor elk segment. Nadeel: minder licht.
- schuifregisters: 3 pinnen voor alles. Nadeel: 6 extra IC's naast je micro.
- nog meer?

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

of je nu een schuifregister moet bijsteken, of een nano erbij inpluggen... qua kost en werk zit je even duur.

kan je gewoon 1 stukje software schrijven die serieel een karakter ontvangt en dit omzet naar 7segemt op 8 uitgangen (7segmenten en een punt).
de code in de display arduino's zal pakweg 5-10regels zijn en moet je niet herprogrammeren. eens die serieel naar segment omzetten, ben je er.

je kan dan de hoofd arduino nog aanpassen voor andere taken en berekeningen en de dubbele punten laten knipperen.

als je dan nog aanpassingen wil, zoals bv een 9 met het streepje onderaan of niet, dat zit dan specifiek in de display arduino's.

ik wou dat ik daar vroeger nog mee begonnen was, want ik maak ook zelf wat dingen voor automotieve (oldtimer), en merk toch vaak dat 1 arduino het niet trekt daar. best dan makkelijk dat je een arduino hebt die alles berekent, een arduino die alle sensoren uitleest, een arduino die zich bezig houd met het display, en daartussen een eigen BUS protocol.
met dergelijke kleine projectjes als TS is het makkelijk om dit deel al onder de knie te krijgen. als je dat allemaal nog mee moet ontwikkelen als je al zoveel hebt te bouwen, dan stap je af van dat idee.

zo heb ik ook oefeningen gemaakt in arduino waarbij ik met threads of objecten werk (om een led te laten knipperen), waar het totaal niet nodig was. maar t zijn wel mooie voorbeeldoefeningen om later stukken uit te kopieren

niks zo leuk als te zeggen
LED.blink(300); en dat die dan 300ms aangaat en daarna zelf weer uit

ik hou van werken ..., ik kan er uren naar kijken

Met schuif-registers en buffers kun je alles aansluiten. Kun je aansturen met 3 pinnen uit een Arduino.

Met rechtstreeks aansturen heb je ook maar 13 pinnen nodig...
(voor 6 displays en 7 toetsen)

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

Klopt.
Maar dan ga je multiplexen, dus iets minder licht.
En je moet nog 12-Volt buffers toevoegen.

Lambiek

Special Member

Wat je ook nog kan overwegen is dit IC.

https://docs-emea.rs-online.com/webdocs/05fe/0900766b805fe017.pdf

Gebruik ik zelf ook nog al eens. En met een ULN2003 als buffer er achter kun je de segmenten makkelijk aansturen.

Op deze manier heb ik het toen gedaan.

Als je haar maar goed zit, GROETEN LAMBIEK.

Op 18 augustus 2019 23:52:59 schreef deKees:
..dan ga je multiplexen, dus iets minder licht.

Iets minder?! Je hebt nog maar 17% van het licht over.

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

Bij multiplexen moet je uiteraard de stroom ook verhogen... (totale stroom blijft dan toch gelijk)
Wel een hele simpele schakeling, de transistoren kun je nog door een ULN vervangen. Hi-side kan met een UDN2981 driver.

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

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