Alright, welcome to this tutorial, we are actually going to be introducing what we call
the Simple Microcontroller Series.
This is a series that was thought up by Sergey, one of our awesome engineers, and he always
loves a challenge.
So he was thinking, how can we learn more about microcontrollers, and then show how
much impressive stuff you can do using the simplest microcontroller possible?
So that was his dream.
And he's the one behind these tutorials, and he did all the writing stuff.
So like, all the tutorials that we do, we have this video.
And then we have our tutorial on CircuitBread.com
So if you want to go over it in a different pace, or you want to have a slightly different
perspective on it, it's a great way to learn it a little bit more in depth.
So with these super simple microcontroller tutorials, we're going to show how you can
do the more basic, light up an LED, or line following robots, or a robot that you can control remotely,
stuff like that, all with one of the most simple microcontrollers available.
So one of the benefits of doing this, and one of the reasons we want to do this is because
we are are so used to Arduino and we're so used to all of these awesome tools that make
it a lot easier, which is great, but we sometimes miss what's going on at the lower level.
So by doing this, we're going to go down to the lowest level of interfacing with a microcontroller
to show what's going on with the registers and what's going on with the code and what
is exactly happening to give you the results that you want.
So even though this is going to be very simple, and we're going to try and make it as easy
as possible, if you do have a background in electronics, just your typical power, ground,
resistor, all that sort of stuff, and the basic understanding of Boolean algebra,
basically digital logic and how that works.
And it's going to go a long way to helping you with this.
Again, I don't think it'll be necessary, but it will definitely help you and maybe make
it so you can only go through the tutorial once and be good to go, versus having to go
through it once or twice or three times to be like, Ah, now it finally makes sense.
So we're going to be using a microchip PIC10F200.
And the reason we chose this microcontroller is because it is extremely simple.
It's one of the most basic microcontrollers that we could find.
It's also extremely cheap, like this DIP package is a little bit over 50 cents.
And if you get a surface mount package, then you're looking at more like a quarter
or less for these things in units of one.
And now of course, if you get thousands or 10s of thousands, they get even cheaper.
So that's one of the reasons we like these.
And also, like I mentioned, there's different packages for the so this is the DIP, which
we like to use, because it's a lot easier to use with a breadboard.
But if you want to actually integrate this into a smaller, more streamlined unit, and
design your own PCB and stuff like that, you can use the SOT 23 packages, which are absolutely
tiny, and still give you the full functionality of this DIP8 package.
And just to give you an idea of how much smaller and simpler this is - this microcontroller,
you can only have 256 words of flash memory.
So you can only really execute 256 commands, whereas with an Arduino Uno, which is really
quite simple, it has 32,000 or 32K of flash memory.
So that is a huge difference.
And that shows you exactly how simple this thing is you yet with this will still be able
to make remote control robots, and other cool things, which we'll get to in later tutorials.
As part of doing this part of the simplicity, we're actually going to do our code in assembly
which can strike fear into some people.
But we're going to keep it very simple.
And one of the benefits of assembly is again, not only do you learn at a lower level what's
going on here, so it's a great learning/ training tool.
But it's actually very efficient, you can save a lot of code space, and it runs faster,
because there's not a lot of extraneous commands going on that are put in by other compilers.
For example, if you were to use an Arduino to do an LED Blinky program, it would use
almost a kilobyte of programming space to just blink an led on and off.
Whereas you can do that same thing in assembly for about 15 words.
So again, just an order of magnitude (or two!) difference in how much space it uses.
So that's one of the awesome things about assembly.
And again, assembly.
It's not something a whole lot of people use anymore.
And we don't expect you to use this commercially or anything like this.
But it's really great for understanding what's going on underneath everything.
So you get a more intuitive sense of how a microcontroller works.
And one thing I do want to say just to make it very clear, this is not an anti-Arduino
thing. Yes, Arduino aren't as efficient, they're a lot bigger, they're a lot more expensive.
But they are amazing for doing quick prototypes.
And just getting stuff done.
We love them, we use them all the time, we use them in a lot of our tutorials.
So don't get that impression whatsoever.
This is not a replacement.
This is a help with the understanding of what's going on.
So with that, let's talk about what our next steps are.
This is just an introduction to what our intent is with this series.
But next steps are we are going to talk about the conceptual ideas that we need to understand
in terms of the hardware, setting up the circuit, as well as the conceptual ideas of what's
going on inside the microcontroller, the registers, the I/Os, and how they all work like back
and forth.
So we're going to get more into that over the next couple tutorials as well as going
over some of the basics of the assembly language, so that when we start getting into the codes,
it's not just completely throwing you off.
And that's it.
Once we do those things, conceptual ideas and kind of lay that foundation, we're going to
go immediately into doing more exciting projects where we're turning on LED blinking LED, again,
just robots, because who doesn't like to make something that moves around back and forth?
So that's what we're going to get to eventually.
And that will be the culmination of this tutorial is having those robots that can do really
powerful things with a very, very simple microcontroller.
So we hope you enjoyed this video.
Hopefully you enjoyed this introduction and it gets you excited for the tutorials that
are going to come to explain more about how we can do amazing things with a simple microcontroller.
If you liked this video, give it a like and subscribe to our channel.
We'll catch you later.