Welcome to the RaspberrySTEMTM Projects Guide!
The goal of the RaspberrySTEMTM is to provide a step-by-step roadmap to learning the key principles of programming and electronics, and this guide is that roadmap. You're probably ready to just jump right in (and we're ready too!), but before we get started, we wanted to offer a few notes and thoughts on how to make the best use this guide and the RaspberrySTEMTM kit. Some of these things won't make sense just yet (they will when we jump into the projects), so if something below doesn't make sense right now, you can skip over it now and refer back here as necessary.
We've made every attempt to make this Projects Guide completely self-contained, self-explanatory and FUN! We realize that learning programming and electronics can be a difficult (and sometimes frustrating) process, and our goal with the RaspberrySTEMTM kit (and this guide) is to make the process as simple as possible. That said, both programming and electronics are subjects where the basics can be learned very quickly, but at the same time, you can spend a lifetime mastering them. Everyone learns differently and at different rates -- some people will be able to move quickly through each project in this guide, and some will want to spread out the learning process over weeks or months -- and it's important that you work at your own pace and do what's comfortable for you.
While you’re welcome to skip around this guide as you please, if you have no previous experience with programming or electronics, we recommend that you read and follow the projects in this guide in the order in which they’re presented. The guide is designed to build on itself, and skipping sections may make it difficult to fully understand later concepts and projects in the guide. The small projects early in the guide eventually build into larger -- and MORE FUN -- projects later in the guide.
Within
the projects, and especially towards the beginning where there is a lot
of important introductory information, we will have included sections
called "Understanding" sections. These are sections of
additional information
that,
while not absolutely necessary to understand and complete the projects,
will contain good information to help you better understand the basics
of programming, electronics and how to use the RaspberrySTEMTM
kit. This is what an Understanding section looks like, and
this
example also contains some information you should read:
WHAT IS PROGRAMMING?
Programming is the process of writing instructions for a computer to follow. You write these instructions using an editing tool (we provide a custom one as part of the RaspberrySTEM, and then "send" those instructions to the the computer to carry out (or "execute"). Just like there are lots of different languages that people can speak, there are also many languages that computer instructions can be written in -- each of which will ultimately be converted into a format that the computer understands.
The RaspberrySTEM supports many different programming languages, but we will primarily be focused on one of the most common, called Python. Python is a versatile language that is used in both the academic and the professional world to build a varied set of applications and tools. Learning how to program in the Python programming language will provide a solid foundaiton for all future programming education.
WHAT IS ELECTRONICS?
Electronics is the study and building of circuits that rely on various types of components, including wires, computer chips and other common electrical devices. Through the study of programming and electronics, you can learn where these two areas collide, often referred to as "embedded systems" or "consumer devices." By combining programming and electronics, we can design and build games, tools and devices that can solve real world problems, as well as provide entertainment and ultimately make life easier and more convenient.
Because a large portion of this guide will be used to teach programming, we wanted to provide some conventions on how we would demonstrate the code you would be writing. Because code can be very finicky -- you have to space things the right way, capitalize things correctly, etc. -- it's important for you to know exactly what the code should look like. For that reason, we have put all the code snippets (a cute term for several lines of code) in their own special boxes. They will look like this:
In
some code boxes, you'll see line numbers included to the left of the
code. We'll discuss this more later, but in the window where
you'll be typing in your code, line numbers will automatically be
included. When we put line numbers along with the code, this
is
simply for you to use as a reference to ensure that you can more easily
type in your code correctly. It's also a good way for us to
discuss the code -- we just need to mention the line number(s) and
you'll know what code we're talking about. Here's an example
of
what a code box with line numbers might look like:
There will be many instances where we will provide a snippet of code in a project, and you'll want to type in exactly as we displayed it. But, this might require a lot of typing or you may want to ensure that you don't type things incorrectly. For that reason, we provide the ability for you to "cut-and-paste" code right from this project guide into the window where you'll be writing your code. We'll provide an example of how to do this in Project #1, but we wanted to mention it so you can look for the instructions.
With some programs you write, there will be
"output" from your code. Output is just a fancy word for
information that your code spits back out at you, either because you
told it to or because there was a problem with your code that the
computer wanted to let you know about. There is a place in
our
development window where output will be displayed, and in some
projects, we'll want to let you know upfront what output you should
expect. When we want to show you what output to expect, we'll
provide an output box that might look a little something like this:
This is where we will display the output...
Just
like with the programming side of things, for the electronics, we'll be
providing a couple different ways to demonstrate exactly how you build
the projects on your RaspberrySTEMTM kit.
We'll
introduce these conventions in the first few projects, but we wanted to
say upfront that every step of the building process will be provided
and hopefully you'll have no problem following along with the guide.
Now that we've sufficiently bored you with this introduction,
it's
time to jump into the hands-on stuff! The next topic we'll
discuss is this how to use this development environment, and after
that, we'll jump right into the projects...