uC vs. uP

Ik ben laatst toch maar weer 's de elektronica ingedoken, na enige tijd van stilte. Ik heb nog een paar onderdelen liggen waarmee ik de computer opnieuw mee wil uitvinden eigenlijk. Dus zelf een OSje schrijven, dat soort dingen. Nou vroeg ik me alleen af wat nou slimmer was om te gebruiken, een uC of een uP. Een uC heeft natuurlijk als voordeel dat alles in een zit, je processor, je geheugen, je flash etc. Maar een uP heeft natuurlijk als voordeel juist weer dat er niks in zit, je kunt alles vervangen en heel makkelijk uitbreiden. Je kunt er zo geheugen bijplaatsen, je EEPROM uitbreiden, je kunt zelfs je processor vervangen zonder het hele systeem opnieuw te hoeven programmeren. Zoals je wel kunt zien vind ik de processor wel interessant, MAAR. De processor is denk ik moeilijker te programmeren, daarmee bedoel ik dus dat de programmer voor een EEPROM aanzienlijk lastiger is te bouwen dan een programmer voor een AVR (1 ICtje). Ook weet ik nog niet zo heel veel van de processor af, en iets meer van de AVR. Dus, wie helpt mij in dit dilemma :)

als je nu een AVR neemt waar de bus ook extern aanwezig is, kan je ook makkelijk externe dingen aansluiten...

Je kan denk ik een C64/MSX achtige home/game-computer namaken met een enkele microcontroller. De snelheid is al vele malen hoger en geheugen ook. Een C64 draaide op 1 MHz en had maar 64k RAM geheugen (geen EEPROM, geen Flash, bestond destijds nog niet) Video signaal opwekken kan ook met een microcontroller, ook input zoals toetsenbord / muis / joystick / MIDI (via UART) is allemaal mogelijk.
Geen simpele opgave ;(

Nou, er is (bedenk ik me net), nog een probleem. Ik heb namelijk een stuk of 4 serieele apparaten die ik er aan wil hangen. Een serieel beeldscherm (misschien zelfs twee), een serieel toetsenbord, en een serieele muis. Deze zijn allemaal async, en bijna alle AVR's (en PIC's) hebben maar 1 UART. Nou zou je de TX en RX wel apart kunnen gebruiken voor beelscherm en muis, maar daar houdt het mee op... Ik weet niet precies hoe dat zit met processors, zoals ik al eerder zei heb ik me daar nog niet in verdiept...

Je kunt alle dingen die je wilt ook extern aan een microcontroller hangen. Een externe adresbus maakt dat wel een heel stuk eenvoudiger.

Als je veel seriële poorten wilt hebben, kun je gewoon extra UARTS aansluiten of UARTS simuleren in software, dat is met een processor niet anders dan met een microcontroller.

En als je een AVR of PIC toch wat beperkt vind, kun je altijd een 68000 Dragonball of een ARM nemen. Dat zijn ook microcontrollers met ingebouwd geheugen, maar helemaal 32-bit en meestal met een ingebouwde 10/100MB ethernetinterface.

De ATMega32 (waarvan ik er twee heb liggen) heeft helaas geen externe adresbus, en maar 2k SRAM. Ik denk ook niet dat ik heel veel meer nodig zal hebben, omdat het toch een DOS-style OS gaat worden. Maar ik heb wel door dat dit een project gaat worden wat nog wel eventjes gaat duren ;)

je kan ATmega's aan elkaar koppelen via de I2C bus die erop zit, kun je daar niet ook geheugen aanhangen. Laa tik zo zeggen, bij de ATmega 8 gaat dit prima

er bestaan ook UART's die via SPI aansluitbaar zijn. Je moet maar eens zoeken op het forum van avrfreaks, heb daar enkele dagen geleden iets van gelezen

Als je geen ingebouwde adresbus hebt, moet je gewoon 2 poorten bombarderen tot adresbus en 1 tot databus. En als je 3 poorten te veel vind, kun je ook werken met bijvoorbeeld 1 poort en 2 latches (zoals een 74HC573), die je daarop aansluit. En op die latches sluit je de adreslijnen van alle andere chips aan.

Je hebt ook nog wat stuurlijnen nodig.

Om dan een byte naar een andere chip te schrijven, zet je eerst de ene helft van het adres op de AD poort en zet je de stuurpin die op de ALE van 1 van de latches staat even aan en uit. Doe daarna hetzelfde voor de tweede latch. Je hebt dan het 16-bit adres op de uitgangen van de latches staan.

Dan zet je de data op de poort en de pin die op de WE ingang van het doel-IC zit laag, dan wordt de data door dat IC ingelezen. Lezen gaat op dezelfde manier.

Die latches kun je ook gebruiken voor het bufferen van de stuursignalen, zodat je in totaal maar 12 IO pinnen nodig hebt (RD, WR, ALE, 1 Chipselect en 8 algemene bits). Je kunt voor het adres natuurlijk zoveel latches nemen als je wilt. Met 4 latches kun je 4 Gigabyte adresseren.

Alles serieel doen kan natuurlijk ook en bespaart je een hoop IC's (alhoewel een latch maar ongeveer 1 Euro kost), maar dat is erg traag.