microcontroller gestuurde pre amp

JuuL · Bericht door **JuuL** » do 29 dec 2005, 18:26

Dan maar code stukjes weghalen en per lijn kijken of hij het doet:

Uieteraard met je Init etc er wel gewoon bij

   pos=0;
   LCDcursor(pos);
   for(n=0; n<20; n++)
   LCDwrite (32);
   LCDcursor(pos);
   while (pos < 20)
   {
     dat=getc();
     if (dat == 13) pos= 19;
     else LCDwrite(dat);
     pos=pos+1;
   }

En dan kijken of hij er goed doorkomt, gaat dat ook fout? Dan weer versimpelen net zo lang totdat je weet waar het zit.
Ik vraag me af of je clock lijn wel goed is, zou ik ook eens meten. En je kan ook kijken met een scope of het RS pinnetje wel hoog en laag wordt bij het schrijven van een commando.

Per deel kijken of het werkt, werkt niet? Kleiner deel nemen. Zo ben ik ook steeds verder gekomen

Moed niet laten zakken bij mij gaat het ook weer goed (uitstekend)

GeertJ · Bericht door **GeertJ** » do 29 dec 2005, 21:09

haha, een klein lichtpuntje (hoop ik)
kheb het over een andere boeg gegooid, en eens een voorbeeld van uit de manual van de controller gevolgd... eerste test was al belovend, maar er zat nog een klein tikfoutje in programma, hopelijk gaat het nu goed

/edit: yesyesyes, tmacheert bijna goed

I love assembler

:D:D:D

JuuL · Bericht door **JuuL** » do 29 dec 2005, 21:50

GeertJ · Bericht door **GeertJ** » do 29 dec 2005, 21:56

zit nog met een klein probleemke, dak nu hopelijk heb opgelost. Om een of andere reden ververst uC de display constant.
haha, ma ben al content, data komt waar ze hoort te staan, joepie !!!

/edit: jaja, tis volledig in orde gekomen, mijne dag kan nie meer stuk $\:D/$

Pjotr · Bericht door **Pjotr** » vr 30 dec 2005, 10:15

Gefeliciteerd Geert.

Hoe heb je het nu gedaan? Recht toe recht aan? Of schrijf je eerst de displaydata in een buffer? Als je een buffer gebruikt kun je controleren of die niet leeg is als je de display routine aanroept. Is de buffer leeg is hoef je het display niet te updaten.

GeertJ · Bericht door **GeertJ** » vr 30 dec 2005, 11:46

hihi, kzou het niet weten of ik het naar een buffer schrijf, denket wel, maar doet er niet toe, et werkt, en das et belangrijkste...

http://www.microtipsusa.com/driver_pdfs ... KS0073.PDF (zie pag 63)
was idd een zeer handig hulpmiddel. Er staat daar een voorbeeld om een 4 lijns display te programeren, awel, da heb ik dan ook letterlijk gevolgd. wel volledig in assembler en nog zonder enige functionaliteit, maar het bewijs is geleverd dat display wel goed werkt, als ik maar volgens de gebruiksaanwijzing van de LCD controller werk...

ben er nu nog wa meer functionaliteit aan het inbrengen, maar da lukt nu op den moment nog niet zo goed.... Probleem is dat ik een waarde vanuit een methode in C in een routine van asm moet krijgn

lukt op den moment nog niet goed.

dees is mijn programma tot nu toe

CODE: Selecteer alles

// ------------- READS51 generated header -------------- 
// module  : C:\Documents and Settings\Geert\Mijn documenten\voorversterker\microcontroller\preamp\preamplcd.c
// created : 22:48:53, Thursday, December 29, 2005
// ----------------------------------------------------- 

#define data_write 0x8002;
#define data_read 0x8003;
#define cmd_write  0x8000;
#define cmd_read  0x8001;


#asm
Busy:
mov     dptr, #cmd_read
movx    A, @dptr
jb      ACC.7, Busy
ret
#endasm

void LCDinit(void)
{
#asm
lcall   Busy                        ;Function Set: 8-bit,RE(1)        
mov     DPTR,#cmd_write
mov     A,#60
movx    @DPTR,A
lcall   Busy                        ;Extended Function Set: 5-Font, 4-Lin                   
mov     DPTR,#cmd_write
mov     A,#9
movx    @DPTR,A
lcall   Busy                        ;Function Set: RE(0)                    
mov     DPTR,#cmd_write
mov     A,#56
movx    @DPTR,A
lcall   Busy                        ;Display On Cursor Off                   
mov     DPTR,#cmd_write
mov     A,#12
movx    @DPTR,A
#endasm
}


void LCDhome(void)      //set cursor home (first segment, first line)
{
#asm
lcall   Busy                        ;Return to Home                   
mov     DPTR,#cmd_write
mov     A,#2
movx    @DPTR,A
#endasm
}

void LCDselLine2(void)              //select second line
{
#asm
lcall   Busy                            ;Volgende regel
mov     DPTR,#cmd_write                
mov     A,#160
movx    @DPTR,A
#endasm
}

void LCDselLine3(void)              //select third line
{
#asm
lcall   Busy                            ;Volgende regel
mov     DPTR,#cmd_write                
mov     A,#192
movx    @DPTR,A
#endasm
}

void LCDselLine4(void)              //select fourth line
{
#asm
lcall   Busy                            ;Volgende regel
mov     DPTR,#cmd_write                
mov     A,#224
movx    @DPTR,A
#endasm
}

void LCDwritechar(unsigned char kar)
{
#asm
lcall   Busy
mov     a, BPL
mov     dptr, #data_write
movx    @dptr, a
#endasm
}

main()
{


LCDinit();
LCDhome();
LCDwritechar("A");
LCDwritechar("a");
LCDwritechar("B");
LCDwritechar("b");
LCDselLine2();
LCDwritechar("C");
LCDwritechar("c");



}

JuuL · Bericht door **JuuL** » vr 30 dec 2005, 12:19

WHOOOPS nu ik je code zie, zie ik dat ik wat heb vergeten toen ik jou dat vertelde over die regels.

kijk eens bij deze site (jaja:))
http://home.iae.nl/users/pouweha/lcd/lcd0.shtml

paragraaf2.2
Sets the DDRAM address. DDRAM data is sent and received after this setting.
Hiermee stel je de cursor in.
die waarde in die tabel staat voor 128decimaal.

Als je dan naar paragraaf 2.3.3. 4-line displays gaat
dan converteer je die waarde naar decimaal (calculator windows is handig

)
en die waarde tel je bij die 128 op (dat was ik vergeten).
Alleen zit jouw LCD dan nog iets anders in elkaar, maar dan snap je tenminste hoe het werkt.

Pjotr · Bericht door **Pjotr** » vr 30 dec 2005, 12:30

Hallo Geert,

Eigenlijk zijn er twee zaken met het display:

1/ De initialisatie, dat hoef je maar 1x te doen bij het aan zetten en hoort thuis in je algemene init routine.

2/ Het schrijven van user data naar het display.

Het voorstel van Henkjan om een pointer te gebruiken is niet zo gek hier. Je zou het zo kunnen doen: Je declareert in C een globale array met een pointer die daar naar toe verwijst. De array kan dan bestaan uit:

Het aantal chars wat naar het display moet (1 byte)
De regel waar het naar toe moet (1 byte)
De positie op de regel (1 byte)
De chars zelf (max. 20 bytes in jouw geval)

Die kun je dan in C gebruiken om naar het display te schrijven.

In assembler schrijf je dan een routine die de data vanuit het array naar display schrijft en dezelfde pointer gebruikt die je in C voor de array gedeclareerd hebt. Is het aantal bytes nul dan is er niets weg te schrijven en kun je gelijk terug keren vanuit de display routine. Is er wel wat te schrijven dan kun je het aantal chars in de array (de eerste byte van de array) gebruiken als char counter.

Ipv het aantal chars mee te geven kun je ook de char string afsluiten met een null byte (= 0 ), wordt ook vaak gedaan. Je schijft dan de chars naar display net zo lang totdat je een null byte tegen komt. Is wat minder robust, stel dat je die null byte vergeet mee te geven .......

GeertJ · Bericht door **GeertJ** » vr 30 dec 2005, 17:22

JuuL schreef:
Als je dan naar paragraaf 2.3.3. 4-line displays gaat
dan converteer je die waarde naar decimaal (calculator windows is handig )

Lol, denk dat volgens windows, de windows calculator het meest gebruikte programma op gans deze computer is

GeertJ · Bericht door **GeertJ** » vr 30 dec 2005, 17:26

Pjotr schreef:
Hallo Geert,

Eigenlijk zijn er twee zaken met het display:

1/ De initialisatie, dat hoef je maar 1x te doen bij het aan zetten en hoort thuis in je algemene init routine.

2/ Het schrijven van user data naar het display.

Het voorstel van Henkjan om een pointer te gebruiken is niet zo gek hier. Je zou het zo kunnen doen: Je declareert in C een globale array met een pointer die daar naar toe verwijst. De array kan dan bestaan uit:

Het aantal chars wat naar het display moet (1 byte)
De regel waar het naar toe moet (1 byte)
De positie op de regel (1 byte)
De chars zelf (max. 20 bytes in jouw geval)

Die kun je dan in C gebruiken om naar het display te schrijven.

In assembler schrijf je dan een routine die de data vanuit het array naar display schrijft en dezelfde pointer gebruikt die je in C voor de array gedeclareerd hebt. Is het aantal bytes nul dan is er niets weg te schrijven en kun je gelijk terug keren vanuit de display routine. Is er wel wat te schrijven dan kun je het aantal chars in de array (de eerste byte van de array) gebruiken als char counter.

Ipv het aantal chars mee te geven kun je ook de char string afsluiten met een null byte (= 0 ), wordt ook vaak gedaan. Je schijft dan de chars naar display net zo lang totdat je een null byte tegen komt. Is wat minder robust, stel dat je die null byte vergeet mee te geven .......

oke, met puntje een ben ik mee, en dat doe ik volgens mij ook in mijn main(); Daar roep ik LCDinit op welke dan de initialisatie doet van de display.
vanaf puntje twee ga je voor mij de mist in, blijkbaar is mijn programmeertalent niet groot genoeg

kan je het eens int vlaams (hum, nederlands is ook goed

) uitleggen? of nog liever kan je eens een vbtje tonen?? thx

Pjotr · Bericht door **Pjotr** » vr 30 dec 2005, 17:48

Oei tja Geert,

Ik neem aan dat je weet wat een pointer is? Dat is eigenlijk het adres waar de data staat. De data staat dan daar op opvolgende adressen. Maar misschien kun je met jouw C-compiler niet eens een array declareren. Een array is ook gewoon een rijtje opvolgende data met een adres waar het begint, de pointer.

Maar ik ken jouw compiler niet dus dat wordt lastig een voorbeeld te geven. Kan je wel een voorbeeld van assembler voor een AVR geven voor het schrijven naar een LCD vanuit een buffer maar dat heb ik nu niet bij de hand. Kan ik volgende week pas weer bij als ik op mijn werk zit.

JuuL · Bericht door **JuuL** » vr 30 dec 2005, 17:51

De vorige code van Geert was toch ook wel aardig netjes?

/Juul wil ook assembler!

GeertJ · Bericht door **GeertJ** » vr 30 dec 2005, 18:00

Pjotr schreef:
Oei tja Geert,

Ik neem aan dat je weet wat een pointer is? Dat is eigenlijk het adres waar de data staat. De data staat dan daar op opvolgende adressen. Maar misschien kun je met jouw C-compiler niet eens een array declareren. Een array is ook gewoon een rijtje opvolgende data met een adres waar het begint, de pointer.

Maar ik ken jouw compiler niet dus dat wordt lastig een voorbeeld te geven. Kan je wel een voorbeeld van assembler voor een AVR geven voor het schrijven naar een LCD vanuit een buffer maar dat heb ik nu niet bij de hand. Kan ik volgende week pas weer bij als ik op mijn werk zit.

oke,
compiler die ik gebruik is reads51, freeware... kunde hier downloaden: http://www.rigelcorp.com/

mijn probleem is dus dat ik in de methode LCDwritechar(unsigned char kar) een karakter moet meegeven, in die methode moet ik de meegegeven waarde in die asm code krijgen. en dat lukt op de moment niet echt.

GeertJ · Bericht door **GeertJ** » vr 30 dec 2005, 18:07

JuuL schreef:
De vorige code van Geert was toch ook wel aardig netjes?

/Juul wil ook assembler!

tja, kvind het ook een schone code, moest het nog eens deftig werken

maar we komen er wel uit. Ben alleszins een stuk verder, maar eig ook een stuk terug, eerst kwam er wel data op display, maar nie waar da ik wil, nu komt er data waar ik wil, maar ze komt nog niet op de display

tis altijd iets precies

wat heb ik hier onlangs ergens gelezen, de wet van behoud van miserie...

Pjotr · Bericht door **Pjotr** » vr 30 dec 2005, 19:15

Hoi Geert,

Nix mis met je code hoor, maar daar ging het ook niet om

Heb even naar de handleiding van je compiler gekeken. Je kunt idd 1 dimensonale arrays declareren van het type char of int. De naam van het array is dan ook gelijk de pointer (eigenlijk identiek als met een variabele) en die kun je volgens mij dan gelijk in je assembler weer gebruiken. Maar goed ik heb het niet geprobeerd, misschien is het een hint waar je wat mee kan.

Ik ging er vanuit dat je een hele regel in een assembler routine wilde schrijven naar het display, maar je kan dat natuurlijk ook character voor character doen. Moet je nog steeds meerdere variabelen naar assembler overdragen.

Voor zover ik het begrijp is de naam van een variabele of array in C ook gelijk de naam van de pointer die je in assembler nodig hebt.

GeertJ · Bericht door **GeertJ** » vr 30 dec 2005, 19:59

mijn volgende probleem dus....
oke, hier die code weermee de lcd werkte:

CODE: Selecteer alles

// ------------- READS51 generated header -------------- 
// module  : C:\microcontroller\test\lcd.c
// created : 19:59:42, Thursday, December 29, 2005
// ----------------------------------------------------- 

#define data_write 0x8002;
#define data_read 0x8003;
#define cmd_write  0x8000;
#define cmd_read  0x8001;


main()
{
#asm
lcall   Busy                        ;Function Set: 8-bit,RE(1)        
mov     DPTR,#cmd_write
mov     A,#60
movx    @DPTR,A
lcall   Busy                        ;Extended Function Set: 5-Font, 4-Lin                   
mov     DPTR,#cmd_write
mov     A,#9
movx    @DPTR,A
lcall   Busy                        ;Function Set: RE(0)                    
mov     DPTR,#cmd_write
mov     A,#56
movx    @DPTR,A
lcall   Busy                        ;Display On Cursor Off                   
mov     DPTR,#cmd_write
mov     A,#12
movx    @DPTR,A
lcall   Busy                        ;Return to Home                   
mov     DPTR,#cmd_write
mov     A,#2
movx    @DPTR,A
lcall   Busy                        ;data write (karatker ASCII)                
mov     DPTR,#data_write
mov     A,#83
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#65
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#77
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#83
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#85
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#78
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#71
movx    @DPTR,A
lcall   Busy                            ;Data Write ASCII 
mov     DPTR,#data_write
mov     A,#71
movx    @DPTR,A
lcall   Busy                            ;Volgende regel
mov     DPTR,#cmd_write                
mov     A,#160
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#75
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#51
movx    @DPTR,A
lcall   Busy
mov     DPTR,#cmd_write            
mov     A,#192
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#76
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#67
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#68
movx    @DPTR,A
lcall   Busy
mov     DPTR,#data_write
mov     A,#68
movx    @DPTR,A
#endasm
}

#asm
Busy:
mov     dptr, #cmd_read
movx    A, @dptr
jb      ACC.7, Busy
ret
#endasm

duidelijk te zien dat het allemaal in asm geschreven is, maar er zit niks van functionaliteit in.

waarvan ik wil gebruik maken..., maar die dus niet werkt... maar wat volgens mij wel op het zelfde neer komt als wat ik doe met bovenstaande code...

CODE: Selecteer alles

// ------------- READS51 generated header -------------- 
// module  : C:\Documents and Settings\Geert\Mijn documenten\voorversterker\microcontroller\preamp\preamplcd.c 
// created : 22:48:53, Thursday, December 29, 2005 
// ----------------------------------------------------- 

#define data_write 0x8002; 
#define data_read 0x8003; 
#define cmd_write  0x8000; 
#define cmd_read  0x8001; 


#asm 
Busy: 
mov     dptr, #cmd_read 
movx    A, @dptr 
jb      ACC.7, Busy 
ret 
#endasm 

void LCDinit(void) 
{ 
#asm 
lcall   Busy                        ;Function Set: 8-bit,RE(1)        
mov     DPTR,#cmd_write 
mov     A,#60 
movx    @DPTR,A 
lcall   Busy                        ;Extended Function Set: 5-Font, 4-Lin                    
mov     DPTR,#cmd_write 
mov     A,#9 
movx    @DPTR,A 
lcall   Busy                        ;Function Set: RE(0)                    
mov     DPTR,#cmd_write 
mov     A,#56 
movx    @DPTR,A 
lcall   Busy                        ;Display On Cursor Off                    
mov     DPTR,#cmd_write 
mov     A,#12 
movx    @DPTR,A 
#endasm 
} 


void LCDhome(void)      //set cursor home (first segment, first line) 
{ 
#asm 
lcall   Busy                        ;Return to Home                    
mov     DPTR,#cmd_write 
mov     A,#2 
movx    @DPTR,A 
#endasm 
} 

void LCDselLine2(void)              //select second line 
{ 
#asm 
lcall   Busy                            ;Volgende regel 
mov     DPTR,#cmd_write                
mov     A,#160 
movx    @DPTR,A 
#endasm 
} 

void LCDselLine3(void)              //select third line 
{ 
#asm 
lcall   Busy                            ;Volgende regel 
mov     DPTR,#cmd_write                
mov     A,#192 
movx    @DPTR,A 
#endasm 
} 

void LCDselLine4(void)              //select fourth line 
{ 
#asm 
lcall   Busy                            ;Volgende regel 
mov     DPTR,#cmd_write                
mov     A,#224 
movx    @DPTR,A 
#endasm 
} 

void LCDwritechar(unsigned char kar) ;hier vooral stelt zich het probleem
{ 
#asm 
lcall   Busy 
mov     a, BPL 
mov     dptr, #data_write 
movx    @dptr, a 
#endasm 
} 

main() 
{ 


LCDinit(); 
LCDhome(); 
LCDwritechar("A"); 
LCDwritechar("a"); 
LCDwritechar("B"); 
LCDwritechar("b"); 
LCDselLine2(); 
LCDwritechar("C"); 
LCDwritechar("c"); 



}

werkt dus niet, maar wat doe ik fout... ???

Pjotr · Bericht door **Pjotr** » vr 30 dec 2005, 20:18

Hmm, wat ik niet kan traceren is waar je de data werkelijk naar het display schijft en de clock ervan stobed. Is dat met lcall Busy?

Nog een opmerking: waarom heb je een aparte routine voor

LCDselLine2()

Kun je toch ook af met:

LCDselLine(2)

Hoef je daar maar 1 assembler routine voor te schrijven waaraan je het regelnummer meegeft.

GeertJ · Bericht door **GeertJ** » za 31 dec 2005, 11:05

Pjotr schreef:
Hmm, wat ik niet kan traceren is waar je de data werkelijk naar het display schijft en de clock ervan stobed. Is dat met lcall Busy?

Nog een opmerking: waarom heb je een aparte routine voor

LCDselLine2()

Kun je toch ook af met:

LCDselLine(2)

Hoef je daar maar 1 assembler routine voor te schrijven waaraan je het regelnummer meegeft.

nu, ik moet zeggen dat ik deze code grotendeels over heb genomen uit een boek.
Lcall busy gaat volgens mijn kijken of dat de busy flag (pin DB7 op display) van de display hoog is, als dat zo is, gaat deze opnieuw kijken, totdat deze laag wordt. Dan keert die terug naar de volgende regel van waar dat hij gekomen is. waar ik de data naar de display schrijf is me eignlijk ook beetje een misterie, maar het werkt wel, ale toch op dat eerst, volledig in asm geschreven programma.
LCDselLine(2) is inderdaad een schoner oplossing... maar dan moet ik wel da meegegeven waardes in mijn methode naar mijn asm routine krijgen, en daarvan ben ik niet zeker dat dat goed gedaan wordt.

/edit: kheb nog wa kleine aanpassingskes gedaan, en ik krijg nu al tekens op mijn display

nu nog zoeken waar dat de letters en cijfers zitten

JuuL · Bericht door **JuuL** » wo 04 jan 2006, 23:16

Hoe gaat het met jouw project dan?

GeertJ · Bericht door **GeertJ** » wo 04 jan 2006, 23:22

noodgedwongen ff aan de kant geschoven, ik heb volgende week examens op school, en daar moet ik nu toch wel ff heel hard voor gaan beginnen leren (jammer genoeg

zou liever voort knosselen

want das toch zo leuk eh

)

GeertJ · Bericht door **GeertJ** » do 05 jan 2006, 16:16

zo ff tussen de boeken door, zat ik te denken wat voor opamps ik best zo kunnen gebruiken voor de bouw van de voorversterker. Mijn idee is om een ingangs en uitgansbuffer/opamp te plaatsen. op deze site http://tangentsoft.net/audio/opamps.html staan er een heel pak die voor audiotoepassingen in aanmerking komen. Mijn oog is gevallen op de Burr-Brown OPA637. Maar wat denken da specialisten hiervan??

JuuL · Bericht door **JuuL** » do 05 jan 2006, 17:12

The datasheet says that it is minimally stable at a gain of 5, but as with all chips, the higher the gain, the more stable it becomes.

Heb er niet zo heel veel verstand van maar, gaat dit niet een probleem vormen voor een gain van 1?

/edit
Helemaal vergeten, ook namens mij succes met je examen(s)!

Rudy · Bericht door **Rudy** » do 05 jan 2006, 17:35

Ik veronderstel dat ie de 627 bedoeld ( welke unity gain stable is ), als je de prijs ervoor wil betalen is dat natuurlijk geen probleem ( >15Euro het stuk ). De LM6171 is een vette aanrader ( ook kwa prijs ), maar niet zo simpel bruikbaar ( smd en allerhande feedback compensaties ).

Een uitgangsbuffer heb je trouwens niet nodig, geen enkele reden om een extra opamp in de hele keten te pleuren.

Verzorg verder je supply en je layout wat meer dan gewoonlijk, hou je signaalverloop zo kort mogelijk en zorg voor een ingangsfilter voor de eerste buffer opamp.

Succes met je examen(s)

Groetjes
Rudy

GeertJ · Bericht door **GeertJ** » za 04 mar 2006, 2:08

alweer een tijdje geleden dat ik hier wa getypt heb, maar kheb nie stil gezeten.
Wat heb ik zoal gedaan ewel, eerst en vooral heb ik wa producten gekocht om printplaten te etsen, want kheb ondervonden dat je dat echt wel zo moet doen, om een proper resultaat te krijgen van een schakeling, zeker als ze wat complexer beginnen worden.
Daarna een print voor voeding ontworpen, en geetst en gesoldeerd, en ze werkt nog ook

, etsen wel twee keer moeten doen, want eerste keer was de print niet lang genoeg belicht

Voeding is gescheiden in 2 delen, een voeding voor het digitaal (+ 5V) en een voeding voor het analoge gedeelte (- 5V en + 5V). Beide met 'eenvoudige' LM7805 en LM7905. Elco's aan voeding 4700µF per voltage...

Tweede deel dat ook af is, is de ingangsselectie voor de verschillende bronnen. Heb 8 kanalen voorzien (beter een te veel dan te weinig). elk kanaal wordt geschakeld mbv een relais. Met een 3 to 8bit decoder(74HCT137) kan ik de uitgangen op de microcontroller wat in de perken houden...

Wat moet er nog gebeuren:
- voorversterker print met µC controller moet nog gemaakt worden
- Afstandsbediening met RC5 codes uitdokteren
- hardware voor RC5 afst maken...
- Bedieningspaneel voor voorversterker te bedienen nog maken (knopjes? rotary encoder? .... )
- µC programmeren

ff nog een fotoke meegeven
Afbeelding

JuuL · Bericht door **JuuL** » za 04 mar 2006, 12:11

Mooi! Begint te komen