"Alan" (
z378reply@blueyonder.co.uk) writes:
> <somuchbadkarma@gmail.com> wrote in message
> news:3043d647-1fd4-49fd-a06b-0993c0030562@s37g2000prg.googlegroups.com...
>> So here is the deal, I'm a self taught computer nerd and wish to mess
>> around with small electronics and microcontrollers. I can already
>> write ASM, C, JAVA, and BASIC with C and ASM under GNU/LINUX being my
>> preferred languages. Seems I'd be in luck with the uC because ASM and
>> C are pretty common from the looks of things, I have however a dilemma
>> and I was hoping to find some help from the wisdom of others.
>
> Hi I expect some other people may remember the heated discussions about 20
> years ago,
> about which CPU was best - Z80, 6502, 6800 etc. etc. - we are still waiting
> for an answer

)
>
And thirty years ago, everyone was pretty much starting out. Except for
those with previous computer experience, anyone getting a home computer
was not only learning about their given CPU, but about how to program and
if they were hooking it up to something external, how to do that hardware
and control the interface.
Coding is coding, and once you've picked that up, translation is relatively
easy. Being able to imagine an end product and make it come to pass is
another skill that is transferable.
But "learning about microcontrollers" is a move to hardware in a way that
many that are used to computers nowadays haven't experienced.
My first computer, a KIM-1 back in 1979, was great for such things. It
had a good monitor, so not only could I enter programs without having
to program something (or else create a bootstrap ROM without any experience
with programming) and it allowed me to single step and see how the
instructions operated or set interrupt points so I could run a bit of
code and then stop to see results. It had hardware built in so if I wanted
to play with some LEDs or something else it was realy easy to attach them,
and then play in the software to control them.
And those things are still important, likely more important than which CPU
(and unless the original poster is going to use a 16bit CPU for this project,
any CPU he chooses will be different from what he's used to, unlike the old
days when you picked a CPU for often vague reasons, and used it for everything
because it was more or less as good as anything else, and about the "top of
the line" anyway).
Of course, in the old days there were articles about bootstrapping a CPU.
About 1980, Byte ran an article about bootstrapping an 8085, adding
some hardware so it would single step and jamming the databus with NOPs (I
think it was) so the address bus would advance and then one could load
RAM with the desired code (via some circuit board pads and a stylus). Because
of the bootstrapping method, and because the bootstrapping hardware was
simple, you could toss it all together with scraps. I later saw the same
basic concept described in Dr. Dobbs for the 68000. You didn't even need
an eprom programmer or eraser, added things that were some sort of obstacle
for playing on that level.
I'm sure that sort of thing could be done today if desired, though I don't
have the date of the Byte article handy. The simple circuitry to get things
going is a way of getting started with hardware, which often is needed
when using a micrcontroller.
But it is that controlling ot the external hardware that's important in
the learning process. To make liitle bits of circuitry that can be
controlled, and then play with the software to control them. Nowadays,
many don't have that experience, even though they may be writing software,
and modern operating systems tend to isolate the hardware from the software.
You don't have to fiddle with a driver for that serial port, but then you
don't have the experience at controlling the uart.
Michael