Beginnen met Microcontrollers?

[TheBlasphemer]

Hey,

Ik ben al vrij ervaren in het onder windows programmeren in C/C++ en (x86) ASM. Ik kijk echter al enkele jaren erg op naar mensen die met microcontrollers de leukste dingen bouwen, en wil dit ook graag eens zelf doen.

Maar hoe begin je met zoiets? je moet naar het schijnt een PIC-programmer hebben, en een PIC kopen (of samplen). En daar nog allerlei dingen bij etc, allemaal vrij ingewikkeld als je er geen drol vanaf weet.

Kunnen jullie misschien aanraden hoe je hiermee, het liefst relatief goedkoop, kan beginnen?
Wat is een leuke PIC, wat voor projectje zou ik daarmee kunnen maken ?
De enige kennis die ik heb van eletronica is signaalverwerking bij Natuurkunde

Alvast bedankt,
TB

[Widow]

Er staat in de Elektronica FAQ aardig wat over uC's

[sigma01]

Je kunt dit verhaal vanaf twee kanten benaderen:

A ) Je wilt zelf echt schakelingen gaan ontwerpen (met later) eventueel microcontrollers

B ) Je wilt vooral een microcontroller leren programmeren

Als je voor de eerste optie gaat, zou ik eerst wat 'simpele' schakelingen ontwerpen en daarna met een eenvoudige microcontroller (bijv. een pic beginnen). Dit omdat iedere microcontroller schakeling op zijn minst een voeding nodig heeft en bij voorkeur ook input/output devices (wat LEDjes of een sensor die je met de interne A/D converter kan uitlezen o.i.d.)

De tweede manier is het aanschaffen van een kant en klaar ontwikkelbord. Hierbij weet je gegarandeerd dat de hardware werkt en leer je de mogelijkheden van een microcontroller sneller kennen. Keil heeft een mooie softwareomgeving (die in de trail version beperkt is qua grote) en ze leveren ook kant en klare developmentboards http://www.keil.com/boards/ . Misschien is dat een goede optie om mee te beginnen.

[DP Kunst]

ik ben er ook net mee begonnen en het is eigenlijk helemaal niet zo moeilijk.
ik heb een paar ATmega32 microcontrollers besteld en ben gaan proberen.

op www.circuitsonline.net staat hoe je zelf een programmer kunt maken voor aan de parallelle poort.
die heb ik in elkaar geknutseld en ik heb eens in de datasheet van de ATmega gekeken wat ie allemaal kan. in het begin snapte ik er niet veel van, maar dankzij madwizard lukt het nu al aardig...

je kunt ook eens kijken op www.avrbeginners.net , daar staat ook wel wat handige info.

[TheBlasphemer]

sigma01 schreef op vrijdag 20 januari 2006 @ 23:39:
Je kunt dit verhaal vanaf twee kanten benaderen:

A ) Je wilt zelf echt schakelingen gaan ontwerpen (met later) eventueel microcontrollers

B ) Je wilt vooral een microcontroller leren programmeren

Als je voor de eerste optie gaat, zou ik eerst wat 'simpele' schakelingen ontwerpen en daarna met een eenvoudige microcontroller (bijv. een pic beginnen). Dit omdat iedere microcontroller schakeling op zijn minst een voeding nodig heeft en bij voorkeur ook input/output devices (wat LEDjes of een sensor die je met de interne A/D converter kan uitlezen o.i.d.)

De tweede manier is het aanschaffen van een kant en klaar ontwikkelbord. Hierbij weet je gegarandeerd dat de hardware werkt en leer je de mogelijkheden van een microcontroller sneller kennen. Keil heeft een mooie softwareomgeving (die in de trail version beperkt is qua grote) en ze leveren ook kant en klare developmentboards http://www.keil.com/boards/ . Misschien is dat een goede optie om mee te beginnen.

Vooral optie B eigenlijk. Electronica is leuk, maar met programmeren kun je meer en vind ik persoonlijk leuker

DaNiEl KuNsT schreef op vrijdag 20 januari 2006 @ 23:54:
ik ben er ook net mee begonnen en het is eigenlijk helemaal niet zo moeilijk.
ik heb een paar ATmega32 microcontrollers besteld en ben gaan proberen.

op www.circuitsonline.net staat hoe je zelf een programmer kunt maken voor aan de parallelle poort.
die heb ik in elkaar geknutseld en ik heb eens in de datasheet van de ATmega gekeken wat ie allemaal kan. in het begin snapte ik er niet veel van, maar dankzij madwizard lukt het nu al aardig...

je kunt ook eens kijken op www.avrbeginners.net , daar staat ook wel wat handige info.

Zal zeker even een kijkje gaan nemen!

[MewBie]

DaNiEl KuNsT schreef op vrijdag 20 januari 2006 @ 23:54:
ik ben er ook net mee begonnen en het is eigenlijk helemaal niet zo moeilijk.
ik heb een paar ATmega32 microcontrollers besteld en ben gaan proberen.

op www.circuitsonline.net staat hoe je zelf een programmer kunt maken voor aan de parallelle poort.
die heb ik in elkaar geknutseld en ik heb eens in de datasheet van de ATmega gekeken wat ie allemaal kan. in het begin snapte ik er niet veel van, maar dankzij madwizard lukt het nu al aardig...

je kunt ook eens kijken op www.avrbeginners.net , daar staat ook wel wat handige info.

Die atmel's kunnen echt een heleboel (net als de 68HC11 die ik voor school gebruik), mijn broertje gebruikt dus atmel chips icm het STK500 ontwikkelboard (zitten ook al ledjes en schakelaars op en er kunnen een heleboel verschillende chips mee geprogrammeerd worden) en het is idd leuk speelgoed

Dat is dus die STK500, daar heb ik vanmiddag de code voor een looplicht (8 verschillende patronen) op zitten maken voor mn broertje, en je kan dan ook mbv een knopje tussen de verschillende patronen schakelen.

De software die beschikbaar is voor die atmel's is ook wel ok, en is vrij makkelijk om mee te beginnen.
Maar zo'n ontwikkelboard kost alleen een paar centjes, die STK is dacht ik 150 euro ongeveer...

Een andere site voor atmel chips is www.avrfreaks.com

[ Voor 4% gewijzigd door MewBie op 21-01-2006 00:08 ]

[Alain]

TheBlasphemer schreef op vrijdag 20 januari 2006 @ 23:25:
Maar hoe begin je met zoiets? je moet naar het schijnt een PIC-programmer hebben, en een PIC kopen (of samplen).

Als je een PIC gebruikt is een PIC-programmer wel makkelijk ja.

Kunnen jullie misschien aanraden hoe je hiermee, het liefst relatief goedkoop, kan beginnen?

Als je nog niet zoveel ervaring met microcontrollers hebt en een mooi development setje wilt hebben, kan ik ethernut aanraden. Het is geen PIC, maar een Atmega128 van Atmel. Je hebt dan een kant en klaar bordje met ethernet, RS232, RS482(/5) en aansluitingen voor de verschillende poorten. Qua software is een OS beschikbaar met TCP/IP stack. (NUT/OS en NUT/NET)

Wat is een leuke PIC, wat voor projectje zou ik daarmee kunnen maken ?

PIC's zijn grappig en doen hun werk. Voor een hobby project zou ik eerder een Atmega nemen. Inspiratie laat ik aan jezelf over.

[kippy]

Die STK-500 bordjes kun je "goedkoop" krijgen via digikey, je moet wel rekening houden dat er nog 20% BTW op komt. Dat was ook mijn probleem toen ik er 15 besteld had....

Maar hoe dan ook zijn ze een stuk goedkoper dan bij farnell of conrad

[madwizard]

Voordeel van AVR is dat ze enorm eenvoudig te programmeren zijn, ze hebben geen hoge spanningen nodig tijdens het programmeren en alle AVRs kunnen dezelfde programmer gebruiken. Mijn oude programmer bestond uit 5 weerstanden en wat connectors:

Het is uiteraard niet de beste programmer maar hij werkt prima. Goedkoper kan bijna niet

Ik kan alleen voor AVR spreken omdat ik nooit met PICs heb gewerkt, maar er zijn zeer degelijke ontwikkeltools voor AVRs die niets kosten. AVR Studio is een goede IDE van de fabrikant (Atmel), volledig gratis maar je kunt geen goedkope programmers gebruiken om je programma direct op het IC te zetten. Dat weerhoud je er verder niet van dit met een extern programma te doen (ponyprog, avrdude), er is alleen standaard in de IDE alleen support voor de officiele programmers (mkII, STK200/500 etc.). Wel een prima simulator en debugger, en sinds kort ook support voor C programma's als avr-gcc geinstalleerd is (en dat is weer open source), inclusief debuggen van de C code (met eventueel de gegenereerde assembler code zichtbaar).

[ Voor 3% gewijzigd door madwizard op 21-01-2006 02:14 ]

[Verwijderd]

Interessant topic
Kan iemand mij in details vertellen wat een microprocessor is? Ik weet het wel in grote lijnen maar voor de rest...

[MewBie]

Verwijderd schreef op zaterdag 21 januari 2006 @ 03:27:
Interessant topic
Kan iemand mij in details vertellen wat een microprocessor is? Ik weet het wel in grote lijnen maar voor de rest...

microprocessor != microcontroller.
Heel simpel gezegd is een microcontroller een mictoprocessor met allerlei I/O porten er aan.
En een microprocessor is in feite een simpele versie van de cpu uit je eigen pc.

[Zjosh]

Ik heb het idee dat je beter met een PIC van microchip kan beginnen. Deze kan je namelijk in ASM programmeren of in c. Ik heb zelf heel even met x86 ASM gespeeld, dit omdat het moest voor school, maar daarna was de stap naar PIC asm heel makkelijk. Je hebt alleen veel minder instructies, je hebt er maar 35 tot je beschikking en hier moet je alles mee doen. ook is de PIC maar 8 bits. Als je asm te moeilijk vind en je door de bomen het bos niet meer ziet, kun je in C de boel gaan programeren, dit kan allemaal in het programma van Microchip en is gratis van internet te halen. Ook programmers zijn er heel veel van te vinden, je kan er 1 inmekaar friemelen voor een paar euro.

[MewBie]

Zjosh schreef op zaterdag 21 januari 2006 @ 11:51:
Ik heb het idee dat je beter met een PIC van microchip kan beginnen. Deze kan je namelijk in ASM programmeren of in c. Ik heb zelf heel even met x86 ASM gespeeld, dit omdat het moest voor school, maar daarna was de stap naar PIC asm heel makkelijk. Je hebt alleen veel minder instructies, je hebt er maar 35 tot je beschikking en hier moet je alles mee doen. ook is de PIC maar 8 bits. Als je asm te moeilijk vind en je door de bomen het bos niet meer ziet, kun je in C de boel gaan programeren, dit kan allemaal in het programma van Microchip en is gratis van internet te halen. Ook programmers zijn er heel veel van te vinden, je kan er 1 inmekaar friemelen voor een paar euro.

De Atmel's kan je ook in C/C++ programmeren, de 68HC11 ook, volgens mij kan je bijna alles in C/C++ proggen

Software voor de atmel is ook gratis, en voor de 68HC11 ook

[ Voor 4% gewijzigd door MewBie op 21-01-2006 12:28 ]

[Verwijderd]

microcontrollers zijn (als je met een redlijk eenvoudig model met niet té veel mogelijkheden begint) niet zo moeilijk. een eenvoudige microcontroller die toch al toelaat om er veel mee te doen is de PIC16F627A van microchip (+-3€ kostprijs, of samplen he ) de programmer daarvoor is redelijk eenvoudig, en kan op zowel een seriele poort, als een parallelle, of zelfs een usb poort.

kwa software heb je dan MPLAB IDE nodig (ontwikkelomgeving) en om de PIC te programeren iets zoals ICPROG (voor thuisgebruik zijn deze 2 programma's gratis dacht ik, ik ben niet zeker)

enigste om op te letten met MPLAB IDE is dat je een stabiele combinatie compiler - IDE moet vinden (kwa versies)

op www.microchip.com is er best veel te vinden (programma voorbeelden) van hun microcontrollers dus... neem eens een kijkje

[Exirion]

Zoals gezegd heeft Microchip een hoop van dat spul. Als je oldschool wil gaan kun je eens kijken naar de Z80 en 8032. Van de 8032 is ook een Basic ROM versie: de 8052. Door de huidige stand van de techniek zijn ze inmiddels wel wat achterhaald.

Wat ik zelf leuk spul vind voor simpel knutselwerk: http://www.rev-ed.co.uk/picaxe/

Voor een paar euro heb je een chipje dat je kunt programmeren zonder flashwerk. Direct aan de PC te hangen en ze kunnen tot aan 600 regels BASIC code bevatten. Er zitten interfacing functies voor remote control sensor in, PWM voor motoraansturing, etc.

Leuk om mee te klooien dus

[_ferry_]

Ikzelf heb een programmer bij conrad besteld voor 40€ geloof ik, van velleman en tevens voorzien van 6 leds en 4 knopjes + software/ Ideel om mee te beginnen Qua info kun je een hoop vinden op circuitsonline en deze site: http://home.versatel.nl/edithenwilliam/william.htm

In het begin kun je ook wat standaard programma's gebruiken en aanpassen naar eigen wens

[Sprite_tm]

Wat je ook kan proberen is aan een AVR Butterfly te komen. Kost je slechts een euro of 20, en je krijgt er een ATMega + LCD + bliepertje + knopjes voor terug, die je door middel van een simpel serieel kabeltje kan programmeren. Als je dat eenmaal snapt is de stap naar custom AVR-projecten vrij klein.

[Verwijderd]

Voor een goede en toch goedkope programmer zoek eens naar de Wisp628 van voti, heb hem zelf ook.

[ Voor 19% gewijzigd door Verwijderd op 21-01-2006 22:39 ]

[darklord007]

een 8051 is ook een hele leuke ucontroller. zit alles in en kunt er een hele boel mee. In de VS zijn er volledige oefenborden te krijgen voor zo'n 114 dollar. mocht je er intresse in hebben kan ik de link nog wel eens proberen te vinden.

[Verwijderd]

Op mijn opleiding ben ik begonnen met van een atmega32 op een STK500 ontwikkelkit. Programmeren gebeurd in c via het programma IAR Embedded Workbench. Dit was mijn eerste ervaring met microcontrollers en het viel me erg mee.

Een ontwikkelkit is echt een aanrader, hiermee kan je heel makkelijk met allerlei hardware op bijv. een breadboardje expirimenteren. Aangezien de STK500 van atmel vrij prijzig is heb ik een STK200 van kanda (kanda.com) aangeschaft. Dit is een kit van ongeveer 75 euro met ongeveer dezelfde features als de STK500. De STK200 word alleen met de bijgeleverde software via de parallelle ipv de seriële poort geprogrammeerd (je bent dus niet afhankelijk van AVR Studio).

[Verwijderd]

Hmz ik ben ook aan het kijken naar een AVR of een PIC zodat ik daar mijn stappenmotor drivers mee kan aansturen via de pc met een RS232 verbining of zo. maa rik heb ook nog nooit iets met microcontrollers gedaan. alleen opschool 2 weken met een 8051 beetje C en ASM. maar dat ben ik alweer vergeten hoe dat moet. Ik ben me dus nog een Beetje aan het oriënteren in de microcontrollers. denk dat het wel verstandig is om met een ontwikkelbord te beginnen.

[Salvatron]

Conrad heeft een PIC-programmer voor 45 euro (of 35 euro als je hem zelf in elkaar zet).
bestelnummer: 191033 71
en zelf in elkaar zetten: 191020 71
En die schijnt dan op de seriële poort aan te moeten worden gesloten.

Ook kun je bij www.circuitsonline.net het schema voor een picprogrammer voor de seriële poort vinden en die doet het goed maar kan geloof ik wel minder PIC's aan en bovendien moet je hem zelf in elkaar zetten en zitten er geen lampjes op. Voordeel is dat die heel goedkoop is en ook simpel in elkaar te zetten.

Om de PIC te programmeren kun je onder andere assembler gebruiken, of bijv. JAL. C zal ook wel kunnen maar dat zou ik niet weten.

En conrad heeft ook de dure c-control te koop. Een microcontroller die in basic te programmeren is met veel functies maar langzaam omdat het basic-programma in de microcontroller wordt geïnterpreteerd.

[DRAFTER86]

Futurlec heeft wel mooie en niet dure ontwikkeldbordjes voor de AVR, meetal zit hier de programmer al op. Helemaal kant en klaar dus.

[RetepV]

darklord007 schreef op zaterdag 21 januari 2006 @ 23:03:
een 8051 is ook een hele leuke ucontroller.

Inderdaad. Maar er zijn al veel geavanceerdere versies van de 8051 in omloop. Flash programmable, 1 clockcycle per instructie (in plaats van 12), etc. etc.

Ik heb zelf laatst een tweetal samples van de 89C51RC2 aangevraagd (en gekregen). In-circuit programmable via een printerpoort adaptertje en gratis software. De 8051 serie bestaat al zo ontzettend lang dat zowat alle software tools gratis te krijgen zijn.

Hij is verder erg simpel te programmeren, hoewel hij wel wat rare dingen heeft (voornamelijk hoe je eventueel extern geheugen adresseert). Ideaal beginners ding imo.

Het voordeel is dat hij in 40-pin DIP verkrijgbaar is, en dat die versie heel veel I/O poorten heeft. Met 5 componenten (excl. voeding) kom je al een heel eind. Je moet wel heel veel I/O mogelijkheden nodig hebben voordat je de I/O moet extenden.

Maar een AVR is ook erg leuk, zou ik je ook aanraden.

Een PIC is volgens mij wat lastiger. Die zijn retesnel, maar de assembly taal is nogal wat beperkter dan die van een 8051 en een AVR. Dan heb je dus een snelle processor, maar als je nog niet zo goed bent in de PIC assembly taal, dan kan het wel eens zijn dat je programma snel inefficient wordt. Volgens mij moet je bij een PIC veel dichter 'tegen de processor aan' programmeren. Dwz. met een PIC moet je goed weten hoe de processor werkt en hoe de assembly in elkaar zit, anders kun je er gewoon geen efficiente programma's voor schrijven.

Maar ik heb nog nooit een PIC geprogrammeerd, dus misschien valt het allemaal wel mee .

[MewBie]

RetepV schreef op dinsdag 24 januari 2006 @ 11:48:
Een PIC is volgens mij wat lastiger. Die zijn retesnel, maar de assembly taal is nogal wat beperkter dan die van een 8051 en een AVR. Dan heb je dus een snelle processor, maar als je nog niet zo goed bent in de PIC assembly taal, dan kan het wel eens zijn dat je programma snel inefficient wordt. Volgens mij moet je bij een PIC veel dichter 'tegen de processor aan' programmeren. Dwz. met een PIC moet je goed weten hoe de processor werkt en hoe de assembly in elkaar zit, anders kun je er gewoon geen efficiente programma's voor schrijven.

Maar ik heb nog nooit een PIC geprogrammeerd, dus misschien valt het allemaal wel mee .

Volgens mij zit er niet veel verschil in snelheid tussen de verschillende uC's, het hangt meer af van wat voor crystal je er aan hangt en hoe je dat ding programmeerd. Als je hem in C programmeerd zal hij idd "langzamer" zijn als dat je hem in ASM programmeerd. Omdat de vertaalslag C -> ASM een hoop rommel opleverd in de ASM code.

[RetepV]

MewBie schreef op dinsdag 24 januari 2006 @ 13:26:
Volgens mij zit er niet veel verschil in snelheid tussen de verschillende uC's, het hangt meer af van wat voor crystal je er aan hangt en hoe je dat ding programmeerd. Als je hem in C programmeerd zal hij idd "langzamer" zijn als dat je hem in ASM programmeerd. Omdat de vertaalslag C -> ASM een hoop rommel opleverd in de ASM code.

Wat ik bedoelde te zeggen is dat op een 8051 (en compatible) de instructieset wat van een hoger niveau is dan die van een PIC. Waar je op een 8051 meestal 1 instructie nodig hebt, heb je op de PIC volgens mij vaak twee of meer instructies nodig.

Maar zoals ik al zei weet ik eigenlijk niet genoeg van een PIC om het zeker te weten.

Overigens, als de C compiler goed optimaliseert, dan kun je er in veel gevallen snellere code mee maken dan als je het met de hand in assembly zou programmeren. Tenzij je de assemblycode helemaal met de hand optimaliseert, maar daar moet je toch al gauw aardig wat ervaring voor hebben...

[madwizard]

De instructieset van AVR is zelfs geoptimaliseerd voor C, ze hebben bewust instructies toegevoegd of weggelaten om het de compiler makkelijk te maken. Voor zover ik weet is de PIC set niet voor C geoptimaliseerd. Mijn ervaring is dat de C compilers het best aardig doen voor de AVR. In veel gevallen zul je niet optimale code nodig hebben, voor het echte diehard optimizen kun je altijd nog delen in assembler doen. Toch is het goed om kennis over en ervaring met de instructieset te hebben, omdat je nou eenmaal toch veel dichter bij hardware programmeert dan op een PC.

[naftebakje]

Over snelheid van PIC's: op een kristal van 8MHz lukt het om een geschakelde voeding (via interne PWM op 8kHz) stabiel te houden en aan te sturen (niet simpel, door de lage freq), terwijl je ook een signaal uitstuurt van 22kHz (telkens bitje toggelen), en ook nog data via I²C zend en ontvangt.
Hoe het zit met andere µP weet ik niet.

Ik heb trouwens de K8048 van velleman, een PIC programmeer en experimenteerbordje, erg handig. Die assembly is trouwens niet noodzakelijk, er circuleren progjes genoeg rond om in C, BASIC, JAL, ... te programmeren. En als je dicht tegen de hardware aan programmeert (interrupts gebruiken voor tijdskritische zaken, niet teveel moeilijke berekeningen doen), is ie bijna even snel in een hogere taal als in assembly (heb het getest met BASIC, voor PWM generatie).

edit: PIC's van de PIC18 reeks zijn geoptimaliseerd voor C, hebben bijvoorbeeld in de 70 instructies (de andere hebben maar 35 instructies, met zijn ervaring in x86ASM moet dat helemaal doodsimpel zijn voor TS), kunnen vermenigvuldigen en delen, en nog wat optimalisaties.

[ Voor 17% gewijzigd door naftebakje op 24-01-2006 14:47 ]

[Ibex]

Mijn eerste ervaringen met een microcontroller was met de PIC 16F628. Op circuitsonline staat er een zeer goede tutorial, waarin staat uitgelegd hoe je de zeer eenvoudige programmer maakt, en hoe je er een basisschakelingetje mee kan maken. Bovendien zijn er van de PIC gratis samples te bestellen op de site van Microchip, de fabrikant van de PIC.
Echter, de ontwikkelomgeving is wat aan de complexe kant en niet echt ideaal voor een beginner.

Mijn huidige ervaring van microcontrollers heb ik opgedaan met de AVR reeks. De ontwikkelomgeving van Atmel, de fabrikant van de AVR, is zeer logisch en handig opgebouwd. De assembler zelf vind ik ook logischer dan die voor de PIC.
Ikzelf heb ervaring met de (verouderde) AT90S8535, welke ondertussen is vervangen door de nieuwere ATmega8535. Deze kost niet zoveel, en heeft een waslijst aan mogelijkheden. Ook de programmer is zeer eenvoudig te maken.

Echter, voor de beginner kan ik toch de tutorial icm met de PIC 16F628 aanraden. Op vlak van instap-microcontrollers aan Atmel's zijde heb ik geen ervaring. Omdat de TS echter al ervaring heeft met de assembler van de x86, welke toch niet van de simpelste is, denk ik dat hij direct naar de ATmega8535 of vergelijkbaar kan gaan .

De url's waren in aanbieding vandaag .

[ Voor 18% gewijzigd door Ibex op 24-01-2006 15:06 ]

[DRAFTER86]

MewBie schreef op dinsdag 24 januari 2006 @ 13:26:
[...]

Omdat de vertaalslag C -> ASM een hoop rommel opleverd in de ASM code.

Je moet toch wel behoorlijk wat ASM kennis hebben wil je het significant sneller hebben dan dat wat de C-compiler produceerd.

Ik heb overigens vandaag mijn eerste regelbare voeding binnengekregen, dus geen gekloot met PC-voedingen en lego-trein-trafos meer
Ga morgen mijn AVR-bordje weer eens uit de kast trekken...

[microchip]

Ik ben een tijdje geleden begonnen met de AVR. Ik moet zeggen dat ik het een hele goed µC vind om mee te beginnen. Er zijn een hoop compilers ervoor beschikbaar. Nu programmeer ik in C en ByteForth (http://www.forth.hccnet.nl, hcc Forth-gg).
Qua snelheid zijn PIC's en AVR's ongeveer even snel, alleen vind ik de asm van de AVR duidelijker. Wat ik meestal doe om te optimaliseren, is een programma schrijven in Forth of C en dan de gegenereerde asm bekijken. Als het beter kan dan probeer ik een andere manier. Maarja, de compiler kan toch beter asm dan ik

[RetepV]

De originele 8051 serie kan op maximaal 12MHz en doet 12 clockcycles over 1 instructie. Je zou kunnen zeggen dat een 8051 op12MHz dus eigenlijk op 1MHz loopt.

De modernere versies lopen op 4 clockcycles per instructie. En Atmel heeft een core AT89LP die op 1 clockcycle per instructie loopt.

De Atmel AVR serie doet volgens mij de meeste instructies in 1 clockcycle. En alle PIC's doen precies 1 clockcycle per instructie.

Dan heb je nog de clocksnelheid. 8, 10, 12, 24, 33, 40, 48MHz.

Dus de snelheid verschilt nog best wel.

[ Voor 22% gewijzigd door RetepV op 29-01-2006 18:17 ]

[DP Kunst]

btj kick, maar dit is wel een topic om niet dood te laten bloeden

ik heb in mijn kast tussen het front en de rest een plaat plexiglas zitten van 7mm dik. hierin komen strax een aantal ledjes te zitten. deze wil ik dan in verschillende standen laten branden:

-alles aan
-looplicht
-enz enz..

maar nou wil ik ook de snelheid van bijv het looplicht bepalen door middel van een potmeter. ik weet alleen niet hoe ik dat moet doen.

het gaat om een ATmega 32. deze heeft iig een AD convertor. die kan ik op verschillende standen instellen (hoe snap ik ook niet helemaal).
heeft iemand een idee hoe ik die potmeter aan moet sluiten, welke waarde ik moet hebben en hoe ik de avr in moet stellen ?

[MewBie]

edit: ging niet helemaal goed

[ Voor 95% gewijzigd door MewBie op 06-04-2006 23:08 ]

[Springuin]

Een potmeter heeft 3 pootjes, daarvan zijn de buitenste twee "vast" en is de middelste de loper. Als je een 10k potmeter hebt en hem helemaal naar links draait is de weerstand tussen het linkse pootje en het middelste pootje 0 en tussen het rechtse en middelste pootje 10k. Zet je hem halverwege dan is het 5k/5k en zo verder.
Wanneer je het linkse pootje aan de gnd vastmaakt en het rechtse aan je +5v dan krijg je een spanningsdeler en is de stand van je potmeter evenredig met de spanning die op het middelste pootje staat. (Let op het is een weerstandsdeling, dus als je er te veel stroom uit trekt dan klopt het niet meer, maar een AD converter doet dat niet.)
Als je dan het middelste pootje met je AD converter verbindt dan kun je met je Atmega32 de waarde uitlezen.
Edit: Je kunt in jou geval prima een 10k lineaire potmeter gebruiken.

[ Voor 6% gewijzigd door Springuin op 07-04-2006 08:11 ]

[naftebakje]

DRAFTER86 schreef op dinsdag 24 januari 2006 @ 18:17:
[...]
Je moet toch wel behoorlijk wat ASM kennis hebben wil je het significant sneller hebben dan dat wat de C-compiler produceerd.
...

Nog es ff aanhalen: het eerste progje dat ik heb geschreven, was vorig jaar op mijn eindwerk. Pure ASM, op een PIC. Ik ben er zeker van dat het in C onmogelijk ging geweest zijn, de stunts die ik heb moeten uithalen om alles snel genoeg te laten reageren .
Als ik het sneller kan, dan moet iedereen het wel kunnen hé.
Maar het is wel zo dat ik nu in Basic schrijf, en door de ASM kennis veel sneller, snelle programma's kan schrijven, ik weet hoe ik het zou schrijven in ASM, en laat dat werk over aan de compiler, maar zet het wel zo goed mogelijk naar de hardware toe.

[M14]

Ik heb nu eens gekeken met welke software ik PIC's kan proggen. Bij de software van Microchip zelf staat wel beschreven dat er met C geprogrammeerd kan worden, maar ik kan nergens een compiler vinden.

Met MPLab krijg ik het alleen voor elkaar om ASM te gebruiken, maar niet C. Met welke compiler gaat dit wel. Waar kan ik die evt. vinden?

[naftebakje]

M14 schreef op donderdag 13 april 2006 @ 15:53:
Ik heb nu eens gekeken met welke software ik PIC's kan proggen. Bij de software van Microchip zelf staat wel beschreven dat er met C geprogrammeerd kan worden, maar ik kan nergens een compiler vinden.

Met MPLab krijg ik het alleen voor elkaar om ASM te gebruiken, maar niet C. Met welke compiler gaat dit wel. Waar kan ik die evt. vinden?

Kijk eens hier, das een heel goeie compiler, in Basic, C en Pascal. De gratis versie werkt tot 2k code, maar dat is zeker genoeg voor de meeste projectjes. Ze hebben ook een eigen forum waar je erg veel kan vinden en snel hulp wordt geboden.

[M14]

Dit pakket ziet er heel interessant uit. Hier ga ik eens mee experimenteren. Als het de moeite waard is, dan ga ik overwegen om het aan te schaffen.

[c0rneel]

Op m'n afstudeerstage heb ik gewerkt met een PIC18F4550 van microchip. Geprogrammeerd en gecompileerd met MPLAB en een MCC18 compiler.

Er loopt momenteel een IA voor de AVR butterfly. een ATmega169 uC. schijnt nog makkelijker te zijn dan een PIC

[Atmoz]

Nu we het toch over PIC's enzo hebben:

Voor een nieuw project wil ik graag met een tijd (klok) gaan werken. Dit in combinatie met een PIC.
De PIC moet op de een of andere manier "weten" hoe laat het is. Ik kan wel timers maken die ongeveer 1 uur ofzo duren, maar dat is niet precies genoeg en zeker niet netjes. Er zullen vast wel IC's zijn die een PIC precies kunnen vertellen hoe laat het is.

Ik zou graag van jullie willen weten wat de beste manier is. Als het maar niet te moeilijk wordt. Met i2c heb ik bijvoorbeeld geen ervaring en SPI ook niet. Zelf had ik in gedachte om de chips die de 7segments aansturen van een wekkerradio uit te lezen. Maar er zullen zeker betere manieren zijn....

Iemand?

[LWY]

Het display van een wekkerradio uitlezen lijkt me nogal omslachtig voor iets wat gewoon met een real-time IC'tje kan. Inderdaad, die werken meestal met I2C/SPI, maar dat hoeft op zich geen probleem te zijn, ook al heb je daar nog geen ervaring mee. Veel van de wat grotere PICs (18F252/452 en 16F876/877A schieten me te binnen) hebben een hardware I2C/SPI poort die heel eenvoudig is te gebruiken.

[ Voor 3% gewijzigd door LWY op 25-04-2006 21:13 ]

[kluyze]

atmoz schreef op dinsdag 25 april 2006 @ 20:12:
[...]

Kant en klare ic's denk ik niet dat er zijn voor een tijd naar een µC te sturen. Als ze wel bestaan dan zitte ze in een wekkerradio.
En die ic's zouden bestaan uit de teller gelijk in een wekkerradio.

7-seg uitlezen zou ik niet doen. Tak het signaal dan af vòòr de 7-seg decoder. Dan heb je het signaal in binaire vorm. Dan misschien eventueel serieel maken, want parallel gaat ge veel IO poorten mogen gebruiken.

[Atmoz]

LWY schreef op dinsdag 25 april 2006 @ 21:12:
Het display van een wekkerradio uitlezen lijkt me nogal omslachtig voor iets wat gewoon met een real-time IC'tje kan. Inderdaad, die werken meestal met I2C/SPI, maar dat hoeft op zich geen probleem te zijn, ook al heb je daar nog geen ervaring mee. Veel van de wat grotere PICs (18F252/452 en 16F876/877A schieten me te binnen) hebben een hardware I2C/SPI poort die heel eenvoudig is te gebruiken.

Ik gebruik altijd/vaak de 18F452. Hier zit idd i2c op, maar ik heb hiermee nog nooit iets gedaan. Maar het zou in princiepe niet zo heel moeilijk hoeven zijn, maar de taal die ik gebruik (JALcc) moet het wel ondersteunen... Morgen eens een kijkje naar nemen.

kluyze schreef op dinsdag 25 april 2006 @ 21:53:
[...]
Kant en klare ic's denk ik niet dat er zijn voor een tijd naar een µC te sturen. Als ze wel bestaan dan zitte ze in een wekkerradio.
En die ic's zouden bestaan uit de teller gelijk in een wekkerradio.

7-seg uitlezen zou ik niet doen. Tak het signaal dan af vòòr de 7-seg decoder. Dan heb je het signaal in binaire vorm. Dan misschien eventueel serieel maken, want parallel gaat ge veel IO poorten mogen gebruiken.

Sorry, beetje verkeerd beschreven. Ik bedoel ook VOOR de decoders Dan heb je inderdaad minder pinnen nodig.

Er moeten toch IC's bestaan die "los" te verkrijgen zijn die tijd kunnen bijhouden...?

[naftebakje]

Ik heb hier een simpel PICje liggen (16F876A) dat via I2C communiceert met een RTC (Real time clock), met name de DS3231S van Maxim.
Zo'n real time clock is wat je zoekt, deze die ik heb heeft een intern kristal, en houd zelfstandig (op de gewone voeding, of als die afligt op een klein batterijtje) de tijd bij. Dat is dus seconden, minuten, uren, dagen, maanden, jaren (schrikkeljaren tot 2100) dat ie automagisch bijhoud. Je kan 2 alarmen instellen, een 1Hz uitgang gebruiken (ledje ) en nog meer (er zit zelfs een temperatuursensor in, die om de zoveel tijd de temperatuur meet en het kristal aanpast, om juister te lopen). Sommige RTC's hebben ook wat EEPROM geheugen, wat soms handig kan zijn.

Ik programmeer met mikroBasic (al heb ik al een volledige I2C master geschreven in assembly, das wel te doen maar véél werk, voor als je PIC/compiler geen master I2C ondersteund), en daarin is het echt piece-of-cake om I2C in gang te krijgen. Het enige probleem was dat die RTC clock-stretching gebruikt (clock lijn laag houden, omdat ie ff geen data kan ontvangen), en dat niet in de datasheet stond. Met gewoon een check of de I2C lijn idle is toe te voegen, was dat opgelost.

[kluyze]

dus toch ... hmm dan was ik mis, het bestaat WEL maar 9/10 doen die hetzelfde als een wekkerradio (met wet extra's voor I²C enz...).
Maar dan heb ik een vraag hierover. Is het niet nauwkeuriger om via de 50Hz van het net te werken ipv met een kristal? Of was juist die 50Hz veel onnauwkeuriger? Zoals de meeste wekkers ed dat doen?

[Reinstein]

De 50Hz van het net is niet zo naukeurig, je kunt beter een kristal gebruiken. Dat moet sowiso icm RTC ic.

Overigens I²C is cool bus systeem zijn veel chips voor, het is niet echt snel, maar simpele communicatie werkt prima.

Als programmer gebruik ik zelf een JDM programmer, schema is zo op internet te vinden. dig is standaard voor 16F84 maar je kunt er zo een verloopje voor solderen zodat er ook andere in kunnen, je hebt nl. 5 pinnen nodig: VCC GND Reset PGC PGD (kun je in datasheet vinden)
Als programeer tool gebruik ik ICprog, en als compiler een PIC C compiler.

* Reinstein bestuurt zn modeltrein via I²C en ethernet (zie sig.)

[ Voor 3% gewijzigd door Reinstein op 26-04-2006 17:17 ]

[JuuL20]

Als ik me niet vergis is de 50Hz van het net erg nauwkeurig hoor.

[naftebakje]

r.l.feenstra schreef op woensdag 26 april 2006 @ 17:17:
De 50Hz van het net is niet zo naukeurig, je kunt beter een kristal gebruiken. Dat moet sowiso icm RTC ic.
......

Het RTC chipje dat ik gebruik (zie vorige post vooor het typenummer) heeft een ingebouwd kristal, je moet alleen voeding, batterij en I2C aanbieden. Er bestaan zelfs RTC's die voorzien zijn van een ingebouwde batterij, die zijn helemaal simpel om te gebruiken.

JuuL20 schreef op woensdag 26 april 2006 @ 17:52:
Als ik me niet vergis is de 50Hz van het net erg nauwkeurig hoor.

De netfrequentie is héél exact juist, over 24 uur bekeken. Er kunnen heel kleine fluctuaties op zitten, maar het gemiddelde wordt exact op 50Hz gehouden (ik dacht zelfs dat ze atoomklokken als referentie gebruiken). Over heel europa loopt die 50Hz trouwens synchroon, in TV's wordt die gebruikt als kloksignaal bij het decoderen van de zenders,... Het is dus zeker een goeie naukeurige tijdsbasis, maar het kan uitvallen, en is niet draagbaar.
Een RTC is de simpelste oplossing, die ook een erg goeie nauwkeurigheid biedt. Wil je zelf de tijd niet meer instellen, dan kan je een draadloos ontvangertje gebruiken die de tijd uitleest die vanuit duitsland verzonden wordt (de naam ontsnapt me) , of je kan een GPS ontvanger gebruiken, die heeft ook een exacte tijdsbepaling (gebruikt om je locatie te bepalen), maar dat zijn duurdere oplossingen, die ik ook minder elegant vind dan een RTC.

[ Voor 12% gewijzigd door naftebakje op 26-04-2006 19:59 ]

[Alain]

Over heel europa loopt die 50Hz trouwens synchroon

Het hoodfnet uiteraard wel, maar achter een transformator is de frequentie wel gelijk, maar zeker niet synchroon.

Het makkelijkste lijkt me idd om een RTC toe te passen. I2C is een erg simpel protocol en is denk ik makkelijker dan een wekkerradio hacken.

[Reinstein]

naftebakje schreef op woensdag 26 april 2006 @ 19:57:
De netfrequentie is héél exact juist, over 24 uur bekeken. Er kunnen heel kleine fluctuaties op zitten, maar het gemiddelde wordt exact op 50Hz gehouden (ik dacht zelfs dat ze atoomklokken als referentie gebruiken). Over heel europa loopt die 50Hz trouwens synchroon, in TV's wordt die gebruikt als kloksignaal bij het decoderen van de zenders,... Het is dus zeker een goeie naukeurige tijdsbasis, maar het kan uitvallen, en is niet draagbaar.

Ik heb idd ook gehoord dat de net frequentie gelijk wordt gehouden, maar daar kun je niet van uit gaan.

In het kader van meten is weten: http://www.tiepie.com/nl/classroom/7/102

Voorbeeld van een meting door een collega verricht. Dit is overigens overdag, dus ik heb geen beeld van wat de frequentie 's nachts is. Maar toch leuk om even te bekijken. Let maar eens op de Duty-cycle en de vorm van de sinus.

[vso]

Misschien een stomme vraag: maar wat zijn nu de grenzen? als ik bv uitga van ethernut 3.0 http://www.ethernut.de/pdf/ethwm30d.pdf te denken.

kan je met een AVR of een Pic het volgende aansturen en uitlezen heb ik er dan 1 of meerdere nodig ?
- ongeveer 20 regelbare Fan's
- ongeveer 20 tempsensors
- 30 knoppen
- lcd scherm
- zooi led's enkel en bi color voor o.a status en andere grappen.
- (edit) een zooi relais)

je hebt met 8 bits heb je 256 mogelijkheden om "aan te sturen" maar hoe zit dat met input ?
Ik heb PLC's geprogameerd waar vaak dit ook gedaan word. daar wordt vaak met stappen gewerkt waar dat is weer een tijdje terug

[ Voor 5% gewijzigd door vso op 27-04-2006 17:57 ]

[lemming_nl]

vso schreef op donderdag 27 april 2006 @ 17:56:
Misschien een stomme vraag: maar wat zijn nu de grenzen? als ik bv uitga van ethernut 3.0 http://www.ethernut.de/pdf/ethwm30d.pdf te denken.

kan je met een AVR of een Pic het volgende aansturen en uitlezen heb ik er dan 1 of meerdere nodig ?
- ongeveer 20 regelbare Fan's
- ongeveer 20 tempsensors
- 30 knoppen
- lcd scherm
- zooi led's enkel en bi color voor o.a status en andere grappen.
- (edit) een zooi relais)

je hebt met 8 bits heb je 256 mogelijkheden om "aan te sturen" maar hoe zit dat met input ?
Ik heb PLC's geprogameerd waar vaak dit ook gedaan word. daar wordt vaak met stappen gewerkt waar dat is weer een tijdje terug

Dat kan zelfs met de aller grootste PIC niet, tenzij je het slim oplost met meerdere dingen op 1 pin en dan met combinaties aangeven wat er moet gebeuren. Maar dan nog is het wel extreem veel voor 1 PIC.

-edit-

Je hebt gewoon niet genoeg pinnetjes, en niet genoeg rekenkracht denk ik maar dat weet ik niet zeker.

[ Voor 8% gewijzigd door lemming_nl op 27-04-2006 19:04 ]

[Verwijderd]

I agree.
Qua timing nagenoeg onmogelijk, zeker als je 20 pwm's en LCD wil gebruiken...

[naftebakje]

Die ingangen (knopjes) en uitgangen (relais) kan je doen met schuifregisters, dat kost je 3 pinnen. LCD scherm neemt 6 pinnetjes. Voor je temperatuursensoren zou ik I2C gebruiken, dus met 2 pinnetjes kan je 20 temperaturen uitlezen (checken bij de chip die je kiest hoeveel verschillende adressen ze kunnen hebben), voor je regelbare fan's zou ik specifieke chip's aan de I2C bus hangen (maxim heeft dacht ik PWM IC's op I2C). Het moet te doen zijn met 11 pinnetjes (toen ik de eerste keer iemand bezig zag om I/O pinnen te besparen, schrok ik ook, hij halveerde zo uit de losse hand het aantal benodigde I/O pinnen).
Je zal wel een "zware" PIC nodig hebben (een kilo lood helpt niet, wel deftig wat ROM en RAM in je PIC), dus je zal ws aangewezen zijn op de 18F.... reeks. En je zal deftig moeten kunnen programmeren.

Je kan natuurlijk ook je probleem wat opsplitsen, wat ik bijvoorbeeld doe met die PWM. Als je zo geen IC vind, dan kan jeeen aparte PIC daarvoor gebruiken.
Bijvoorbeeld een gemeenschappelijke zaagtand genereren (met je PIC een condensator snel op en "traag" ontladen), en 20 RC netwerkje's gebruiken op 20 uitgangspinnen van die PIC, waarmee je dus een analoge referentiewaarde maakt. Je gebruikt dan 20 comparator's, die hun aparte referentiewaarde vergelijken met de gemeenschappelijke zaagtand. De uitgang van elke comparator is dan een PWM signaal, dat netjes kan ingesteld worden door de PIC.


Dus je ziet, het is zeker mogelijk om een oplossing te vinden voor een complex probleem, maar je moet het kunnen in aparte stukken opsplitsen, en wat slim omgaan met alles. Begin met een klein stukje, en bouw langzaam verder, gooi er steeds meer bij. Gaandeweg zal je zelf begrijpen wat haalbare en wat overdreven eisen zijn, en ondertussen ben je braaf
Het is volgens mij zeker te doen om alles in 1 PIC te krijgen, maar dan haal je je wel wat op je nek (haalbaar voor mij is iets anders dan haalbaar voor jou, en haalbaar voor een professionele PIC designer is nog iets heel anders). Om het jezelf gemakkelijk te maken, splits je alles best op.
(ik heb in mijn eindwerk in een PIC een programma gekregen dat eigenlijk absoluut onhaalbaar was, vooral op de lage klokfrequentie. Maar tis gelukt, met veel zwoegen, dus jij moet het zeker ook kunnen, het was mijn eerste contact met µP)

Die ethernut die je daar toont, is wel een racemonster in vergelijking met PIC's of AVR's. Tis een totaal andere architectuur, en kan véél sneller rekenen, zo op het eerste zicht. Probleem is alleen dat het programmeren ervan dikwijls ook navenant veel moeilijker/ingewikkelder wordt.

[ Voor 23% gewijzigd door naftebakje op 27-04-2006 20:11 ]

[enermax]

Als je echt binnen no time dingetjes wilt maken. Binnen 2 dagen kan je motortjes draaien lcd's aansturen enz. www.Picbasic.nl

[Verwijderd]

Kijk eens op www.inkoopacties.net, daar kun je goedkoop aan butterfly's komen met diverse extra's zoals een carrierbordje, experimenteersetje etc..

Inkoopactie duurt tot 1 mei, dus even snel bestellen

Butterfly is later ook te hergebruiken als programmer en zelfs als jtag als ik mij niet vergis.

Gewoon super

[ Voor 3% gewijzigd door Verwijderd op 27-04-2006 20:58 ]

[vso]

naftebakje schreef op donderdag 27 april 2006 @ 20:03:
Die ingangen (knopjes) en uitgangen (relais) kan je doen met schuifregisters, dat kost je 3 pinnen. LCD scherm neemt 6 pinnetjes. Voor je temperatuursensoren zou ik I2C gebruiken, dus met 2 pinnetjes kan je 20 temperaturen uitlezen (checken bij de chip die je kiest hoeveel verschillende adressen ze kunnen hebben), voor je regelbare fan's zou ik specifieke chip's aan de I2C bus hangen (maxim heeft dacht ik PWM IC's op I2C). Het moet te doen zijn met 11 pinnetjes (toen ik de eerste keer iemand bezig zag om I/O pinnen te besparen, schrok ik ook, hij halveerde zo uit de losse hand het aantal benodigde I/O pinnen).
Je zal wel een "zware" PIC nodig hebben (een kilo lood helpt niet, wel deftig wat ROM en RAM in je PIC), dus je zal ws aangewezen zijn op de 18F.... reeks. En je zal deftig moeten kunnen programmeren.

Je kan natuurlijk ook je probleem wat opsplitsen, wat ik bijvoorbeeld doe met die PWM. Als je zo geen IC vind, dan kan jeeen aparte PIC daarvoor gebruiken.
Bijvoorbeeld een gemeenschappelijke zaagtand genereren (met je PIC een condensator snel op en "traag" ontladen), en 20 RC netwerkje's gebruiken op 20 uitgangspinnen van die PIC, waarmee je dus een analoge referentiewaarde maakt. Je gebruikt dan 20 comparator's, die hun aparte referentiewaarde vergelijken met de gemeenschappelijke zaagtand. De uitgang van elke comparator is dan een PWM signaal, dat netjes kan ingesteld worden door de PIC.

<knip --> ff wat tekst weg anders wordt mijn quote te lang

ik snap wat je wilt zeggen, maar begrijpen is punt 2
Je helpt me geweldig uit de brand want ik zat echt te pijnzen hoe ik dit netjes via 1 systeem zou kunnen doen is wel netter dan alles direct op een pic/avr

Ik zat zelf te denken aan een modulair systeem wat via een byte bereikbaar was en dan via 1 kanaal uit te lezen. maar dat is denk ik moeilijker, teminste je moet in mijn idee het als volgt zien

code:

1) d.m.v logische poorten het kanaal open zetten m.b.v 1 byte 
(de waarde die het kanaal heeft bepaald de actie van het aangesloten apparaat)
2) dan de huidige waarde (terug) laten sturen 
3) de huidge waarde aanpassen (of niet)
4) d.m.v logische poorten het kanaal dicht zetten m.b.v 1 byte

Wat ik vermoed is dat het eigenlijk heel erg matriaal intensief is, als ik per aan te sturen eenheid ga werken ik moet de grens vinden waneer en waar het beter is te stoppen met seriele communicatie en over moet gaan op parallele communicatie, ik denk niet dat ik ontkom aan een multilayer PCB teminste als ik niet teveel draadbruggen wil hebben, maar ja dat kost ook weer wat meer.

Die ethernut die je daar toont, is wel een racemonster in vergelijking met PIC's of AVR's. Tis een totaal andere architectuur, en kan véél sneller rekenen, zo op het eerste zicht. Probleem is alleen dat het programmeren ervan dikwijls ook navenant veel moeilijker/ingewikkelder wordt.

Die ethernut heeft als extra funtie dat ik het ipv een laptop moet dedicaten een webservertje kan laten draaien op de ethernut en dus meer directer invloed kan hebben. (denk aan dat je via een webbrowser direct waardes kan aanpassen remote) De knoppen die ik bedacht heb die erbij komen die moeten eigenlijk via een interrupt signaal werken waardoor direct een actie gebeurt, afhankelijk van de module moet er ook een interupt gestuurd kunnen worden. (temp te hoog ofzo)

In mijn optiek is progammeren niet moeilijk, je idee moet alleen helder en duidelijk wezen. ik werk meestal als volgt

code:

1) interface voor eindgebruiker 
2) knop/menu defenitie
3) per knop een actie diagram uitzetten 
4) software schrijven

Dit houdt het modulair en veranderbaar/overzichtenlijk en je hebt documentatie bijdehand, ik zit nu tussen stap 3 en 4 met mijn gedachten.

Echter voor dit project zit ik met veel waardes die in een register geschreven moeten worden.
Aan of Uit is het probleem ook niet. met 8 bits kan je 128 apparaten bedienen (theorie)
Het is harder of zachter waar ik mee zit en de eventuele controle daarvan, misschien moet ik bv niet per RPM toeren dus + 100 toeren per min/sec erbij of er af dus gradaties
me temperatuur uitlezen: hoe vaak per sec, hoeveel maximaal uitleesbaar?

PLC controlle is een beetje te duur maar zelf bouw is weer een stuk goedkoper

[naftebakje]

vso schreef op vrijdag 28 april 2006 @ 00:41:
[...]
denken aan een modulair systeem wat via een byte bereikbaar was en dan via 1 kanaal uit te lezen. maar dat is denk ik moeilijker, teminste je moet in mijn idee het als volgt zien

code:

1) d.m.v logische poorten het kanaal open zetten m.b.v 1 byte 
(de waarde die het kanaal heeft bepaald de actie van het aangesloten apparaat)
2) dan de huidige waarde (terug) laten sturen 
3) de huidge waarde aanpassen (of niet)
4) d.m.v logische poorten het kanaal dicht zetten m.b.v 1 byte

Dit snap ik niet helemaal. Wil je dan een temperatuur uitlezen, de desbetreffende FANsnelheid aanpassen aan die temperatuur, en naar het volgende koppeltje fan-tempsensor? Daarvoor kan je best de gewenste waarde in het EEPROM geheugen zetten, na elkaar als lookup table. Maak dan een loopje, dat gewoon telkens de juiste temperatuur uitleest, vergelijkt met de wenswaarde, en de FANsnelheid aanpast. De sensor/snelheid/wenswaarde wordt bepaald met een variabele, die je in je loopje van 0 naar 20 laat gaan.

Voor die fansnelheid, je kan 256 waarden in een byte steken (érg veel). Gebruik je een nibble (4 bits), dan kan je 16 waarden kiezen (dat voldoet misschien). Maar wees niet bang voor de opslag, µP met 321 RAM bytes (en evenveel EEPROM bytes) zijn gewoon courant te krijgen, daar past dat allemaal in.

[ Voor 13% gewijzigd door naftebakje op 28-04-2006 08:50 ]

[Atmoz]

Als ik een infrarood code wil sturen met een microcontroller dan moet ik "iets" doen met een 40Khz draaggolf. Deze kan ik maken doormiddel van PWM, maar ik vraag me af wat ik hiermee moet?

Het signaal zelf bestaat uit 12 bits (SONY afstandsbediening). Maar moet die draaggolf over die code heen ofzo?

[naftebakje]

atmoz schreef op vrijdag 28 april 2006 @ 17:54:
Als ik een infrarood code wil sturen met een microcontroller dan moet ik "iets" doen met een 40Khz draaggolf. Deze kan ik maken doormiddel van PWM, maar ik vraag me af wat ik hiermee moet?

Het signaal zelf bestaat uit 12 bits (SONY afstandsbediening). Maar moet die draaggolf over die code heen ofzo?

Tis zoals ik dacht, je gebruikt die draaggolf om te voorkomen dat achtergrondlicht (zon ofzo) als signalen begrepen wordt. Je zend wel/niet die 40KHz (gewoon op de IR led zetten), en door de tijd dat je wel/niet die 40kHz uitzend, zend je een '1' of een '0'. Google legt het je nog eens fijn uit.

[Verwijderd]

@ naftebakje: respect man, die oplossing voor PWM had ik ammenooitniet opgekomen...
Zoals jij het opdeelt moet het idd nog haalbaar zijn, als je dankbaar gebruik maakt van interrupts.

Eindwerk secundair heb ik ook met PIC gedaan, leerkracht had er zelfs nog nooit van gehoord.
Volledig geprogrammeerd in JAL, een robot spin volledig zonder interrupts.
Als ik die code nu zie schaam ik me dood en wordt driedubbel misselijk

[naftebakje]

Verwijderd schreef op vrijdag 28 april 2006 @ 21:11:
@ naftebakje: respect man, die oplossing voor PWM had ik ammenooitniet opgekomen...
Zoals jij het opdeelt moet het idd nog haalbaar zijn, als je dankbaar gebruik maakt van interrupts.

Eindwerk secundair heb ik ook met PIC gedaan, leerkracht had er zelfs nog nooit van gehoord.
Volledig geprogrammeerd in JAL, een robot spin volledig zonder interrupts.
Als ik die code nu zie schaam ik me dood en wordt driedubbel misselijk

Je moet gewoon bijleren, en durven iets anders proberen. Die oplossing voor PWM heb ik gedeeltelijk gestolen (in het RGB moodlight topic komt dat id, maar de referentie gebeurt via een potmeter), en gedeeltelijk verzonnen (analoge waarde maken als referentie), beter goed gestolen (en gecombineerd) dan slecht verzonnen.
En ik ben ook maar een simpel studentje electronica, dat na 3 jaar hoger (graduaat, dus bachelorniveau) nog ff door probeert te gaan voor ingenieur, maar van de 12 klasgenoten zijn er nog 2 een beetje bezig in hun vrije tijd met electronica, de rest slingert daar ook maar aan.

Voor dat opdelen in blokken heb ik nog een tip: speel een autist. Geen enkel inlevingsvermogen met de omgeving, wat je niet snapt doet je flippen. Dat is een µP, vanuit dat begrip moet je zoeken naar losse stukjes, die naast elkaar kunnen bestaan. Eenmaal je dat beet hebt, kan je gemakkelijk (het gaat steeds beter, als je het meer doet) een complex probleem opentrekken tot een hoop simpele zaken die je gewoon aan elkaar knoopt, en de meest onbegrijpelijke dingen kan laten doen.

[Verwijderd]

Me too, binnen 2 maand mag ik -hopelijk- mijn diploma bachelor elektronica -ICT ophalen. Je studeert toevallig toch niet in St-katelijne waver he

[naftebakje]

Verwijderd schreef op zaterdag 29 april 2006 @ 11:15:
Me too, binnen 2 maand mag ik -hopelijk- mijn diploma bachelor elektronica -ICT ophalen. Je studeert toevallig toch niet in St-katelijne waver he

Nope, PIH te kortrijk.

[Verwijderd]

Hey mensen ik hoor hier wel een hoop verhalen over 8051/pic/atmel etc.. maar is er ook iemand die ervaring heeft met TI-MSP430?

Tis volgens mij een hele leuke microcontroler met de nodige periferie. Vervolgens is i netals atmel ( AVR?) te programeren via JTAG.

Zie ook http://focus.ti.com/mcu/d...cm/mcuovw/data/msp430_ovw

Ik heb er al wel een (MSP430F167) in een projectje gebruikt (PCB heb ik al ontworpen en geetst)

Alleen moet ik de boel nog proggen dus ik vroeg mij af of er iemand was die al (goeie) ervaring heeft en waar ik op moet letten met deze controller en IAR kickstart/TI CCE-430 (de ontwikkelomgeving, die laatste schijnt te integreren te zijn met Eclipse, je weet wel die java ontwikkel omgeving die ooit van IBM was).

[naftebakje]

Verwijderd schreef op zondag 30 april 2006 @ 09:43:
Hey mensen ik hoor hier wel een hoop verhalen over 8051/pic/atmel etc.. maar is er ook iemand die ervaring heeft met TI-MSP430?

Tis volgens mij een hele leuke microcontroler met de nodige periferie. Vervolgens is i netals atmel ( AVR?) te programeren via JTAG.

Zie ook http://focus.ti.com/mcu/d...cm/mcuovw/data/msp430_ovw

Ik heb er al wel een (MSP430F167) in een projectje gebruikt (PCB heb ik al ontworpen en geetst)

Alleen moet ik de boel nog proggen dus ik vroeg mij af of er iemand was die al (goeie) ervaring heeft en waar ik op moet letten met deze controller en IAR kickstart/TI CCE-430 (de ontwikkelomgeving, die laatste schijnt te integreren te zijn met Eclipse, je weet wel die java ontwikkel omgeving die ooit van IBM was).

Dat ziet er een erg leuk chipje uit, en nog goedkoop ook (20$ voor een ontwikkelbordje ). Ik heb er wel geen enkele ervaring mee (ik zit op school, daar lopen ze 20 jaar achter), maar tziet er een leuk dingetje uit. Waar je wel naar moet kijken, is de haalbaarheid van het programmeren. Kijk of er een goedkope/gratis compiler is voor dat chipje, in een taal die je beheerst/kan leren.

[Verwijderd]

@naftebakje die CCE-430 die ik al aangaf kan in ASM (soort van 8051 instructieset) en c compilen en is tot 8KB gratis. Nou vind ik C wel handig maar het meeste doe ik nog in assembly dus voor ik die 8KB vol heb heb ik blauwe vingers van het tikken.

die kickstart is ook gratis (c en assembler) maar "slechts" tot 4 kb.

[ Voor 3% gewijzigd door Verwijderd op 30-04-2006 13:01 ]

[vso]

naftebakje schreef op vrijdag 28 april 2006 @ 08:47:
Dit snap ik niet helemaal. Wil je dan een temperatuur uitlezen, de desbetreffende FANsnelheid aanpassen aan die temperatuur, en naar het volgende koppeltje fan-tempsensor?

Nee ik wil 1 I/O paar dus 2 pinnetjes op een microcontroller gebruiken voor alle apparaten die geen interrupts genereren. en een X aantal moeten via die 1ne paar uitgelezen kunnen worden dus over de output van de controller die stuurt dus constant, <apparaatcode><opdracht>, <apparaatcode><opdracht> etcetra.

blackbox met 1x in en 1x out + mod(ule aansluiting)
in:
- Zit op output van microcontroller
- Dus ik heb voor 1 apparaat een black box die de een apparaatcode heeft een het commando doorstuurt,
out:
- Zit op input van microcontroller
- De black box die stuurt ook een signaal op verzoek terug met het juiste apparaatcode erbij <apparaatcode><antwoord>
mod
- Hierop gaat een module die aan de hand van een <opdracht> iets doet. Dit kan van alles zijn.

Die losse modules die je op de blackbox aansluit, die zetten daad werkelijk de fan aan, schakelen het toerental v.d fan, noem maar op. die blackbox is dus alleen maar een doorgeef luik.

Hierdoor kan ik meer dan genoeg apparaaten aansturen

atmoz schreef op vrijdag 28 april 2006 @ 17:54:
Als ik een infrarood code wil sturen met een microcontroller dan moet ik "iets" doen met een 40Khz draaggolf. Deze kan ik maken doormiddel van PWM, maar ik vraag me af wat ik hiermee moet?

Het signaal zelf bestaat uit 12 bits (SONY afstandsbediening). Maar moet die draaggolf over die code heen ofzo?

Tis zoals naftebakje reageert de IR 40khz signaal is niet echt relevant alleen je IR ontvanger moet het wel kunnen "zien" (DUH)

zie deze link http://www.xs4all.nl/~sbp/knowledge/ir/ir.htm,

ik heb het zelf gedaan met RC5(philips remotes) ik baal alleen dat ik er niks meer van heb, ik weet dat de emulatie software c.q software op de controler niet echt boeiend is en met zo'n remote kan je heel heel veel apparaaten bedienen. teminste als je er zelf 1 maakt je eigen universele remote maken is ook niet echt moeilijk

leuk detail, de oude palm series III, kon je m.b. van de juiste software al elk appraat bedienen bereik was alleen 1,5 meter verving je de IR led met een betere dan kon je bereik tot 5 t/m 10 meter verhogen wat leuks was voor jou, voor je buren met de dezelfde tv was het pech

[naftebakje]

@vso: Je moet eens kijken naar I2C of dergerlijke protocollen (onewire, SPI,...). I2C werkt met een I/O draad (SDA) en een clock draad (SCL), en een master/slaves systeem. De master start de communicatie naar een slave, door zijn adres te zenden (7 bits of 10 bits adres, laatste bit bepaalt of de data van master naar slave gaat, of omgekeerd).
Als je bijvoorbeeld een master-PIC maakt (LCD, status LED's, communicatie met buitenwereld), en een slave-PIC-printje met wat knopjes op om het adres in te stellen. Aan die slave kan je dan hangen wat je wil, en netjes vanuit de master aansturen. Je kan gewoon extra apparaten op die I2C-bus inprikken, dat werkt gewoon (maximale lengte is niet gespecificeerd, wel een maximale capaciteit, met een paar meter houd het wel op, tenzij je er een exteder aan hangt).

Door je protocol wat op te bouwen kan je alles erg handig houden, je kan bijvoorbeeld bij het opstarten op alle adressen vragen wat ze kunnen (temp lezen, fan aansturen,...), komt er geen antwoord dan zit er niets op dat adres. Wel antwoord is bijvoorbeeld een byte voor te lezen temperaturen (elke bit die '1' is, is een tempsensor), enzovoort. Dan nog wat verzinnen hoe je wil die specifieke temperatuur wil opvragen of die specifieke fan wil in snelheid instellen.
Tis ff uitzoeken hoe je alles wil, en netjes opschrijven, maar eenmaal het een beetje op zijn poten begint te vallen gaat het enorm vlug, laat je dus niet ontmoedigen omdat je 5 keer de datasheet moet lezen, zo heb ik ook moeten beginnen (niet dat ik nu erg ver sta).

[ Voor 6% gewijzigd door naftebakje op 01-05-2006 10:40 ]

[vso]

naftebakje schreef op maandag 01 mei 2006 @ 10:30:
Tis ff uitzoeken hoe je alles wil, en netjes opschrijven, maar eenmaal het een beetje op zijn poten begint te vallen gaat het enorm vlug, laat je dus niet ontmoedigen omdat je 5 keer de datasheet moet lezen, zo heb ik ook moeten beginnen (niet dat ik nu erg ver sta).

Ik laat me ook niet ontmoedigen met jou antwoorden kan ik bouwen wat ik voor ogen heb teminste ik zal nog wel veel struikel dingetjes tegenkomen denk ik.

Als je iets maakt, maak het eerst af / werkend .. wis delete alle bestanden die je nodig hebt/had en begin daarna helemaal opnieuw werkt het daarna in 1 keer dan snap je het en zal het nog beter zijn dan je eerste. Is het dan nog niet goed genoeg ? --> delete en werk het opnieuw uit

[ Voor 5% gewijzigd door vso op 01-05-2006 17:08 ]

[Verwijderd]

Kent iemand ook de 68HC11 microcontroller en eventueel op een SIMPLEX 3 boardje van Elomax? en hoe die dingen geprogd worden?

[Verwijderd]

met een atmega kan je vrij makkelijk 20 fans aansturen ,, moet je alleen uitgang gaan schakelen via timer ... zoveel pwm uitgangen hebben de meeste niet

[Yoram]

*Kick*

Ik wil me graag ook eens wagen aan microcontrollers. Nu is er een ia met wat van die dingen. Dus wil ik er een paar aanschaffen, om wat uitteprobeeren.
Ik heb dit topic hier en daar doorgelezen en er wordt steeds een PIC of een Atmel aangeraden, en er zijn ook nog verschillende types. dus nu ben ik de weg kwijt.
Ik heb een beetje ervaring met elektronica, maar het progameeren moet ik dus nog allemaal leren.
Welke microcontrollers raden jullie mij aan, om mee te beginnen. ?
ik zat er aan te denken om te beginnen met een looplichtje of iets in die richting.

[Rowwan]

Een ATMega is fantastich voor beginners en gevorderden. Op E-bay zijn regelmatig complete opstellingen (bordje + Programmer) te koop voor tussen 30 - 40 EUR. (Zoek maar eens op "ATMega progammer")

[naftebakje]

Voor het beginnen is het zowiezo nodig je door de datasheet te worstelen, om de instellingsregisters te vinden en te weten hoe ze te gebruiken. Ik denk niet dat er daarin enig verschil zit tussen PIC en AVR.
Persoonlijk ben ik meer fan van PIC (omdat ik daar mee begonnen ben), anderen zijn begonnen met AVR (omdat zij daar mee beginnen zijn), uiteindelijk maakt het niet veel uit.
Voor goedkope programmer en µC kan ik je www.voti.nl aanraden, 5€ verzendkosten maar erg goedkoop in vergelijking met de winkels hier in de buurt.

Als je het onderliggende systeem van de µC kent (door in ASM aan de slag te gaan), kan je overstappen naar een gemakkelijker programmeertaal, die jou een hoop werk uit de handen neemt. Persoonlijk ben ik grote fan van mikroelektronica, ze hebben basic compilers voor PIC en AVR, en érg mooie development boards met on-board programmer en alles erop en eraan voor een heel mooie prijs (221.77€ voor compiler (levenslang update's) + development board: grafisch en karakterLCD), daar koop je anders enkel een compiler voor. Hun forum zit vol met duidelijke uitleg over vanalles, er zitten mensen op die alle kneepjes van het vak met plezier met je delen, ook de ontwikkelaars van de software geven alle uitleg over de (vlot komende) volgende versie's.

[ Voor 43% gewijzigd door naftebakje op 25-08-2006 10:16 ]

[kluyze]

Voor de eerste stappen is het misschien ook handig om eens op CO te kijken. Ze hebben daar een aantal tutorials waarmee je in µC programming kunt komen.

Tutorials:
- Beginnen met AVR
- Beginnen met PIC

[Fuzzillogic]

Ik kwam langs deze Cubloc development bordjes. Het "onboard" breadboard lijkt me wel praktisch. (Zo'n zin in solderen heb ik vooralsnog niet) Ook de onderkant is tenminste afgschermt, dus dat je het ding ergens kwijtkunt zonder bang te zijn dat dat schroefje dat er lag mooie rookeffectjes gaat veroorzaken. Maar ik kan niet zo 123 een leverancier hier in de EU vinden (invoerrechten, yadayada). Iemand enig idee of hier in de buurt iets soortgelijks te vinden is?

[StapelPanda]

Hoi, ik ben net begonnen met PIC'tjes, en wil wat meer dingen kunnen maken:
zo ben ik ongeveer begonnen (assembly):

• ledje laten knipperen,
• ledje met PWM en potmeter
• rij van acht ledjes, van links naar rechts, overnieuw, en snelheid natuurlijk weer te regelen
• rij van 8 ledjes van links naar rechts en weer terug, natuurlijk met a2d erin
• legorobotje, en beetje laten rondrijden ( niet mee doorgegaan, ontwerp van robot was niet geweldig, wou haast geen bochten maken)

Lcdtje wou niet werken, en erna een DCF77 C51 uit proberen te lezen (natuurlijk lcd nodig om tijd op te laten zien). C51 heeft trouwens een ander tijdformaat: Meinberg timestring.
maar vanaf de lcd wou het niet werken, rs232 ook niet (zie niks op de scoop), dus zit ik erover te denken om C te gaan doen, nu de vragen: is het slim om al op c over te stappen?, heeft iemand een betere assembly tutorial dan http://www.mstracey.btinternet.co.uk/pictutorial/picmain.htm?
tutorial moet hetliefst ook over rs232 enz gaan, dus niet alleen wat BTFSS is en doet.

Michiel

ps: ik heb de application meastro ook al geprobeerd, kwam niet veel soeps uit...

[ Voor 6% gewijzigd door StapelPanda op 30-08-2006 15:33 ]

[Zjosh]

Op de site van microchip heb ik een keer een powerpoint presentatie gevonden waar piekfijn in word uitgelegd hoe je rs232 moet configureren. Mail voor de pps

[Ricvdp]

Nou je hem mss kunnen uploaden? Ik heb ook wel interesse om eens te zien..

[Zjosh]

Ik heb zelf geen opslag ruimte, maar als het goed is zet iemand anders hem wel online

edit: Gieltjev zet hem online als ik het goed begrepen heb

[ Voor 26% gewijzigd door Zjosh op 30-08-2006 21:12 ]

[Ricvdp]

Reclame maken mag vast niet, maar rapidshare.de does the trick. Wel eerst even comprimeren.

[StapelPanda]

Sorry voor mijn late post, en mijn eigenwijsheid om het niet op rapidshare te zetten.
http://picprojects.awardspace.com/usart.pdf

ik moet het zelf nog bekijken, maar het ziet er veelbelovend uit.

Michiel

[Verwijderd]

Sorry om deze oude thread weer even op te rakelen, maar ik heb een vraag die hier wel bij past.. Bedankt voor dit topic overigens, ik heb hier al een heel aantal nuttige referenties gevonden.

Anyway, voor een project zijn wij van plan een basic elektrisch circuitje met een aantal elektroden, comparators en wat relais te maken en sturen via een microcontroller, en het laatste is een nogal diepe 'leap in the dark' voor mij.

Mijn vraag is welke van die drie architecturen die hier vooral besproken zijn (8051/AVR/PIC) het best geschikt is voor communicatie met een pc. Het zou de bedoeling zijn dat we een letter/getal intypen op pc en dat doorgeven aan de microcontroller die dan elektroden aanstuurt. Die elektroden zijn in contact met een kopersulfaatoplossing, waardoor via redoxreacties het koper zou moeten neerslaan & draadjes vormen in de vorm van de ingegeven letter.

Nu van wat ik van een paar dagen googlen heb geleerd verloopt communicatie met de pc via een terminal program & een seriele poort connectie.
Voor de PIC heb ik hier gezien dat er een hele troep connectors en nog een palmpilot tussen de pc en de controller moeten. Is dit nog steeds zo (wegpage is nogal outdated) of is er ondertussen een iets handigere manier?
Voor de AVR/8051 *denk* ik dat gewoon een RS232 seriele kabel al zou volstaan? Klopt dit? Als dit zo is, is het dan ook mogelijk om die controllers zonder programmer te programmeren, zoals ik meen te herinneren ergens gelezen te hebben? (Het zou wel kunnen zijn dat het daar over een bepaald type development board ging.)

Kan iemand mij overigens een goed terminal program aanraden?

Bedankt!

[Thijsch]

@WIM:

Van de 8051 heb ik geen verstand dus daar kan ik niets over zeggen naast dat het geen handige beginners uc is.

Er zit in het serieel communiceren eigenlijk geen verschil tussen pic en avr. Het is niet zo dat je zo een seriele kabel op de avr kan aansluiten. RS232 maakt van hele andere spanningen gebruik dan een pic of avr dus die moeten geconverteerd worden (meestal door een max232, zeer eenvoudig). Software matig is het een eitje op beide sytemen, en óók vrijwel hetzelfde. Een waarde naar een register schrijven en een paar bitjes hoog maken.

Er zit qua complexiteit in het communiceren met de seriele poort geen verschil tussen avr en pic! Voor jouw toepassing maakt het niet uit welk ding je kiest, het zal allebei functioneren!

Zelf werk ik voor de hobby al een paar jaren met PIC's en voor school nu met AVR's... Ik kan je zeggen: eigenlijk zit er geen verschil in, alles heeft zo zijn voor en nadelen! (Het héle grote pluspunt van atmel vind ik de gratis C compiler maar dat is het enige, ik prog toch in asm)

Als je voorbeeld code voor de pic moet hebben moet je het maar zeggen.. ik heb een paar standaard routines gemaakt die ik zo in mijn code plak als ik ze nodig heb

[ Voor 25% gewijzigd door Thijsch op 14-10-2006 15:28 ]

[naftebakje]

Voor simpele projectje's ga je idd best kijken naar de AVR/PIC familie, 8051 is ingewikkelder.
Zowiezo moet je je door de datasheet worstelen, na 5 keer lezen ben je ermee vertrokken, trek je er niets van aan dat je de eerste keer er niet teveel van snapt, dat komt wel bij de volgende keer lezen.

Seriële communicatie is op bijna elke processor gelijk, aangezien ze ongeveer allemaal een UART ingebouwd hebben, dat is een stuk hardware die seriëel verzenden/ontvangen voor jou doet. Aangezien PIC en AVR op TTL-niveau werken ('1' is 5V, '0' is 0V), en op RS232 andere spanningen worden gebruikt ('1' is -3 à 12V, '0' is +3 à 12V), wordt een IC'tje gebruikt om dat te vertalen, doorgaans de MAX232 volgens dit schema:

Nog een tip IVM je projectje: zoek eens op wat de ASCII-tabel is, die ga je nodig hebben.

Ik programmeer trouwens met MikroBasic, die is gratis tot 2K code, daar krijg je al het een en ander in, en het programmeert heel wat sneller dan in pure ASM.

[ Voor 8% gewijzigd door naftebakje op 14-10-2006 16:03 ]

[Verwijderd]

@Paradot: Wel die zou zeker welkom zijn ! Dat is precies wat ik irritant vond aan de meeste tutorials die ik vond over de 8051. Ze gaven altijd maar losse commando's, en amper samenhangende voorbeelden.

Ik denk dat we dan voor de pic zullen gaan, in dit topic heb ik er in ieder geval al een goeie beginnertutorial voor gevonden.

Zou je die voorbeeldcode dan kunnen doormailen naar [e-mail] aub?

Thanks!

@naftebakje: Bedankt voor de tip & uitleg. Ik had al een vermoeden dat ASCII erin voor zou komen.

[ Voor 11% gewijzigd door Verwijderd op 14-10-2006 15:53 ]

[Fuzzillogic]

Heeft iemand ervaring met Arduino, of kan aan de hand van de website een oordeel vellen? Het is een open systeem, met een open (gratis) cross-platform ontwikkelomgeving, met een op Java gebaseerd scripttaaltje. Een kant-en-klaar bordje kost rond de €25.

[MewBie]

ATmega's zijn gewoon te programmeren in C/C++ en assembly, waarom een of ander scripttaaltje gebruiken dat op Java gebaseerd is?

edit: even verder gekeken naar dat "scripttaaltje", dat is gewoon C waar ze een library voor gemaakt hebben om het voor beginners wat makkelijker te houden.

Neem bijvoorbeeld:

code:

/* Basic Digital Read
 * ------------------ 
 *
 * turns on and off a light emitting diode(LED) connected to digital  
 * pin 13, when pressing a pushbutton attached to pin 7. It illustrates the
 * concept of Active-Low, which consists in connecting buttons using a
 * 1K to 10K pull-up resistor.
 *
 * Created 1 December 2005
 * copyleft 2005 DojoDave <http://www.0j0.org>
 * http://arduino.berlios.de
 *
 */

int ledPin = 13; // choose the pin for the LED
int inPin = 7;   // choose the input pin (for a pushbutton)
int val = 0;     // variable for reading the pin status

void setup() {
  pinMode(ledPin, OUTPUT);  // declare LED as output
  pinMode(inPin, INPUT);    // declare pushbutton as input
}

void loop(){
  val = digitalRead(inPin);  // read input value
  if (val == HIGH) {         // check if the input is HIGH (button released)
    digitalWrite(ledPin, LOW);  // turn LED OFF
  } else {
    digitalWrite(ledPin, HIGH);  // turn LED ON
  }
}

Dit is gewoon puur C en is in winAVR naar mijn idee nog veel makkelijker.
HIGH is gewoon een andere definitie van de waarde 1 en LOW is waarde 0.
digitalWrite is een functie die pinnetje "ledPin" 1 of 0 maakt.
digitalRead is gewoon een functie die de status van een pinnetje inleest.

[ Voor 86% gewijzigd door MewBie op 03-01-2007 23:49 ]

[naftebakje]

Dat bordje op zich lijkt me wel te doen voor 25€, en als ik het zo zie kan je ook het printje zelf etsen enzo, documentatie staat allemaal op die site.
Wil je met AVR's beginnen, en lijkt die gebruikte programeertaal je wat, gewoon doen, eenmaal je met een µC hebt gewerkt wil je er alles mee doen

[ReLight]

Ik ben ook net begonnen met AVR's etc en digitale controllers, na de velleman k8055 IO board (om meer over io digitaal te leren) nu een leuke eerste hobby robotje van Arexx, hier zit diezelfde ATMega8 op.

Als ik Arduino eerder had gezien had ik die gekocht denk ik, voor 25,- kan je je niet echt een buil vallen. Ik zou er wel een paar van die shield pcb's bij kopen indien mogelijk, altijd fijn om goed passende boards te hebben met connectors.

[ Voor 0% gewijzigd door ReLight op 04-01-2007 12:05 . Reden: typo ]

[Verwijderd]

Ik lees hier nogal veel kritiek op de 8051...

Persoonlijk ben ik begonnen met Microchip (lijkt al wel een eeuwigheid geleden) in Jal, later overgestapt op assembler, en uiteindelijk op school bij 8051/8052 terecht gekomen.

En ik kan maar 1 ding zeggen, ik gebruik nog steeds Pics, als ik niet veel meer wil doen dan wat ledjes laten knipperen...
Goed, het is RISC, en er zijn minder commando's te kennen, maar je hebt wel al gauw 3 keer zoveel code nodig om hetzelfde te doen met een 8051.
Klein stom voorbeeld, PIC heeft slechts 1 interruptvector (ok, de 18F reeks heeft er 3 ofzo, maar dan nog.. ) dus moet je als je meerdere interrupts gebruikt elke flag afgaan en zelf zorgen voor prioriteitsafhandeling ed.
Nog zo eentje, als je bij pic een pin hoog wilt maken en nadien uitlezen moet je zelf nog het TRIS register setten/resetten, terwijl dat bij 8051 niet nodig is.

Nu goed, zo kan je eeuwig blijven doorgaan, ben nu zelf bezig met inverse kinematica en ik twijfel sterk om over te stappen naar een ARM voor floating point berekeningen, maar ik wou toch even vermelden dat 8051 zeker geen slechte stap voor beginnelingen is...

Last but not least, er zijn redenen dat de 8051 al een 25-tal jaar bestaat hoor

[IJnte]

Verwijderd schreef op donderdag 04 januari 2007 @ 19:40:
Ik lees hier nogal veel kritiek op de 8051...

Persoonlijk ben ik begonnen met Microchip (lijkt al wel een eeuwigheid geleden) in Jal, later overgestapt op assembler, en uiteindelijk op school bij 8051/8052 terecht gekomen.

En ik kan maar 1 ding zeggen, ik gebruik nog steeds Pics, als ik niet veel meer wil doen dan wat ledjes laten knipperen...
Goed, het is RISC, en er zijn minder commando's te kennen, maar je hebt wel al gauw 3 keer zoveel code nodig om hetzelfde te doen met een 8051.
Klein stom voorbeeld, PIC heeft slechts 1 interruptvector (ok, de 18F reeks heeft er 3 ofzo, maar dan nog.. ) dus moet je als je meerdere interrupts gebruikt elke flag afgaan en zelf zorgen voor prioriteitsafhandeling ed.
Nog zo eentje, als je bij pic een pin hoog wilt maken en nadien uitlezen moet je zelf nog het TRIS register setten/resetten, terwijl dat bij 8051 niet nodig is.

Nu goed, zo kan je eeuwig blijven doorgaan, ben nu zelf bezig met inverse kinematica en ik twijfel sterk om over te stappen naar een ARM voor floating point berekeningen, maar ik wou toch even vermelden dat 8051 zeker geen slechte stap voor beginnelingen is...

Last but not least, er zijn redenen dat de 8051 al een 25-tal jaar bestaat hoor

8051 is idd een goede begin processor. Ik ben er zelf ook mee begonnen (aka Bitsim). Moesten we assembler voor kloppen.. Maar het maakt niet zo heel erg veel uit welke processor je pakt in het begin. Het gaat om een methode die je aanleert om met een uP te kunnen werken. Als je een bepaald doel voor ogen hebt, dan kies je een processor, maak je een software flowchart en dan ga je programmeren. De taal die je daarvoor kiest is afhankelijk van de complexiteit en de beschikbare hoeveelheid geheugen. Heb je genoeg geheugen: C, heb je zeer weinig geheugen (zoals een PIC) dan ga je voor assembler. Asm is wel wat lastiger om te leren maar als je het eenmaal begrijpt dan weet je ook hoe je hardware van je processor in elkaar zit (asm is echt gericht op hardware aansturing).
Als je een doel voor ogen hebt en je weet wat je wilt maken dan moet je voor jezelf alleen de goede weg uitstippelen om te kijken wat je nodig hebt en hoe je het doel gaat bereiken (onderzoek naar verschillende processoren, programmeertalen, externe hardware, flowcharts, etc).

Een ARM is een zeer leuke processor, waar je zeer veel mee kan doen. Heeft een goede interrupt vector machine en heeft voldoende i/o pinnen voor normale applicaties. Heeft SPI aan boord en ook nog I2C. Ook een uart ontbreekt niet. De nieuwe LPC2129 van NXP is trouwens 2x zo snel als andere fabrikanten van de ARM7 microcontrollers. Ook het feit dat de processor 32-bits is (intern sommige delen 64-bits, lpc2129 zelfs 128bits geloof ik) maakt het rekenen ermee prettig. Er is ook genoeg over de ARM te vinden en dat maakt het werken met de processor voor een beginner ook ideaal. Alleen simpele applicatie test bordjes om mee te spelen zijn vaak wel duur.

[LiquidSmoke]

Ik heb hier een aantal 16f628a's liggen, onderdelen voor een progger besteld, breadboardje erbij e.d.

Nu zag ik op CO een dobbelsteen, lijkt me wel een leuk beginproject.

Via google zijn ook nog wel wat projectjes te vinden, maar vaak zonder duidelijke uitleg (gewoon code downloaden en proggen die hap).

Ergens wat tut's over de beginselen van het programmeren of leuke projectjes met beschrijving hoe en waarom?

[flux_w42]

Deze site is wel duidelijk.

Als je gewoon eens zou googlen op 'PIC tutorial'of op '16f628 tutorial' raak je al wat verder.

[ Voor 20% gewijzigd door flux_w42 op 05-01-2007 13:04 ]

[Sprite_tm]

IJnte schreef op vrijdag 05 januari 2007 @ 12:19:
[...]

8051 is idd een goede begin processor. Ik ben er zelf ook mee begonnen (aka Bitsim). Moesten we assembler voor kloppen.. Maar het maakt niet zo heel erg veel uit welke processor je pakt in het begin. Het gaat om een methode die je aanleert om met een uP te kunnen werken. Als je een bepaald doel voor ogen hebt, dan kies je een processor, maak je een software flowchart en dan ga je programmeren. De taal die je daarvoor kiest is afhankelijk van de complexiteit en de beschikbare hoeveelheid geheugen. Heb je genoeg geheugen: C, heb je zeer weinig geheugen (zoals een PIC) dan ga je voor assembler. Asm is wel wat lastiger om te leren maar als je het eenmaal begrijpt dan weet je ook hoe je hardware van je processor in elkaar zit (asm is echt gericht op hardware aansturing).

Mmm, imo is de 8051-assembly-taal niet zo orthogonaal als die van bijvoorbeeld de AVR of ARM; bovendien heeft de 8051 vaagheden wbt. de verschillende typen ram enzo die bij beginners voor verwarring kunnen dienen. Ik zie de 8051-architectuur persoonlijk als een legacy-iets: als je er qua hardware, software of kennis in geinvesteerd hebt is er nog wel spul voor te krijgen, maar als newb zou ik toch een modernere proc pakken. Als je het in C (of een andere hogere taal) wilt programmeren gaat dat trouwens niet op; dan zijn de meeste procs wel goed te doen en moet je eigenlijk alleen kijken naar welke proc de gewenste eigenschappen heeft voor jouw project.

Een ARM is een zeer leuke processor, waar je zeer veel mee kan doen. Heeft een goede interrupt vector machine en heeft voldoende i/o pinnen voor normale applicaties. Heeft SPI aan boord en ook nog I2C. Ook een uart ontbreekt niet. De nieuwe LPC2129 van NXP is trouwens 2x zo snel als andere fabrikanten van de ARM7 microcontrollers. Ook het feit dat de processor 32-bits is (intern sommige delen 64-bits, lpc2129 zelfs 128bits geloof ik) maakt het rekenen ermee prettig. Er is ook genoeg over de ARM te vinden en dat maakt het werken met de processor voor een beginner ook ideaal. Alleen simpele applicatie test bordjes om mee te spelen zijn vaak wel duur.

Klopt. Zeker de nieuwere LPC2103s zijn heerlijk om mee te spelen: goedkoop (E6.25 bij http://www.voti.nl maar ik heb bij buitenlande shops al prijzen van E3 of minder gezien) en nog wel enigszins zonder duur experimenteerboardje te gebruiken (als je aan de PLCC-versie kan komen is het helemaal makkelijk maar met dunne draadjes is TQFP48 ook nog wel te solderen, en anders kan je nog altijd een tqfp-adapter-printje halen) en je hebt geen programmer nodig door de ingebouwde bootloader. Daar krijg je dan een hele leuke 70MHz ARM voor terug; iirc is dat zelfs snel genoeg om mp3tjes softwarematig te decoden.

[IJnte]

Sprite_tm schreef op vrijdag 05 januari 2007 @ 13:41:
[...]

zou ik toch een modernere proc pakken. Als je het in C (of een andere hogere taal) wilt programmeren gaat dat trouwens niet op; dan zijn de meeste procs wel goed te doen en moet je eigenlijk alleen kijken naar welke proc de gewenste eigenschappen heeft voor jouw project.


[...]

Klopt. Zeker de nieuwere LPC2103s zijn heerlijk om mee te spelen: goedkoop (E6.25 bij http://www.voti.nl maar ik heb bij buitenlande shops al prijzen van E3 of minder gezien) en nog wel enigszins zonder duur experimenteerboardje te gebruiken (als je aan de PLCC-versie kan komen is het helemaal makkelijk maar met dunne draadjes is TQFP48 ook nog wel te solderen, en anders kan je nog altijd een tqfp-adapter-printje halen) en je hebt geen programmer nodig door de ingebouwde bootloader. Daar krijg je dan een hele leuke 70MHz ARM voor terug; iirc is dat zelfs snel genoeg om mp3tjes softwarematig te decoden.

Ik vindt altijd het gevaar van een hogere programmeertaal voor beginners dat ze te snel resultaat boeken en daardoor niet stilstaan bij de interne opbouw van de processor. Een taal als assembler leert een beginner zeer veel over de hardware van de processor, omdat als je de taal asm gebruikt je in de datasheet moet bladeren om het te kunnen programmeren Als je een OO programing language gebruikt zitten er vaak al een hele zut standaard library's bij die je simpel hoeft te knippen en plakken en daarna even een functie aanroepen. Dat leert je niets over de processor zelf. Ik heb de PIC, ARM en 8051 geleerd door eerst ASM te gebruiken en daarna de taal C. Java etc heb ik nooit gebruikt omdat je nooit exact weet wat de compiler voor statements er van maakt. M.a.w. je weet niet wat die allemaal met je geheugen uithaald.

De ARM is idd niet al te duur. Voti.nl is van een docent van de HU (zit ik toevallig op). Mijn docent heeft ook een aantal ARM demobordjes gemaakt waar ik bij mijn opleiding gebruik van maak. Daar zitten de simpele dingen zoals een display, knopjes en ledjes e.d. op. Bordje koste iets van 36 euro met kabeltjes etc erbij Er komt een nieuwe versie uit met SD kaart houder erop. Bied perspectieven

[StapelPanda]

IJnte schreef op vrijdag 05 januari 2007 @ 14:13:
[...]

Ik vindt altijd het gevaar van een hogere programmeertaal voor beginners dat ze te snel resultaat boeken en daardoor niet stilstaan bij de interne opbouw van de processor. Een taal als assembler leert een beginner zeer veel over de hardware van de processor, omdat als je de taal asm gebruikt je in de datasheet moet bladeren om het te kunnen programmeren Als je een OO programing language gebruikt zitten er vaak al een hele zut standaard library's bij die je simpel hoeft te knippen en plakken en daarna even een functie aanroepen. Dat leert je niets over de processor zelf. Ik heb de PIC, ARM en 8051 geleerd door eerst ASM te gebruiken en daarna de taal C. Java etc heb ik nooit gebruikt omdat je nooit exact weet wat de compiler voor statements er van maakt. M.a.w. je weet niet wat die allemaal met je geheugen uithaald.

De ARM is idd niet al te duur. Voti.nl is van een docent van de HU (zit ik toevallig op). Mijn docent heeft ook een aantal ARM demobordjes gemaakt waar ik bij mijn opleiding gebruik van maak. Daar zitten de simpele dingen zoals een display, knopjes en ledjes e.d. op. Bordje koste iets van 36 euro met kabeltjes etc erbij Er komt een nieuwe versie uit met SD kaart houder erop. Bied perspectieven

Assembly moet je alleen heel veel geduld mee hebben in asm lukte rs232 niet, maar in C al na 3 keer, omdat je dan niet hoeft te twijfelen of je code verkeerd is. het bleek dat er ook nog een ANSELH was, die de rx pin analoog maakte nu zal het me waarschijnlijk ook wel lukken in ASM

terwijl je in c niet hoeft te proberen om een vga signaal te maken, daarvoor heb je preciese timing nodig.

[ Voor 3% gewijzigd door StapelPanda op 05-01-2007 16:39 . Reden: stukje toegevoegd ]

[IJnte]

Gieltjev schreef op vrijdag 05 januari 2007 @ 16:38:
[...]

Assembly moet je alleen heel veel geduld mee hebben in asm lukte rs232 niet, maar in C al na 3 keer, omdat je dan niet hoeft te twijfelen of je code verkeerd is. het bleek dat er ook nog een ANSELH was, die de rx pin analoog maakte nu zal het me waarschijnlijk ook wel lukken in ASM

terwijl je in c niet hoeft te proberen om een vga signaal te maken, daarvoor heb je preciese timing nodig.

Mjah das gewoon een programmeerfoutje in asm De UART bij de ARM is erg eenvoudig. Data in een register zetten en de ARM zorgt zelf voor afhandeling
Idd met C hoef je niet te proberen een tijd nauwkeurig proces te besturen, mits je precies weet wat er gebeurd en hoeveel instructiecycles het precies kost. Met ASM heb je dat zelf in de hand.