Met één digitale uitgang en de PIC16F84A meerdere dingen aansturen

Hallo allemaal,

ik heb een probleem en ik hoop dat iemand mij daarbij kan helpen. Ik heb namelijk een aansluiting die alleen maar aan of uit kan waarmee ik meerdere dingen wil gaan aansturen, hoe moet dat? En kan dat met een microcontroller, de PIC16F84A?
Ik vraag me af of je die aansluiting dan op de microcontroller kan aansluiten en bijvoorbeeld die aansluiting "aan, aan, aan, uit" kan laten doen en als dat gebeurt er uit een pin van de controller stroom komt. Ik hoop dat iemand mij verder kan helpen.

René Haemers

Tuurlijk kan dat met een microcontrolller, maar kan je iets duidelijker zijn?
Wat ga je aan/uit schakelen? Misschien kan het wel makkelijker.

Wat jij wilt is mogelijk met diverse microcontrollers, waaronder de door jou genoemde PIC. Sturen van een poort bij een microcontroller is op zich een vrij triviale actie.

Maar omdat je zo vaag blijft over hetgeen je wilt aansturen is het niet mogelijk een doelgericht antwoord te geven.

  • Wat is die aansluiting die jij wilt gaan aansturen?
  • Hoe weet de microcontroller wanneer je wat gaat sturen: Komt er een toestenbord aan? Gaat het op tijd? etc...
  • Heb je ervaring met de genoemde PIC? Gezien je vraag waaarschijnlijk niet.
  • Heb je ervaring met programmeren (niet specifiek gericht op micocontrollers)?

Een microcontroller stuurt meestal een TTL signaal uit (0-5V). Low power controllers nog minder (3V of lager). De maximale stroom is ook beperkt. Een buffer schakeling (voor signaal aanpassing) kan dus wenselijk zijn.

[Bericht gewijzigd door Marcel op ]

Ik zal proberen wat duidelijker zijn. Ik wil op één pin van de LPT poort meerdere transistors aansluiten m.b.v. die microcontroller.
Ik wil dan (in delphi, dat is de enige programmeertaal die ik kan) een programma schrijven die die pin van de LPT poort aanstuurd, dus bijvoorbeeld: ik schrijf een programma die die pin eerst een miliseconde aandoet dan een miliseconde uit dan weer aan en dan weer uit, steeds een miliseconde lang. En ik wil dan bereiken dat die microcontroller dat "leest" en een pin van die microcontroller aandoet, die pin sluit ik dan aan op een transistor en klaar is kees :).
En het moet natuurlijk ook zo zijn dat bijvoorbeeld als je:
"aan, uit, aan, uit" -> pin 18 aan gaat.
"uit, aan, aan, uit" -> pin 17 aan gaat.
enz...

[Bericht gewijzigd door rhaemers op ]

Dat noemen ze serieële communicatie, mischien handig als je daar eens op zoekt, er is al een massa info over geschreven en het is allemaal niet echt moeilijk hoor. Heb je trouwens geen serieële poort op je PC, het lijkt me een beetje raar om een serieële verbinding op te zetten op een parrallele poort, maar het kan natuurlijk wel.

Steven

Op 27 december 2005 02:11:16 schreef rhaemers:
Ik zal proberen wat duidelijker zijn. Ik wil op één pin van de LPT poort meerdere transistors aansluiten m.b.v. die microcontroller.
Ik wil dan (in delphi, dat is de enige programmeertaal die ik kan) een programma schrijven die die pin van de LPT poort aanstuurd

Ok, ik dacht eerst dat de microcontroller (noem ik vanaf nu uC) die ene pin moest schakelen. Maar het is dus juist de uC die via die ene pin aangestuurd wordt.

Dan moet je een serieel protocol gaan bedenken en implementeren in de uC en in je Delphi programma. Maar is de seriele poort ook geen optie zoals paxmowa al zegt?

Ik ben trouwens benieuwd? Vanwaar je keuze voor de (obsolete) PIC16F84A en niet bijv. een AVR (mijn favoriet) of een 8051 (free_electrons favoriet). Als je dan een PIC kiest kies dan liever een 16F628A.

Serieel is het vrij simpel. Pas nog een kerstster gemaakt die via RS232 (serieel) gestuurt kan worden (topic kerst ideeën). De relevante C sourcecode daarvan mag je zo van me hebben.

Ik houd het liever bij die LPT poort, daar heb ik al veel ervaring mee en kan ik goed besturen met delphi.
Maar ik vraag me af hoe je dan zo een serieel protocol bedenkt en maakt, het implementeren ervan lukt me wel maar hoe moet je het maken?
En ik wil die microcontroller gebruiken omdat ik die hier nog heb liggen en ik werk er graag mee.

Het grote probleem wat ik heb is eigenlijk niet
-hoe ik het moet aansluiten
-wat ik moet gebruiken
-hoe ik de LPT poort moet besturen
maar wat zet ik in die microcontroller.

Stapje bij stapje wordt het duidelijker.

Als het echt maar 1 stuurlijn mag zijn dan kan je denken aan een protocol op basis van manchester encoding zoals Philips dat in zijn RC5 protocol doet. Voorbeeld http://www.xs4all.nl/~sbp/knowledge/ir/rc5.htm

Of op basis van pulsbreedte. Weer een voorbeeld http://www.xs4all.nl/~sbp/knowledge/ir/recs80.htm

De laatste is denk ik iets makkelijker te implementeren.

Zijn twee lijnen ook een optie dan zou je clock en data kunnen scheiden. Dan krijg je een soort schuifregister aansturing. Je klokt gewoon zoveel bits over als nodig.

De software voor de PIC zou je kunnen schrijven in JAL. Naar ik heb vernomen (zelf heb ik er geen ervaring mee) lijkt dat veel op Pascal. En aangezien Delphi weer een soort visual Pascal is, lijkt dat ook weer op elkaar.

Voordeel van serieel is wel dat je de kabel veel langer kan maken voordat je transmissie problemen krijgt. En dat het in de uC makkelijker te implementeren is.

Stapje bij stapje wordt het duidelijker;)

Maar nu weet ik nog niet hoe ik die protocol dan moet maken, heeft mischien iemand een voorbeeld ofzo, ik heb niets kunnen vinden.
Ik wil trouwens liever assembleer taal gebruiken i.p.v. JAL, ik heb namelijk nog nooit van JAL gehoort en mijn vorige project heb ik ook met assembleer taal gemaakt.

Ik hoop dat iemand mij verder kan helpen.

Natuurlijk kan het ook in assembler. Maar je schreef zelf

in delphi, dat is de enige programmeertaal die ik kan

Daarom stelde ik je JAL voor.

Met assembler op de PIC kan ik je niet helpen, geen ervaring mee. Maar er moeten genoeg andere forum gebruikers zijn die dat wel hebben.

Waar loop je precies vast bij het maken van een protocol? Ik heb je een paar voorbeelden gegeven. Begrijp je ze niet? Weet je niet hoe die te implementeren in Delphi en assembler? Of is er iets anders?

Heb je echt maar 1 ingang ter beschikking voor de communicatie PC -> uC ?
Met 2 lijnen wordt het een heeeeeel stuk gemakkelijker.

Zoals Marcel al schreef: dan kun je met een Clock-lijn en een Data-lijn werken.

Op 27 december 2005 19:18:24 schreef Marcel:
Waar loop je precies vast bij het maken van een protocol? Ik heb je een paar voorbeelden gegeven. Begrijp je ze niet? Weet je niet hoe die te implementeren in Delphi en assembler? Of is er iets anders?

Ik loop vast bij beide eigenlijk, het maken van een protocol en ik heb ook absoluut geen idee hoe je die protocollen dan moet implenteren in de assembler.

Op 27 december 2005 19:35:59 schreef logic:
Heb je echt maar 1 ingang ter beschikking voor de communicatie PC -> uC ?
Met 2 lijnen wordt het een heeeeeel stuk gemakkelijker.

Zoals Marcel al schreef: dan kun je met een Clock-lijn en een Data-lijn werken.

Ik kan echt maar één ingang gebruiken.

"Ik kan echt maar één ingang gebruiken."
Da's jammer, want met 1 lijn kom je altijd terecht bij TIMING.
En dat is altijd link om met een PC te doen. (zeker onder Windows)
Tenminste, als je het zelf wilt doen via de LPT-poort.
(seriele communicatie werkt ook met timing, maar het IC dat daarvoor gebruikt wordt is daarin gespecialiseerd, dus da's iets anders)

De 2 voorbeelden van Marcel zijn duidelijk genoeg, dacht ik zo.
Je zou ook nog een heel simpel protocol kunnen gebruiken:
- 3 seconden hoog - startbit
- 2 seconden hoog - logisch 1
- 1 seconden hoog - logisch 0
- tussen 2 hoge signalen altijd 1 seconde laag
- in totaal worden altijd 8 logische signalen (bits) verzonden

Die "seconde" moet je niet letterlijk nemen natuurlijk, da's alleen maar als voorbeeld: het gaat even om het idee.
Als je die "seconden" lang genoeg neemt, dan zou het qua timing geen probleem moeten zijn.
De communicatie gaat wel een beetje langzaam worden, maar dat wordt het zowiezo met maar 1 datalijn.

Snap je 'm, of ga ik nu te snel?

OK, dat snap ik:), maar zou je dan een voorbeeld willen geven hoe je dat dan moet programmeren in asembleertaal (dat met die "- 3 seconden hoog - startbit
- 2 seconden hoog - logisch 1
- 1 seconden hoog - logisch 0")?

[Bericht gewijzigd door rhaemers op ]

Ik heb niet zo 1-2-3 een assembler-voorbeeld voor je.
Ik kan je wel het algemene idee geven hoe dat aan te pakken.

Ik werk zelf niet met de 16F84A en ik weet ook niet of je bepaalde onderdelen al voor andere zaken gebruikt (bv. timer0 ), dus als ik onzin brabbel moet je het maar zeggen.

Het idee is het volgende:
Wanneer de input hoog wordt, start je een timer.
In een lusje poll je de input, totdat die weer laag is.
Dan stop je de timer.
Aan de hand van de timerwaarde kun je meten hoe lang de input hoog is geweest: dat bepaalt startbit/logisch 0/logisch 1.

Waarschijnlijk zal die timer veel te snel lopen, dus maak je gebruik van extra registers.
Iedere keer bij een timer-overflow (FFh -> 00h) hoog je een register op.
Loopt dat register over, dan hoog je het volgende register op, enz.
Hoeveel registers je nodig hebt, hangt af de lengte van de pulsen.

Houd bij het controleren van de registers een bepaalde marge aan (b.v. 10-20 = logisch 0 / 15-25 = logisch 1 / 40-55 = startbit), dan komt de timing (vanuit de computer gezien) niet zo nauw.

Het programmeren mag je zelf doen. ;-)

zit er daar geen USART op die pic ? dan wordt het een stuk makkelijker. en hang hem dan aan uw seriele port en niet aan uw printerport.

probleem weg.

De 16F84A heeft idd geen USART.
Anders had iemand dat idee allang geopperd. :-)

Op 27 december 2005 21:59:59 schreef logic:
Ik heb niet zo 1-2-3 een assembler-voorbeeld voor je.
Ik kan je wel het algemene idee geven hoe dat aan te pakken.

Ik werk zelf niet met de 16F84A en ik weet ook niet of je bepaalde onderdelen al voor andere zaken gebruikt (bv. timer0 ), dus als ik onzin brabbel moet je het maar zeggen.

Het idee is het volgende:
Wanneer de input hoog wordt, start je een timer.
In een lusje poll je de input, totdat die weer laag is.
Dan stop je de timer.
Aan de hand van de timerwaarde kun je meten hoe lang de input hoog is geweest: dat bepaalt startbit/logisch 0/logisch 1.

Waarschijnlijk zal die timer veel te snel lopen, dus maak je gebruik van extra registers.
Iedere keer bij een timer-overflow (FFh -> 00h) hoog je een register op.
Loopt dat register over, dan hoog je het volgende register op, enz.
Hoeveel registers je nodig hebt, hangt af de lengte van de pulsen.

Houd bij het controleren van de registers een bepaalde marge aan (b.v. 10-20 = logisch 0 / 15-25 = logisch 1 / 40-55 = startbit), dan komt de timing (vanuit de computer gezien) niet zo nauw.

Het programmeren mag je zelf doen. ;-)

Hier kom ik wel verder mee, bedankt.

Ok.

Laat je tezijnertijd weten of het gelukt is? (stukje code posten?)
Ben zeer benieuwd.

Succes ermee.

Op 27 december 2005 21:59:59 schreef logic:
Waarschijnlijk zal die timer veel te snel lopen, dus maak je gebruik van extra registers.

Dat kan maar het is veel efficienter om de prescaler van de timer zo in te stellen dat deze langzamer loopt.