zondag 3 juni 2012

Displaytest met drukknop

Main
Macro: "schuiven"


In de calculation plaatsen we de data van de getallen die hexadecimaal ingevoerd zijn. Hierna komt de oneindige lus om het programma constant te laten lopen. Als volgt plaatsen we de macro van het keypad waar we keypad gaan inlezen. Dan vragen we ons af of het keypad gelijk is aan 255 (ingedrukt wordt of niet). Is dit niet zo dan is tel = 0 en blijft het programma gewoon verder lopen. Is dit wel zo dat er een cijfer op het keypad is ingeduwd dan gaan we naar de macro "schuiven" en tel = 1. In de macro wordt de data eerst ingeschreven en dan wordt er een loop 8 maal overlopen. Het 8 maal overlopen komt doordat we 7 segmenten hebben en een decimaal punt. De variable bitje is de data en moet dus een 1 krijgen. Deze variable wordt dan naar poort A0 gestuurd. In de calculation zeggen we dat variable seg7 een plaats naar rechts moet opschuiven. Dit wijst op het volgende segment. Als klok gebruiken we poort A1 die we eerst een "1" sturen en daarna een "0". Als dit 8 maal overlopen is dan komen we terug in het hoofdprogramma en beginnen we terug opnieuw.

Nieuw verbeterd schema

teller met schuifrigister

Main:                                                                  Schijven:


In de calculation plaatsen we de data van de getallen die hexadecimaal ingevoerd zijn. Hierna komt de oneindige lus om het programma constant te laten lopen. Bij de volgende calculation wordt de teller terug op 0 gezet. Dit gebeurt nadat de teller de volgende loop 10000 keer overlopen heeft. In deze loop staat er als eerste een calculation. Hierin selecteren we de duizendtallen door: D0 = (tel /1000) MOD 10. Dan komen we in de macro 'schuiven' terecht. Hier wordt de data eerst ingeschreven en dan wordt er een loop 8 maal overlopen. Het 8 maal overlopen komt doordat we 7 segmenten hebben en een decimaal punt. De variable bitje is de data en moet dus een 1 krijgen. Deze variable wordt dan naar poort A0 gestuurd. In de calculation zeggen we dat variable seg7 een plaats naar rechts moet opschuiven. Dit wijst op het volgende segment. Als klok gebruiken we poort A1 die we eerst een "1" sturen en daarna een "0". Als dit 8 maal overlopen is dan komen we terug in het hoofdprogramma waar we door gaan. Het volgende display is zijn de honderdtallen. Dit kunnen we selecteren door de calculation: D1 = (tel/100) MOD 10. Daarna komen we terug in de macro 'schuiven' die we terug 8 maal overlopen. Dit doen we ook nog is voor de tientallen, calculation: D2 = (tel/10) MOD 10 en voor de eenheden, calculation: D3 = tel MOD 10.
 Voorbeeld:
 Binaire code van 2 is:

a
b
c
d
e
f
g
dp
0
0
1
0
0
1
0
1

Als eerste moeten we  de laatste bit schrijven, het decimaal punt. Dit komt doordat we het altijd laten doorschuiven en als alles ingeschreven staat, staat de eerst bit op de laatste plaats.
 Tijdsdiagram:

















Grafische voorstelling doorschuiven van de segmenten:


Verbeteren eventuele fouten in displaymodule


Als er fouten zijn in de displaymodule gaan we kijken welk display het is en welke segmenten van de displays dat verbinding geeft met elkaar of verlies geeft. Hier voor gebruiken we figuur hierboven om te kijken welk segment welke pin heeft op het display. Als we dit weten kijken we hoe deze pinnen verbonden zijn met elkaar en als we dit gevonden hebben verwijderen we het geen dat verbinding geeft. Dit kan door soldeersel zijn of iets anders dat geleid.

Testen van de display modules


Voor het testen van de displaymodules gebruiken we terug een breadbordje. Nu plaatsen we de 2 LED-drivers erop en sluiten we hiervan de outputs aan op onze connector. Het aansturen van de LED-drivers blijven het zelfde als dat we gedaan hebben bij het testen van de LED-drivers. We sluiten ons displaymodule aan op de connector. De module wordt gevoed met 8V. We plaatsen de kabel die zorgt voor de  data op de +. Bij iedere klokpuls gaat er een segment oplichten en schuift er een op. Bij eventuele fouten zien we dat er soms 2 segmenten tegelijkertijd branden terwijl het ene nog niet mag branden of er maar half een segment gaat branden. Dit wil zeggen dat er foutje is gebeurd tijdens het solderen, dat er verlies opzit of baantjes met elkaar verbonden zijn. We kunnen ook terug de segmenten uit doen door de kabel van de data ingang aan de massa te hangen.


Testen van de LED-drivers


Wa gaan de LED-drivers testen door ze op een breadbordje te plaatsen.



Eerst worden de LED-drivers gesoldeerd op een IC-adaptor omdat de LED-drivers SMD-componenten zijn en deze kunnen we niet zomaar in een breadbordje plaatsen. Dus maken we er een IC van met een DIL-behuizing.



De linkse weerstand wordt aangesloten aan klem 23 van de IC. Deze zal zorgen voor een constante stroom die de IC mag leveren.



De rechtse weerstand wordt aangesloten aan de drukknop. Deze beperkt de stroom als we op de drukknop drukken en ook dat er geen kortsluiting kan ontstaan. Met de drukknop kunnen we een klokpuls sturen naar de IC. Deze is aangesloten op klem 3.

De LED's hangen aan de outputs van de IC.

de blauwe kabel is aangesloten aan de massa en aan klem 21 en dient om de outputs aan te sturen.

De oranje kabel wordt aangesloten aan klem 24 (+) en de groene kabel een klem 1 (-). Deze zorgen voor de voedingsspanning van de LED-driver (5V).


De bruine kabel wordt aangesloten aan klem 2 en dient om de data in te lezen. Is deze verbonden met de + dan kunnen we bij iedere klokpuls een 1 insturen, een LED zal dan oplichten. Hangen we de kabel aan de aan de massa dan kunnen we bij iedere klokpuls een 0 sturen. Dan kunnen de LED's terug uit gaan. Iedere keer we iets inlezen schuiven de LED's 1 plaats verder op.

De groene kabel aan de linkerkant is aangesloten aan klem 4 en zorgt dat we de IC kunnen gebruiken als latch.



testen verschillende segmenten


Om te controleren en zeker van te zijn dat er geen fouten op de printplaat staan gaan we elk segment van elk display afzonderlijk testen. Dit doen we met een 4 x 4 keypad dat we aansluiten op de print. Iedere drukknop gaat een segment bedienen. Aangezien we de displays als common anode aansluiten wordt het keypad op GND aan gesloten.

Gebruikt keypad:



Schema:


Solderen controllerbord


Bij het controllerbord moesten we ook eerst de doormetallisaties solderen voor het geleiden langs beide kanten en pas daarna plaatsten we de verschillende componenten op.



dinsdag 1 mei 2012

Solderen van de display module



De printplaat wordt eerst gefreesd.
Vervolgens worden de doormetalisaties gesoldeerd met koper draadjes.







Hierna wordt de connector en jumper op gesoldeerd.

 




Als laatste plaatsen we de displays erop.

donderdag 9 februari 2012

Flowcode oefening 2: 4x7-segment display's

Uitlezen van 4 getallen ingedrukt op klavier


Eerst wordt de oneindige lus geplaatst zodat het programma steeds blijft herhalen. Vervolgens komt de macro van het keypad. Hier zeggen we dat het keypad een getal gaat doorgeven. We vragen ons dan af of de variable "getal" gelijk is aan 255. Dit dient voor het behouden van het cijfer als we de drukknop van het keypad terug loslaten. Is dit ja dan blijft het getal gewoon staan. Dit geven we aan daar de variable "herh" gelijk aan 0 te stellen. Indien dit nee is dan gaan we een nieuwe vraag stellen. Is de variable "herh" gelijk aan 1? Is dit wel zo dan gebeurt er niks. Als dit nee is dan komen we in een calculation terecht waar we de displays een plaats laten opschijven zodat het cijfer ook een plaats opschijft en het nieuwe getal wordt weergegeven. Als laatste plaatsen we vier macro's van onze displays. Hier zeggen we welke waarde ze moeten weergeven.

Bijvoorbeeld: display 0 (het eerste display) geeft de variable "waarde" weer. Het volgende display "waarde2". Het derde display geeft de variable "waarde3" weer en het laatste display de variable "waarde4".

Flowcode oefening 1

avier inlezen --> ingedrukte knop op een 7-segment

1: met macro



Als eerste plaatsen we een oneindige lus zodat het programma kan blijven herhaalt worden. Vervolgens plaatsen we een macro. Hierin zeggen we wat het keypad moet doen. Hierna plaatsen we een dessision. Hierin plaatsen we of het nummer van het keypad gelijk is aan 255. Dit dient om het bewaren van het cijfer op het display. Dan plaatsen we nog een macro voor het sturen van ons display. Zo hebben we een simpel programma gemaakt dat als we een cijfer induwen op het keypad dat dit cijfer op een display verschijnt en behouden blijft.











2: zonder macro
Allereerst plaatsen we een oneindige lus dat ervoor zorgt dat het programma blijft lopen. We voegen hierna een input op poort C in. Dit zijn de schakelaars die het keypad gaan voorstellen. Bij deze oefening zijn C1 tot en met C3 de kolommen en C4 tot en met C7 zijn de rijen. Dan vragen we ons af in een decision welk nummer er op het keypad wordt ingedrukt. Tabel 1 zal aantonen hoe we de verschillende cijfers van het keypad in de verschillende decisions hebben geplaatst met een binaire code. Vooralleer we iets op het display konden laten verschijnen moesten we eerst de common klem, die we ingesteld hebben naar common anode, altijd een logische "1" sturen. Indien dit niet het geval was verscheen er niks op het display. Deze klem staat op A3. De segmenten van het display sluiten we aan op poort B. Hierop zetten we via een binaire code welk getal er moet op verschijnen. Tabel 2 toont welke codes er gebruikt werden.

Tabel 1

rij 4
rij3
rij2
rij 1
kolom 3
kolom 2
kolom 1
1
0
0
0
1
0
0
1
2
0
0
0
1
0
1
0
3
0
0
0
1
1
0
0
4
0
0
1
0
0
0
1
5
0
0
1
0
0
1
0
6
0
0
1
0
1
0
0
7
0
1
0
0
0
0
1
8
0
1
0
0
0
1
0
9
0
1
0
0
1
0
0
0
1
0
0
0
0
1
0
*
1
0
0
0
0
0
1
#
1
0
0
0
1
0
0

Tabel 2


DP
g
f
e
d
c
b
a
1
1
1
1
1
1
0
0
1
2
1
0
1
0
0
1
0
0
3
1
0
1
1
0
0
0
0
4
1
0
0
1
1
0
0
1
5
1
0
0
1
0
0
1
0
6
1
0
0
0
0
0
1
1
7
1
1
1
1
1
0
0
0
8
1
0
0
0
0
0
0
0
9
1
0
0
1
0
0
0
0
0
1
1
0
0
0
0
0
0
*
0
1
1
1
1
1
1
1
#
0
0
0
0
0
0
0
0