7-segmentindicator 4 cijfers. Indicator met zeven segmenten

Een 7-segment display aansluiten op een Arduino is een geweldig instapproject om je Arduino-bord beter te leren kennen. Maar het is vrij eenvoudig om te doen. Daarom zullen we de taak enigszins ingewikkelder maken en een viercijferige zevensegmentindicator aansluiten.

In dit geval gebruiken we een viercijferige LED-indicatormodule met een gemeenschappelijke kathode.

Elk segment in de indicatormodule is gemultiplext, wat betekent dat het één anodeverbindingspunt deelt met andere segmenten van de ontlading. En elk van de vier bits in de module heeft zijn eigen verbindingspunt met een gemeenschappelijke kathode. Hierdoor kan elk cijfer afzonderlijk worden in- of uitgeschakeld. Bovendien zorgt deze multiplexmethode ervoor dat de microcontroller slechts elf of twaalf pinnen gebruikt in plaats van tweeëndertig.

De LED-segmenten van de indicator vereisen de aansluiting van stroombegrenzende weerstanden wanneer ze worden gevoed vanaf 5 V op de logische pin. De weerstandswaarde wordt meestal tussen 330 en 470 ohm genomen. Het wordt ook aanbevolen om transistors te gebruiken om extra stroom te leveren, aangezien elke pin van de microcontroller maximaal 40 mA kan leveren. Als u alle ontladingssegmenten (nummer 8) inschakelt, overschrijdt het stroomverbruik deze limiet. De onderstaande afbeelding toont een aansluitschema voor een viercijferige zevensegmentindicator met behulp van stroombegrenzende weerstandstransistors.

Hieronder volgen diagrammen voor het aansluiten van de indicator op de Arduino-pinnen. Hier worden bipolaire NPN-transistoren BC547 gebruikt. Met een potentiometer van 10 KOhm aangesloten op de ingang van de A0-kaart kunt u de waarde die op de indicator wordt weergegeven, wijzigen van 0 in 1023.

Op het Arduino-bord worden in dit geval de digitale uitgangen D2-D8 gebruikt om de segmenten “a” tot en met “g” te besturen, en de digitale uitgangen D9-D12 worden gebruikt om de bits D0 tot en met D3 te besturen. Opgemerkt moet worden dat in dit voorbeeld de punt niet wordt gebruikt, maar in de onderstaande schets is het wel mogelijk om deze te gebruiken. Pin D13 van het Arduino-bord is gereserveerd voor het aansturen van het puntsegment.

Hieronder vindt u de code waarmee u een viercijferige segmentindicator kunt besturen met behulp van een Arduino-bord. Daarin specificeert de cijferreeks de codes van getallen van 0 tot 9 in binaire vorm. Deze schets ondersteunt zowel indicatoren met een gemeenschappelijke kathode (standaard) als indicatoren met een gemeenschappelijke anode (hiervoor moet u één regel aan het einde van de schets verwijderen).

Sinds de komst van radiotechniek en elektronica wordt feedback van een elektronisch apparaat en een persoon vergezeld door verschillende signaallichten, knoppen, tuimelschakelaars en bellen (het signaal van de magnetron dat klaar is - ding!). Sommige elektronische apparaten bieden een minimum aan informatie, omdat meer niet nodig zou zijn. Een brandende LED op de oplader van uw Chinese telefoon geeft bijvoorbeeld aan dat de oplader is aangesloten en stroom krijgt. Maar er zijn ook parameters waarvoor het handiger zou zijn om objectieve informatie te verstrekken. Bijvoorbeeld de luchttemperatuur buiten of de tijd op de wekker. Ja, dit alles kan ook worden gedaan met gloeiende lampen of LED's. Eén graad - één brandende diode of gloeilamp. Hoeveel graden er zijn, zoveel indicatoren staan ​​aan. Het tellen van deze vuurvliegjes is misschien wel gebruikelijk, maar nogmaals, hoeveel van deze lichten zijn er nodig om de temperatuur aan te geven met een nauwkeurigheid van een tiende graad? En welk gebied zullen deze LED's en gloeilampen in het algemeen innemen op een elektronisch apparaat?

Praktische weergaveapparaten met zeven segmenten moeten minimaal acht externe aansluitklemmen hebben; zeven daarvan bieden toegang tot individuele fotovoltaïsche segmenten, en de achtste biedt een gemeenschappelijke verbinding met alle segmenten. In het eerste geval staat het apparaat bekend als een gemeenschappelijk anodedisplay met zeven segmenten; in het laatste geval staat het apparaat bekend als een zeven-segment common-kathode display.

Om een ​​gemeenschappelijk anodedisplay aan te sturen, moet de driver een actief-laag-uitgang hebben, waarbij elke segmentaandrijving normaal gesproken hoog is, maar laag gaat om het segment in te schakelen. Om een ​​gemeenschappelijk kathodebeeldscherm aan te sturen, moet de driver over een actieve actieve uitgang beschikken.

En aan het begin van de twintigste eeuw, met de komst van elektronische buizen, verschenen de eerste gasontladingsindicatoren

Met behulp van dergelijke indicatoren was het mogelijk om digitale informatie in Arabische cijfers weer te geven. Vroeger werden deze lampen gebruikt om verschillende indicaties te geven voor instrumenten en andere elektronische apparaten. Momenteel worden gasontladingselementen vrijwel nergens toegepast. Maar retro is altijd in de mode en daarom verzamelen veel radioamateurs prachtige gasontladingshorloges voor zichzelf en hun dierbaren.

De volledige uitleg hiervan is iets ingewikkelder en luidt als volgt. Wanneer de spanning nul is, is het segment feitelijk onzichtbaar. Wanneer de ingangsspanning echter aanzienlijk positief of negatief is, wordt het segment effectief zichtbaar, maar als de stuurspanning langer dan een paar honderd milliseconden wordt gehandhaafd, kan het segment permanent zichtbaar worden en geen verdere betekenis hebben.

Onder deze omstandigheden is het segment uitgeschakeld. Het segment is dus onder deze voorwaarden opgenomen. Deze vorm van aandrijving staat algemeen bekend als een spanningsverdubbelend "bridge drive" -systeem. De volgorde van acties van het schema is als volgt. Het eerder beschreven eenvoudige cascadesysteem heeft het ernstige nadeel dat de weergave wazig wordt tijdens de feitelijke telperiode, en pas stabiel en leesbaar wordt wanneer elke telling voltooid is en de ingangspoort gesloten is. Dit "wazige en leesbare" type display is erg vervelend om naar te kijken.

Nadelen van gasontladingslampen: ze eten veel. Over duurzaamheid valt te twisten. Op onze universiteit gebruiken we nog steeds frequentiemeters op gasontladers in laboratoriumruimtes.

Met de komst van LED's is de situatie dramatisch veranderd. LED's verbruiken zelf een kleine hoeveelheid stroom. Als u ze op de juiste positie plaatst, kunt u absoluut alle informatie weergeven. Om alle Arabische cijfers te benadrukken, was gewoon iets genoeg zeven (vandaar de naam indicator met zeven segmenten) gloeiende LED-strips die op een bepaalde manier zijn gerangschikt:

Figuur 13 toont een verbeterd frequentietellercircuit dat gebruik maakt van displayvergrendeling om het bovenstaande defect te verhelpen. Dit schema werkt als volgt. Tegelijkertijd gaat de ingangspoort open en beginnen de tellers de ingangssignaalpulsen op te tellen. Deze teller gaat precies één seconde door, en gedurende deze periode voorkomen de vier-bits grendels dat de telleruitgang de beeldschermstuurprogramma's bereikt; het display blijft gedurende deze periode stabiel.

Na een paar seconden wordt de reeks opnieuw herhaald, waarbij de tellers opnieuw opstarten en vervolgens de ingangsfrequentiepulsen gedurende één seconde tellen, gedurende welke het display continu de vorige telling weergeeft, enz.

Bijna al deze zevensegmentindicatoren voegen ook een achtste segment toe: een punt, zodat het mogelijk is om de gehele en fractionele waarde van elke parameter weer te geven

Het circuit in figuur 13 produceert dus een stabiele weergave die één keer per seconde wordt bijgewerkt; in de praktijk kan de werkelijke telperiode hiervan en het diagram in figuur 12 in elk decennium worden uitgevoerd met meerdere of gedeeltelijke seconden, op voorwaarde dat de uitvoerweergave dienovereenkomstig wordt geschaald.

Houd er rekening mee dat een driecijferige frequentieteller maximale frequenties kan aangeven van 999 Hz bij gebruik van een tijdbasis van één seconde, 99 kHz bij gebruik van een tijdbasis van 100 ms, 9 kHz bij gebruik van een tijdbasis van 10 ms en 999 kHz bij gebruik van een tijdbasis van 10 ms. Tijdbasis van 1 ms.

In theorie blijkt het een indicator met acht segmenten te zijn, maar op de ouderwetse manier wordt het ook wel zevensegmenten genoemd, en daar is geen vergissing in.

Kortom, een indicator met zeven segmenten bestaat uit LED's die in een bepaalde volgorde ten opzichte van elkaar zijn geplaatst en in één behuizing zijn ingesloten.

Deze methode kan worden begrepen met behulp van figuren 14 en 15. Deze schakelaars zijn met elkaar verbonden en zorgen voor de daadwerkelijke multiplexeractie en moeten worden beschouwd als elektronische schakelaars met hoge snelheid die herhaaldelijk worden geschakeld via posities 1, 2 en de volgorde van de handelingen van de schakeling is als volgt. Laten we eerst aannemen dat de schakelaar in positie staat.

Even later gaat de schakelaar naar stand 3, waardoor display 3 na een paar minuten een getal weergeeft, de hele cyclus zich opnieuw begint te herhalen, enzovoort, waarbij het oneindige wordt toegevoegd. In de praktijk vinden ongeveer 50 van deze cycli elke seconde plaats, dus het oog ziet de displays niet afzonderlijk aan en uit gaan, maar neemt ze waar als een ogenschijnlijk stabiel display dat het getal 327 toont, of een ander getal dat wordt gedicteerd door het datasegment.

Als we het diagram van een enkele indicator met zeven segmenten bekijken, ziet het er als volgt uit:

Zoals we zien, kan de indicator met zeven segmenten beide zijn gemeenschappelijke anode (CA), dus met gemeenschappelijke kathode (OC). Grof gezegd, als we een zeven-segment hebben met een gemeenschappelijke anode (OA), dan moeten we in het circuit een "plus" aan deze pin hangen, en als we een gemeenschappelijke kathode (OC) hebben, dan een "min" of aarde . Op welke pin we spanning zetten, zal deze LED oplichten. Laten we dit allemaal in de praktijk demonstreren.

In praktische multiplexers is de piekweergavestroom vrij hoog om voldoende helderheid van het scherm te garanderen. In afb. Figuur 15 toont een voorbeeld van een verbeterde multiplexmethode toegepast op een driecijferige frequentieteller. Deze methode heeft twee belangrijke voordelen.

Als deze terminals hoog actief zijn, hebben ze de volgende kenmerken. Afb. 18 en 19. Figuur 18 toont de rimpelonderdrukkingstechniek die wordt gebruikt om voorloopnulonderdrukking te bieden op een viercijferig display dat de hoeveelheid weergeeft.

Wij hebben de volgende LED knipperlichten op voorraad:

Zoals we zien, kunnen apparaten met zeven segmenten single- en multi-bit zijn, dat wil zeggen twee, drie, vier apparaten met zeven segmenten in één geval. Om een ​​modern apparaat met zeven segmenten te controleren, hebben we alleen een multimeter met diodetestfunctie nodig. We zoeken willekeurig naar een algemene conclusie (het kan OA of OK zijn) en vervolgens kijken we naar de prestaties van alle segmenten van de indicator. We controleren het drie-bit zeven-segment:

Het display toont dus. Kortom, ze zijn gemakkelijk te gebruiken, zetten ze aan en ze lichten op. Ze kunnen vervelend zijn omdat ze een bepaalde polariteit hebben, wat betekent dat ze alleen werken als je ze correct aansluit. Als je de positieve en negatieve spanning annuleert, lichten ze helemaal niet op.

Hoe vervelend het ook is, het is ook best nuttig. De andere draad is de kathode. De kathode is verbonden met aarde. In principe zal het daar op neerkomen. Voor een gemeenschappelijke kathode past u stroom toe op de pinnen die u wilt inschakelen. Multiplexen. Er zijn zelfs displaycontrollers hiervoor als je je geen zorgen wilt maken over het overschakelen van je software.

Oeps, één segment vloog in brand, dus we controleren de andere segmenten op dezelfde manier.

Soms is de spanning op de cartoon niet voldoende om de indicatorsegmenten te controleren. Daarom nemen we de voeding, stellen deze in op 5 volt, sluiten een weerstand van 1-2 kiloOhm aan op een aansluiting van de voeding en beginnen met het controleren van de zevensegmenteneenheid.

7-segment displaybediening

Dus als je een 4-cijferige, gemultiplexte 7-segments gemeenschappelijke anode hebt. Ten eerste moeten we weten welk type beeldscherm we hebben, aangezien er twee mogelijke vormen zijn: gemeenschappelijke kathode en gemeenschappelijke anode. Dingen die je nodig hebt voor deze tutorial. Links: een grafische weergave van een 7-segmentdisplay met een algemene lay-out voor interne bedrading en pinlocaties.

Let op dit punt op de initiële uitvoer, aangezien u deze later nodig zult hebben bij het laden van het programma. Als het beeldscherm een ​​gewone kathode zou zijn, zouden we het annuleren. Onderaan het artikel staat een foto van de circuits die op mijn prototypebord zitten. We bieden ook een bibliotheek waarmee u meer dan één display kunt bedienen.

Waarom hebben we een weerstand nodig? Wanneer er spanning op de LED wordt gezet, begint deze bij het inschakelen sterk stroom te verbruiken. Daarom kan het op dit moment doorbranden. Om de stroom te beperken wordt een weerstand in serie geschakeld met de LED. U kunt meer lezen in dit artikel.

Hex-telling op één display met 7 segmenten

Het nadeel is dat ze hulpbronnenintensief zijn. Dit specifieke display heeft vier cijfers en twee dubbele punten. Het apparaat biedt echter ook digitale controle over de helderheid van het scherm via een interne breedbandmodulator. In dergelijke gevallen kan de uitvoer op meerdere 7-segmentdisplays worden uitgevoerd.

Dit bespaart contacten op de behuizing en vervolgens op de besturing. Dienovereenkomstig wordt verwezen naar gemeenschappelijke anode- of gemeenschappelijke kathodebeeldschermen. De uitvoer die overeenkomt met een segment of decimaalpunt kan voor weergave het beste uit het gegevensblad worden gehaald. Een display met 7 segmenten dat geschikt is voor de gebruikelijke 10-20 mA zal nog steeds oplichten, zij het zwak. Maar hiervoor zijn geen contacten nodig. De volgende verdeling van dit segment is gebaseerd op.

Op dezelfde manier controleren we het viercijferige zevensegment van een Chinese radio

Ik ben van mening dat hier geen bijzondere problemen mee gepaard moeten gaan. In de circuits zijn circuits met zeven segmenten verbonden met weerstanden op elke pin. Dit komt ook door het feit dat LED's, wanneer er spanning op wordt toegepast, verwoed stroom verbruiken en doorbranden.

Indien een ander doel wordt gebruikt, is dit in principe mogelijk, maar moet er bij het programmeren rekening mee worden gehouden. Het omzetten van individuele cijfers in een specifiek uitvoerpatroon kan worden gedaan met behulp van iets dat wordt genoemd. Alle andere segmenten moeten donker zijn. Als dit selectievakje voor alle cijfers is aangevinkt, wordt de volgende tabel weergegeven.

Het testprogramma geeft de cijfers 0 tot en met 9 achtereenvolgens weer op een display met 7 segmenten. Het uitgangsnummer wordt opgeslagen in een registerteller en binnen de cyclus met 1 verhoogd. Als het register een waarde van 10 bereikt, wordt het weer op 0 gezet. Eenmaal verhoogd, ontstaat er een wachtlus die ervoor zorgt dat er bij de volgende vrijgave een bepaalde tijd is verstreken. Normaal gesproken zou je niet zulke lange wachtcycli doen, maar dit gaat niet over wachten, het gaat over het bedienen van een 7-segments display. Hiervoor een timer gebruiken is te veel moeite.

In onze moderne wereld worden apparaten met zeven segmenten al vervangen door LCD-indicatoren die totaal verschillende informatie kunnen weergeven

maar om ze te gebruiken heb je bepaalde vaardigheden nodig in het circuitontwerp van dergelijke apparaten. Tot nu toe is er niets eenvoudiger of goedkoper dan LED-indicatoren met zeven segmenten.

Het eigenlijke probleem, en dus het interessante deel van dit artikel, doet zich echter direct na de labellus voor. Houd er rekening mee dat de tellerwaarde verdubbeld moet worden. Dit houdt rechtstreeks verband met het feit dat flashgeheugen woordgewijs en niet bytegewijs is. Het tweede voorbeeld op deze pagina doet het anders. Het laat zien hoe, via een andere tabelinvoer, het genereren van opvulbytes door de assembler kan worden voorkomen. Het is ook interessant dat de berekening een register vereist dat de waarde 0 bevat.

Daarom moet deze constante eerst in een register worden geladen en pas daarna kan de optelling met behulp van dit register worden uitgevoerd. Het interessante is dat dit feit in veel programma's wordt aangetroffen, en dat constanten in de overgrote meerderheid van de gevallen de constante 0 zijn. Daarom reserveren veel programmeurs hiervoor vanaf het allereerste begin een register en noemen dit het nulregister.

In dit artikel zullen we het hebben over digitale weergave.
LED-indicatoren met zeven segmenten zijn ontworpen om Arabische cijfers van 0 tot 9 weer te geven (Fig. 1).

Dergelijke indicatoren bestaan ​​uit één cijfer en geven slechts één getal weer, maar er kunnen meer groepen van zeven segmenten zijn gecombineerd in één behuizing (meercijferig). In dit geval worden de cijfers gescheiden door een decimaalpunt (Fig. 2)

Helaas is er een probleem omdat het beeldscherm acht poorten nodig heeft; voor vier advertenties zouden er 32 poorten nodig zijn. Maar er zijn verschillende manieren. Schuifregisters worden al beschreven in een andere tutorial. Dit zou het gemakkelijker maken om de vereiste 32 uitgangslijnen te creëren met slechts drie pinnen. Het besturingsprincipe verschilt niet van het aansturen van een enkel 7-segment display, alleen de manier waarop de "output pins" hun waarden benaderen is anders en wordt bepaald door het gebruik van schuifregisters. Op dit punt zou echter een andere besturingsoptie moeten worden getoond.

Afb.2.

De indicator wordt zevensegmenten genoemd vanwege het feit dat het weergegeven symbool is opgebouwd uit zeven afzonderlijke segmenten. In de behuizing van een dergelijke indicator bevinden zich LED's, die elk hun eigen segment verlichten.
Het is problematisch om letters en andere symbolen op dergelijke indicatoren weer te geven, daarom worden voor deze doeleinden indicatoren met 16 segmenten gebruikt.

We zullen hieronder opnieuw naar multiplex kijken. Multiplexing betekent dat niet alle vier de beeldschermen tegelijkertijd worden ingeschakeld, maar slechts één voor een korte tijd. Als de wisseling tussen de schermen sneller plaatsvindt dan wij mensen kunnen waarnemen, lijken alle vier de lampjes tegelijkertijd te werken, ook al brandt er maar één korte tijd. Op deze manier kunnen vier displays individuele segmentsegmenten delen, en het enige dat nodig is zijn vier extra bedieningslijnen voor de vier displays waarmee het display is uitgerust.

Eén aspect van dit type besturing is de frequentie van multiplexen, dat wil zeggen de volledige cyclus van overgang van het ene beeldscherm naar het andere. Deze moet hoog genoeg zijn om flikkering van het display te voorkomen. Het menselijk oog is traag, in een bioscoop 24 frames per seconde, waarbij de tv voor de zekerheid ook stilstaande beelden rustig zijn, elk segment moet op minimaal 100 Hz worden aangestuurd, dus er wordt minimaal elke 10 ms verbinding gemaakt. In uitzonderlijke gevallen kan zelfs 100 Hz echter nog flikkeren, bijvoorbeeld wanneer het display snel beweegt of wanneer er interferentie optreedt met kunstmatige lichtbronnen die op wisselstroom werken.

LED-indicatoren zijn er in twee soorten.
In de eerste daarvan zijn alle kathodes, d.w.z. de negatieve aansluitingen van alle LED's worden gecombineerd en er wordt een overeenkomstige aansluiting voor toegewezen op de behuizing.
De overige aansluitingen van de indicator zijn verbonden met de anode van elke LED (Fig. 3, a). Dit circuit wordt een "gemeenschappelijk kathodecircuit" genoemd.
Er zijn ook indicatoren waarbij de LED's van elk segment zijn verbonden volgens een circuit met een gemeenschappelijke anode (Fig. 3, b).

Afb.3.

Elk segment wordt aangeduid met een overeenkomstige letter. Figuur 4 toont hun locatie.

Afb.4.

Beschouw als voorbeeld een tweecijferige zevensegmentindicator GND-5622As-21 rood. Er zijn trouwens andere kleuren, afhankelijk van het model.
Met een batterij van drie volt kun je segmenten inschakelen, en als je een groep pinnen tot een bos combineert en er stroom op zet, kun je zelfs cijfers weergeven. Maar deze methode is lastig, dus worden schuifregisters en decoders gebruikt om indicatoren met zeven segmenten te besturen. Ook zijn de indicatorpinnen vaak rechtstreeks verbonden met de uitgangen van de microcontroller, maar alleen als indicatoren met een laag stroomverbruik worden gebruikt. Figuur 5 toont een fragment van een circuit dat PIC16F876A gebruikt.

Afb.5.

Voor het aansturen van de zeven-segment indicator wordt vaak de K176ID2 decoder gebruikt.
Deze chip kan binaire code bestaande uit nullen en enen omzetten in decimale cijfers van 0 tot en met 9.

Om te begrijpen hoe het allemaal werkt, moet je een eenvoudig circuit samenstellen (Fig. 6). De K176ID2-decoder is ondergebracht in een DIP16-behuizing. Het heeft 7 uitgangspinnen (pinnen 9 - 15), elk gewijd aan een specifiek segment. Puntcontrole is hier niet beschikbaar. De microschakeling heeft tevens 4 ingangen (pinnen 2 - 5) voor het leveren van binaire code. De 16e en 8e pin worden respectievelijk voorzien van plus- en minstroom. De overige drie conclusies zijn aanvullend, ik zal er later over praten.

Afb.6.

DD1 - K176ID2
R1 - R4 (10 - 100 kOhm)
HG1 - GND-5622As-21

Er zitten 4 tuimelschakelaars in het circuit (elke knop is mogelijk), als je erop drukt, wordt er een logische tuimelschakelaar geleverd aan de decoderingangen van de voeding plus. Overigens wordt de microschakeling zelf gevoed met een spanning van 3 tot 15 volt. In dit voorbeeld wordt de gehele schakeling gevoed door een 9 volt voeding.

Er zijn ook 4 weerstanden in het circuit. Dit zijn zogenaamde pull-up-weerstanden. Ze zijn nodig om ervoor te zorgen dat de logische ingang laag is als er geen signaal is. Zonder deze worden de meetwaarden op de indicator mogelijk niet correct weergegeven. Het wordt aanbevolen om hetzelfde te gebruikenweerstand van 10 kOhm tot 100 kOhm.

In het diagram zijn pinnen 2 en 7 van de HG1-indicator niet aangesloten. Als u de DP-pin op de negatieve voeding aansluit, licht de komma op. En als u een minteken op de Dig.2-uitgang toepast, licht ook de tweede groep segmenten op (toont hetzelfde symbool).

De decoderingangen zijn zo ontworpen dat u slechts één knop hoeft in te drukken om de cijfers 1, 2, 4 en 8 op de indicator weer te geven (tuimelschakelaars die overeenkomen met de ingangen D0, D1, D2 en D3 zijn op de modelbaan geïnstalleerd ). Als er geen signaal is, wordt het getal nul weergegeven. Wanneer een signaal wordt aangeboden aan ingang D0, wordt het getal 1 weergegeven, enzovoort. Om andere nummers weer te geven, moet u op een combinatie van tuimelschakelaars drukken. Tabel 1 laat ons zien welke we moeten indrukken.

Tabel 1.

Om het getal "3" weer te geven, moet u een logisch cijfer toepassen op de ingangen D0 en D1. Als u een signaal toepast op D0 en D2, wordt het getal “5” weergegeven(Afb. 6).

Afb.6.

Hier is een uitgebreide tabel waarin we niet alleen het verwachte cijfer zien, maar ook de segmenten (a - g) waaruit dit cijfer zal bestaan.

Tabel 2.

De 1e, 6e en 7e pin van de microschakeling zijn hulp (respectievelijk S, M, K).

In het diagram (Fig. 6) is de 6e pin "M" geaard (naar de min van de voeding) en is er een positieve spanning aan de uitgang van de microschakeling voor het werken met een indicator met een gemeenschappelijke kathode. Als er een indicator met een gemeenschappelijke anode wordt gebruikt, moet deze op de 6e pin worden aangebracht.

Als een logische wordt toegepast op de 7e pin “K”, dan gaat het indicatieteken uit, nul maakt de indicatie mogelijk. In het circuit is deze pin geaard (naar de min van de voeding).

Aan de eerste uitgang van de decoder wordt een logische eenheid (plus voeding) geleverd, waardoor de geconverteerde code op de indicator kan worden weergegeven. Maar als u een logische nul op deze pin (S) toepast, ontvangen de ingangen geen signaal meer en blijft het momenteel weergegeven teken op de indicator vastlopen.

Een interessant ding om op te merken is dat we weten dat tuimelschakelaar D0 het getal "1" inschakelt, en tuimelschakelaar D1 het getal "2" inschakelt. Als u beide tuimelschakelaars indrukt, wordt het getal 3 weergegeven (1+2=3). En in andere gevallen geeft de indicator de som weer van de getallen waaruit deze combinatie bestaat. We komen tot de conclusie dat de decoderingangen doordacht zijn gerangschikt en zeer logische combinaties hebben.

Je kunt ook de video bij dit artikel bekijken.

Aansluitschema voor een ééncijferige zevensegmentindicator
Aansluitschema voor een meercijferige zevensegmentindicator

Digitaal informatieweergaveapparaat. Dit is de eenvoudigste implementatie van een indicator die Arabische cijfers kan weergeven. Complexere multi-segment- en matrixindicatoren worden gebruikt om letters weer te geven.

Zoals de naam al zegt, bestaat het uit zeven display-elementen (segmenten) die afzonderlijk aan en uit gaan. Door ze in verschillende combinaties op te nemen, kunnen ze worden gebruikt om vereenvoudigde afbeeldingen van Arabische cijfers te maken.
De segmenten worden aangeduid met de letters A tot en met G; achtste segment - decimaalpunt (decimale punt, DP), ontworpen om fractionele getallen weer te geven.
Af en toe worden letters weergegeven op de uit zeven segmenten bestaande indicator.

Ze zijn verkrijgbaar in verschillende kleuren, meestal wit, rood, groen, geel en blauw. Bovendien kunnen ze verschillende afmetingen hebben.

Ook kan de LED-indicator uit één cijfer bestaan ​​(zoals in de afbeelding hierboven) of uit meerdere cijfers bestaan. In principe worden in de praktijk één-, twee-, drie- en viercijferige LED-indicatoren gebruikt:

Naast tien cijfers kunnen indicatoren met zeven segmenten ook letters weergeven. Maar weinig letters hebben een intuïtieve weergave van zeven segmenten.
In het Latijn: hoofdletter A, B, C, E, F, G, H, I, J, L, N, O, P, S, U, Y, Z, kleine letters a, b, c, d, e, g , h, ik, n, o, q, r, t, u.
In Cyrillisch: A, B, V, G, g, E, i, N, O, o, P, p, R, S, s, U, Ch, Y (twee cijfers), b, E/Z.
Daarom worden indicatoren met zeven segmenten alleen gebruikt om eenvoudige berichten weer te geven.

In totaal kan de uit zeven segmenten bestaande LED-indicator 128 tekens weergeven:

Een typische LED-indicator heeft negen aansluitingen: één gaat naar de kathodes van alle segmenten en de andere acht gaan naar de anode van elk segment. Dit schema heet "gemeenschappelijk kathodecircuit", er zijn ook regelingen met gemeenschappelijke anode(dan is het andersom). Vaak worden er niet één, maar twee gemeenschappelijke aansluitingen gemaakt aan verschillende uiteinden van de basis - dit vereenvoudigt de bedrading zonder de afmetingen te vergroten. Er zijn ook zogenaamde 'universele', maar die ben ik persoonlijk niet tegengekomen. Daarnaast zijn er indicatoren met een ingebouwd schuifregister, waardoor het aantal betrokken microcontrollerpoortpinnen aanzienlijk wordt verminderd, maar deze zijn veel duurder en worden in de praktijk zelden gebruikt. En omdat de onmetelijkheid niet te vatten is, zullen we dergelijke indicatoren voorlopig niet in overweging nemen (maar er zijn ook indicatoren met een veel groter aantal segmenten, matrix-segmenten).

Meercijferige LED-indicatoren werken vaak volgens een dynamisch principe: de uitgangen van de segmenten met dezelfde naam van alle cijfers zijn met elkaar verbonden. Om informatie over een dergelijke indicator weer te geven, moet de besturingsmicroschakeling cyclisch stroom leveren aan de gemeenschappelijke aansluitingen van alle cijfers, terwijl stroom wordt geleverd aan de segmentaansluitingen, afhankelijk van of een bepaald segment oplicht in een bepaald cijfer.

Een ééncijferige indicator met zeven segmenten aansluiten op een microcontroller

Het onderstaande diagram laat zien hoe er is een uit één cijfer bestaande indicator met zeven segmenten aangesloten naar de microcontroller.
Er moet rekening mee worden gehouden dat als de indicator met GEMEENSCHAPPELIJKE KATHODE, waarna de gemeenschappelijke uitgang ervan wordt verbonden "aarde", en de segmenten worden ontstoken door te voeren logische eenheid naar de poortuitgang.
Als de indicator dat is GEMEENSCHAPPELIJKE ANODE, vervolgens wordt het aan de gemeenschappelijke draad geleverd "plus" spanning, en de segmenten worden ontstoken door de poortuitgang naar de status te schakelen logisch nul.

Indicatie in een LED-indicator met één cijfer wordt uitgevoerd door een binaire code toe te passen op de pinnen van de microcontrollerpoort van het overeenkomstige cijfer van het overeenkomstige logische niveau (voor indicatoren met OK - logische, voor indicatoren met OA - logische nullen).

Stroombegrenzende weerstanden kan wel of niet aanwezig zijn in het diagram. Het hangt allemaal af van de voedingsspanning die aan de indicator wordt geleverd en de technische kenmerken van de indicatoren. Als de aan de segmenten geleverde spanning bijvoorbeeld 5 volt is en ze zijn ontworpen voor een bedrijfsspanning van 2 volt, dan moeten stroombegrenzende weerstanden worden geïnstalleerd (om de stroom er doorheen te beperken voor een verhoogde voedingsspanning en niet te verbranden niet alleen de indicator, maar ook de microcontrollerpoort).
Het is heel eenvoudig om de waarde van stroombegrenzende weerstanden te berekenen met behulp van de formule van grootvader Ohm.
De kenmerken van de indicator zijn bijvoorbeeld als volgt (overgenomen uit het gegevensblad):
— bedrijfsspanning — 2 volt
— bedrijfsstroom — 10 mA (=0,01 A)
— voedingsspanning 5 volt
Formule voor berekening:
R= U/I (alle waarden in deze formule moeten in Ohm, Volt en Ampère zijn)
R= (voedingsspanning - bedrijfsspanning)/bedrijfsstroom
R= (5-2)/0,01 = 300 Ohm

Aansluitschema voor een meercijferige LED-indicator met zeven segmenten In principe hetzelfde als bij het aansluiten van een eencijferige indicator. Het enige is dat er stuurtransistors worden toegevoegd in de kathodes (anodes) van de indicatoren:

Het is niet in het diagram weergegeven, maar tussen de bases van de transistors en de pinnen van de microcontrollerpoort moeten weerstanden worden opgenomen, waarvan de weerstand afhangt van het type transistor (de weerstandswaarden worden berekend, maar je kunt ook proberen weerstanden te gebruiken met een nominale waarde van 5-10 kOhm).

Indicatie door lozingen gebeurt dynamisch:
— de binaire code van het overeenkomstige cijfer wordt ingesteld op de uitgangen van de PB-poort voor het eerste cijfer, waarna het logische niveau wordt toegepast op de stuurtransistor van het eerste cijfer
— de binaire code van het overeenkomstige cijfer wordt ingesteld op de uitgangen van de PB-poort voor het tweede cijfer, waarna het logische niveau wordt toegepast op de stuurtransistor van het tweede cijfer
— de binaire code van het overeenkomstige cijfer wordt ingesteld op de uitgangen van de PB-poort voor het derde cijfer, waarna het logische niveau wordt toegepast op de stuurtransistor van het derde cijfer
- dus in een cirkel
In dit geval is het noodzakelijk om rekening te houden met:
— voor indicatoren met OK Er wordt gebruik gemaakt van een regeltransistorstructuur NPN(bestuurd door logische eenheid)
- voor indicator met OA- structuurtransistor PNP(bestuurd door logische nul)

Op verzoek van de arbeiders besloot ik te praten over iets prachtigs, een LED-indicator met 7 segmenten. Allereerst: wat is het? Hier is het probleem. Dit is één cijfer, er zijn ook twee cijfers, drie en vier cijfers. Ik zag nog zes cijfers. Na elk cijfer staat een decimaalteken. Als er vier cijfers zijn, kunt u na het tweede cijfer meestal een dubbele punt vinden om seconden aan te geven bij het weergeven van de tijd. Nadat we de klieren hebben behandeld, gaan we verder met het bestuderen van het circuit. Wat is dynamische weergave eigenlijk en waarom is het nodig? Omdat de indicator uit 7 segmenten bestaat, worden er slechts 7 segmenten gebruikt om het nummer weer te geven. Ze worden altijd in Latijnse letters aangeduid A, B, C, D, E, F, G en DP Laten we naar de foto kijken. Onder elk segment bevindt zich een LED. Alle LED's zijn aan één uiteinde aangesloten. Ofwel anodes of kathodes, en de tegenovergestelde uiteinden worden naar buiten gebracht. Het is gemakkelijk op te merken dat u 8 pinnen nodig heeft om een ​​nummer weer te geven. Eén algemeen en zeven voor segmenten. Gaat het om één categorie, dan is er niets aan de hand, we hangen alles gewoon aan één poort. Wat als er vier cijfers zijn? Acht vermenigvuldigd met vier is tweeëndertig. Oh... Ja, zo'n 32 mega-indicator zal er eentje zijn om over na te denken. Zo zal het niet werken. Er zijn twee oplossingen. De onze is een dynamische weergave of statisch. Laten we, om het beter te begrijpen, eens kijken naar het diagram voor het inschakelen van de indicator.

Dit schema impliceert dynamische indicatie. Ja, ik ben helemaal dynamisch en statisch. Wat is het verschil? Statische indicatie is wanneer we elk cijfer een eigen nummer geven en het is constant aan, en dynamische indicatie is wanneer we het nummer in het eerste cijfer weergeven, het vervolgens uitdoven en weergeven in het tweede cijfer, het vervolgens uitdoven en weergeven in het tweede cijfer. derde cijfer, enzovoort totdat de ontladingen niet eindigen. Na de laatste categorie gaan we weer naar de eerste en zo verder in een cirkel. Als je dit langzaam doet, kun je een digitale ticker zien, maar als je de snelheid verhoogt naar bijvoorbeeld 50 Hz, zien je ogen geen flikkering meer. Dit is hoe dynamische weergave werkt. Laten we nu naar het diagram kijken. Links staat de ATmega8 MK, daarachter op poort D zit een 74ALS373-chip. Waarom is het nodig? Feit is dat de indicator eenvoudigweg uit 8 LED's bestaat, samengevoegd in een soort matrix. Dat wil zeggen, de indicator kan worden weergegeven als een lijn van 8 LED's. En zoals je weet, eten LED's veel in vergelijking met MK. Direct aansluiten is uiteraard niet verboden, maar het is beter om een ​​soort repeater tussen de MK en de indicator te plaatsen. Voor deze doeleinden heb ik besloten een 8-bits grendelbuffer te gebruiken. Waarom hij? Rekening houdend met het feit dat ik de indicator met een gemeenschappelijke anode gebruik, dat wil zeggen dat voor de taak van het cijfer het actieve niveau 0 is, dan zou ik veilig de ULN2003A-microschakeling kunnen gebruiken (7 transistorassemblages volgens het Darlington-circuit) en niet moeite met de buffer, maar... Maar het feit is dat ULN2003A alleen NPN-transistors aan boord heeft en ik de indicator alleen kan gebruiken met een gemeenschappelijke anode, maar wat als ik hem met een gemeenschappelijke kathode moet gebruiken? Dit is waar de buffer zal helpen, aangezien wat ik daar schrijf op de uitvoer zal staan. Als je 0 wilt, wil je 1. De bedieningspoten zijn verbonden in de vertaalmodus. Dat wil zeggen, de buffer voert hetzelfde uit als de invoer. Aya pseudo-galvanische isolatie. De buffer wordt gevolgd door stroombegrenzende weerstanden. Houd er rekening mee dat dit LED's zijn en dat ze zonder weerstanden doorbranden. De weerstandswaarde moet iets lager dan acceptabel worden gekozen. Feit is dat het dynamische display tekens met een bepaalde frequentie weergeeft en vergelijkbaar is met PWM, dat wil zeggen: hoe hoger de frequentie, hoe hoger het contrast, om zo te zeggen. En met het meest comfortabele contrast zullen de cijfers een beetje zwakker schijnen. Daarom moeten weerstanden met een iets lagere nominale waarde worden genomen. Ik gebruikte alleen 360 Ohm omdat ik er een paar op voorraad had. Het volgende na de weerstanden is onze indicator. Aan de andere kant, waar de anodes zitten, heb ik de eerste vier cijfers van poort C aangesloten. Dus we hebben het circuit min of meer ontdekt. Laten we nu het programma-algoritme bespreken. Om de indicatorcijfers één voor één in te schakelen, zullen we een aparte functie schrijven en deze eindeloos aanroepen in de hoofdtekst van het programma. Meer specifiek zal de functie een getal van 0 tot 9999 ontvangen, dit in cijfers ontleden en vervolgens elk cijfer op zijn plaats uitvoeren. Als het getal minder dan 4 cijfers bevat, worden de lege velden aan de linkerkant gevuld met nullen. Wij stemmen ons af op de rechterrand. We doorlopen de categorieën van links naar rechts. Om eventuele acties zichtbaar te maken, gebruiken we interrupts van de teller om het uitvoernummer één keer per seconde te verhogen. Dus de taak is vastgesteld, klaar voor de strijd. #define F_CPU 7372800UL // Kwartsfrequentie #erbij betrekken #erbij betrekken #erbij betrekken vluchtige niet-ondertekende int-test = 9980; // Variabele die op de indicator moet worden weergegeven ISR(TIMER1_COMPA_vect) // Onderbreekhandler voor timer 1-wedstrijd (test++; // Verhoog het uitvoernummer als(test > 9999) test = 0; // Als het meer dan vier cijfers bedraagt, stelt u het opnieuw in op nul TCNT1H=0x00; //Reset register TCNT1L=0x00; // rekeningen ) void dig_out(int num); // Verklaring van de functie die op de indicator moet worden weergegeven int hoofd(void) ( DDRC = 0x0F; // Poorten configureren DDRD = 0xFF; // voor het werken met de indicator Poort C voor cijfers, Poort D voor cijfers TCCR1A=0x00; // De timer instellen TCCR1B=0x04; TCNT1H=0x00; TCNT1L=0x00; OCR1AH=0x70; OCR1AL=0x80; TIMSK=0x10; sei(); // Schakel interrupts in while(1) ( dig_out(test); // Roep de functie voortdurend aan om het huidige nummer weer te geven ) ) void dig_out(int num) // Functie voor het weergeven van 4 cijfers op de indicator (niet-ondertekende char i = 0; // Tellervariabele niet-ondertekende char raz = 1; // Cijfernummer niet-ondertekende char dig_num = (0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x78, 0x00, 0x10); // Nummercodes voor een indicator met een gemeenschappelijke anode niet-ondertekende char dig_num = (0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x78, 0x00, 0x10); niet-ondertekende char dig = (0, 0, 0, 0); // Array voor cijferwaarde als(num ( dig =0; dig =0; dig =0; ) if(getal // Om de linkerbits met nullen te vullen ( dig =0; dig =0; ) if(getal ( dig =0; ) terwijl(num > 999) // Haal het aantal duizenden op ( dig++; num -= 1000; ) while(num > 99) // Haal het aantal honderden op ( dig++; num -= 100; ) while(num > 9) // Haal het tientallennummer op ( dig++; num -= 10; ) dig = num; // Haal het aantal eenheden op terwijl (raz // Draai totdat we alle 4 de bits hebben gevuld (POORTC = raz; // Selecteer een rang POORTD = dig_num]; } } // Voer het nummer uit

raz = raz // Ga naar het volgende cijfer

ik++;

//Verhoog de index van het volgende cijfer

_delay_ms(1);

// Vertraging 1 ms

Dat is alle code. Ik zal het niet beschrijven omdat het commentaar bevat voor elke regel. Hieronder kunt u het archief downloaden met het project voor AtmelStudio6.2. Als u nog vragen heeft, bent u welkom op het forum. Nou, voor de meest kieskeurige, hieronder is een video van al deze balalaika))).

Laten we een LED-indicator met zeven segmenten aansluiten op het Arduino-bord en leren hoe we deze kunnen besturen met behulp van de Led4Digits.h-bibliotheek.

• In de vorige les zijn microcontrollers in detail beschreven. Laten we zo'n indicator op het Arduino-bord aansluiten.
• Het diagram voor het aansluiten van de indicator op het Arduino-bord ziet er als volgt uit.
• Ik heb het op een printplaat gemonteerd.
• Om indicatoren te beheren, heb ik de Led4Digits.h-bibliotheek geschreven:
  • En betaal.
  • Met de bibliotheek kunt u indicatoren met zeven segmenten beheren:
  • maximaal vier cijfers groot;
• met alle varianten van stuurpulspolariteiten (alle);
• werkt in een parallel proces;

Hiermee kunt u op de indicator weergeven:

segmenten van elke categorie; het cijfer van elk cijfer;

geheel getal 0 ... 9999;

Ik zal de bronteksten niet verstrekken. Je kunt ze opzoeken in de bibliotheekbestanden. Zoals altijd zijn er veel reacties. Ik zal gedetailleerd beschrijven, met voorbeelden, hoe u de bibliotheek kunt gebruiken.

LED-besturingsbibliotheek voor Arduino Led4Digits.

Hier is de klassebeschrijving. Ik heb alleen openbare methoden en eigenschappen opgegeven.

klasse Led4Digits (
publiek:
bytecijfer; // bitsegmentbesturingscodes
ongeldig regen(); // regeneratie, de methode moet regelmatig worden aangeroepen
void tetradToSegCod(byte dig, byte tetrad); // tetrad naar segmentcodes converteren
boolean print(niet-ondertekende int-waarde, byte digitNum, byte leeg); // gehele uitvoer



} ;

Constructeur.

Led4Digits (bytetypeLed, byte cijferPin0, byte cijferPin1, byte cijferPin2, byte cijferPin3,
byte segPinA, byte segPinB, byte segPinC, byte segPinD,
byte segPinE, byte segPinF, byte segPinG, byte segPinH);

typeLed Stelt de stuurpulspolariteiten in voor bit- en segmentselectiesignalen. Ondersteunt alle verbindingsschema's ().

cijferPin0...cijferPin3– uitgangen voor het selecteren van cijfers. Als digitPin = 255, is het cijfer uitgeschakeld. Hierdoor kunt u indicatoren met minder cijfers verbinden. digitPin0 – laag (rechter) cijfer.

segPinA...segPinH– segmentbesturingsuitgangen.

Bijvoorbeeld,

betekent: indicatortype 1; afvoeruitgangen 5,4,3,2; uitgangen van segmenten 6,7,8,9,10,11,12,13.

void regen() methode

De methode moet regelmatig in een parallel proces worden aangeroepen. Het regenereert het beeld op de indicatoren. De regeneratiecyclustijd is gelijk aan de methodeaanroepperiode vermenigvuldigd met het aantal bits.

Bijvoorbeeld,

// interrupt-handler 2 ms
void timerInterrupt() (
disp.regen(); // indicator regeneratie
}

Bytecijferarray

Bevat de status van de segmenten. cijfer is het minst significante bit, het minst significante bit van een cijfer is het “A”-segment van het minst significante bit. Een bitstatus van 1 betekent dat het segment verlicht is.

Bijvoorbeeld,

cijfer = B0000101;

betekent dat in het tweede cijfer de segmenten “A” en “C” oplichten.

Een voorbeeld van een programma dat achtereenvolgens alle segmenten van elk cijfer verlicht.

// lopende segmenten
#erbij betrekken
#erbij betrekken

//
Led4Digits disp(1, 5,4,3,2, 6,7,8,9,10,11,12,13);

ongeldige setup() (
timeronderbreking 2 ms
MsTimer2::start(); // onderbreking inschakelen
}

lege lus() (
voor (int i = 0; ik< 32; i++) {
als (i == 0) disp.cijfer= 1;
anders als (i == 8) disp.digit= 1;
anders als (i == 16) disp.digit= 1;
anders als (i == 24) disp.digit= 1;
anders(
disp.cijfer = disp.cijfer<< 1;
disp.cijfer = disp.cijfer<< 1;
disp.cijfer = disp.cijfer<< 1;
disp.cijfer = disp.cijfer<< 1;
}
vertraging(250);
}
}

//interrupt-handler 2 ms
void timerInterrupt() (
disp.regen(); // indicator regeneratie
}

In de cijferreeks is 1 verschoven en de indicatoren geven dit aan.

Methode ongeldig tetradToSegCod(byte dig, byte tetrad)

Met deze methode kunt u cijfers en letters van een hexadecimale code in afzonderlijke cijfers weergeven. Heeft argumenten:

• dig – cijfernummer 0 ... 3;
• tetrad – decimale tekencode. Code 0 geeft het cijfer “0” weer, code 1 - het cijfer "1", code 14 - de letter "E".

Bijvoorbeeld,

tetrad(2, 7);

zal het nummer “7” in het derde cijfer weergeven.

Een voorbeeld van een programma dat om beurten de tekens in elk cijfer verandert.

// nummers één voor één
#erbij betrekken
#erbij betrekken

// indicatortype 1; afvoeruitgangen 5,4,3,2; segmentuitgangen 6,7,8,9,10,11,12,13
Led4Digits disp(1, 5,4,3,2, 6,7,8,9,10,11,12,13);

ongeldige setup() (
MsTimer2::set(2, timerInterrupt); // timeronderbreking 2 ms
MsTimer2::start(); // onderbreking inschakelen
}

lege lus() (
voor (int i = 0; ik< 64; i++) {
disp.tetradToSegCod(i>>4, i);
vertraging(250);
}
}

// interrupt-handler 2 ms
void timerInterrupt() (
disp.regen(); // indicator regeneratie
}

Methode boolean print(niet-ondertekende int-waarde, byte digitNum, byte leeg)

De methode geeft een geheel getal weer op de indicatoren. Het converteert het binaire getal voor elk cijfer naar BCD. Heeft argumenten:

• waarde – het getal dat op de indicator wordt weergegeven.
• digitNum – aantal cijfers voor een getal. Dit moet niet worden verward met het aantal indicatorcijfers. Mogelijk wilt u een getal op twee cijfers weergeven en op de andere twee tekens met cijfers.
• blanco – een teken van onderdrukking van onbeduidende cijfers. blanco=0 betekent dat het getal met allemaal nullen moet worden weergegeven. Het getal "7" ziet eruit als "0007". Als blanco verschillend is van 0, worden onbeduidende nullen onderdrukt.

Als de getalswaarde het toegestane getal voor het geselecteerde aantal cijfers (digitNum) overschrijdt, geeft de functie “---” weer op de indicator en retourneert false.

Een voorbeeld van een nummeruitvoerprogramma.

// uitgangsnummer
#erbij betrekken
#erbij betrekken

// indicatortype 1; afvoeruitgangen 5,4,3,2; segmentuitgangen 6,7,8,9,10,11,12,13
Led4Digits disp(1, 5,4,3,2, 6,7,8,9,10,11,12,13);

ongeldige setup() (
MsTimer2::set(2, timerInterrupt); // timeronderbreking 2 ms
MsTimer2::start(); // onderbreking inschakelen
}

lege lus() (
voor (int i = 0; ik< 12000; i++) {
weergave.print(i, 4, 1);
vertraging(50);
}
}

// interrupt-handler 2 ms
void timerInterrupt() (
disp.regen(); // indicator regeneratie
}

De laatste twee methoden veranderen niets aan de status van het “H”-segment – ​​de komma. Om de status van een punt te wijzigen, kunt u de volgende commando's gebruiken:

cijfer |= 0x80; // verlicht de komma
cijfer &= 0x7f; // doof de komma uit

Uitvoer naar indicatoren van negatieve getallen (int).

Negatieve getallen kunnen als volgt worden uitgevoerd:

• Controleer het teken van het nummer.
• Als het getal negatief is, druk dan een minteken af ​​bij het meest significante cijfer en verander het teken van het getal in positief in de print() functie.
• Als het getal positief is, schakel dan de tekenbit uit en druk het getal af met behulp van de print() functie.

Hier is een programma dat deze methode demonstreert. Het voert getallen uit van -999 tot 999.

// negatieve getallen uitvoeren
#erbij betrekken
#erbij betrekken

// indicatortype 1; afvoeruitgangen 5,4,3,2; segmentuitgangen 6,7,8,9,10,11,12,13
Led4Digits disp(1, 5,4,3,2, 6,7,8,9,10,11,12,13);

ongeldige setup() (
MsTimer2::set(2, timerInterrupt); // timeronderbreking 2 ms
MsTimer2::start(); // onderbreking inschakelen
}

lege lus() (

voor (int i = -999; i< 1000; i++) {

als (ik< 0) {
// het getal is negatief
weergave.cijfer= B01000000; // teken -
disp.print(i * -1, 3, 1);
}
anders(
weergave.cijfer= B00000000; // Wis het bord
weergave.print(i, 3, 1);
}

vertraging(50);
}
}

// interrupt-handler 2 ms
void timerInterrupt() (
disp.regen(); // indicator regeneratie
}

Uitvoer naar indicatoren van fractionele getallen, float-formaat.

Er zijn veel manieren om getallen met drijvende komma (floats) op indicatoren weer te geven met behulp van standaard C-taalfuncties. Dit is in de eerste plaats de functie sprint(). Het werkt erg langzaam, vereist extra conversies van tekencodes naar binaire decimale codes, je moet een punt uit een string halen. Dezelfde problemen met andere functies.

Ik gebruik een andere methode om de waarden van float-variabelen op indicatoren weer te geven. De methode is eenvoudig, betrouwbaar en snel. Reduceert tot de volgende bewerkingen:

• Het getal met drijvende komma wordt vermenigvuldigd met 10 tot de macht die overeenkomt met het vereiste aantal decimalen. Als u 1 decimaal op de indicatoren wilt weergeven, vermenigvuldig dan met 10, als het 2 is, vermenigvuldig dan met 100, 3 decimalen met 1000.
• Vervolgens wordt het drijvende-kommagetal expliciet geconverteerd naar een geheel getal (int) en weergegeven op de indicatoren met behulp van de print()-functie.
• Er wordt een punt in het gewenste cijfer geplaatst.

De volgende regels zullen bijvoorbeeld een float-variabele met twee decimalen uitvoeren naar de zeven-segment-LED's.

vlotter x = 2,12345;

weergavecijfer |= 0x80; //

We vermenigvuldigen het getal met 100 en door een punt in het derde cijfer te plaatsen, delen we het resultaat door 100.

Hier is een programma dat drijvende-kommagetallen van 0,00 tot 99,99 op de indicatoren weergeeft.

// drijvende-komma-uitvoer
#erbij betrekken
#erbij betrekken

// indicatortype 1; afvoeruitgangen 5,4,3,2; segmentuitgangen 6,7,8,9,10,11,12,13
Led4Digits disp(1, 5,4,3,2, 6,7,8,9,10,11,12,13);

ongeldige setup() (
MsTimer2::set(2, timerInterrupt); // timeronderbreking 2 ms
MsTimer2::start(); // onderbreking inschakelen
}

lege lus() (
zweven x = 0;

voor (int i = 0; ik< 10000; i++) {
x+= 0,01;

disp.print((int)(x * 100.), 4, 1);
weergavecijfer |= 0x80; // verlicht het derde niveaupunt

vertraging(50);
}
}

//interrupt-handler 2 ms
void timerInterrupt() (
disp.regen(); // indicator regeneratie
}

Zoals u kunt zien, vereenvoudigt de Led4Digits.h-bibliotheek het werken met zeven-segment light-emitting diode (LED)-indicatoren die zijn aangesloten op het Arduino-bord aanzienlijk. Ik heb geen analoog van een dergelijke bibliotheek gevonden.

Er zijn bibliotheken voor het werken met LED-displays via een schuifregister. Iemand schreef me dat ze een bibliotheek hadden gevonden die werkt met een LED-display dat rechtstreeks op het Arduino-bord is aangesloten. Maar bij gebruik gloeien de indicatorcijfers ongelijkmatig en knipperen ze.

In tegenstelling tot zijn analogen, doet de Led4Digits.h-bibliotheek het volgende:

• Wordt uitgevoerd als een parallel proces. In de hoofdlus laadt het programma gegevens in bepaalde variabelen, die automatisch op het display worden weergegeven. Informatie-uitvoer en indicatorregeneratie vinden plaats in een timer-interrupt, onzichtbaar voor het hoofdprogramma.
• De displaynummers lichten gelijkmatig op, zonder te knipperen. Deze eigenschap wordt verzekerd door het feit dat de regeneratie plaatsvindt in een cyclus die strikt wordt gedefinieerd door een timer-interrupt.
• De bibliotheek heeft compacte code, wordt snel uitgevoerd en belast de controller minimaal.

In de volgende les zullen we tegelijkertijd een LED-indicator en een knoppenmatrix op het Arduino-bord aansluiten. Laten we een bibliotheek schrijven voor zo'n ontwerp.