Thames & Kosmos Code Gamer Experiment Manual

EXPERIMENT MANUAL

620141-03-090816

Franckh-Kosmos Verlag s-GmbH & Co. KG, Pfizer str. 5-7, 70184 Stuttgart, Germany | +49 (0) 711 2191-0 | www.kosmos.de Thames & Kosmos, 301 Frien dship St., Providence , RI, 02903, USA | 1-800-587-2872 | www.thamesandkosm os.com Thames & Kosmos UK Ltd , Goudhurst, Kent, TN17 2QZ , United Kingdom | 01580 212000 | www.thamesandkosmos.co.uk

CodeGamer manual cover english.indd 1 8/9/16 10:04 AM

› › › IMPORTANT INFORMATION

Safety Information

WARNING! Only for use by children aged 10 years and older.

Instructions for parents or other s upervising adults are included and have to be observed. Keep the packaging and ins tructions as they contain important information.

WARNING! Not suitable for children under 3 years. Choking hazard

— small parts may be swallowed or inhaled.

Safety for Experimen ts with the Rechargeable Batter y

››› A lithium polymer r echargeable battery is r equired for

the experimen ts. Please use only the b attery supplied with the kit!

››› The rechargea ble battery is only to be charge d under

adult supervision.

››› Never perform experiments using household current!

The wires are not to be ins erted into socket-outlet s. The high voltage can be e xtremely dangerous or fata l!

››› The battery is no t to be short-circuited. It co uld

overheat and explo de!

››› Do not connect t he battery’s terminals to ea ch other. ››› The battery is to be i nserted with the corre ct polarity. ››› Avoid deforming the battery. ››› The battery is to be r emoved from the toy if it is

defective.

››› Keep the kit out of th e reach of small children . ››› When assembling the device and installing the

battery, follow th e instructions in this ma nual in order to avoid destr uction of components .

Dear Parents and Supervising Adults,

This experiment kit will introduce your chil d to the exciting world of programming in a fun way. Please be available to provide your child with help, advice, an d support. It is natural to have questions about safety. This kit meet s U.S. and European safety standards. These stan dards impose obligations on the manufacturer, but also stipulate that adults should provide their children with advice and assistan ce during the experiments. Tell your child to read all the relevant instructions and safety information, and to keep these mater ials on hand for reference. Be sure to stress the impor tance of following all the rules and information when performing the e xperiments. We wish your child, and of course you as well, lot s of fun and success with the experime nts!

Disposal of Electrical and Electronic Components

This product’s elec tronic parts are reusa ble and, for the sake of protecting th e environment, they sh ould not be thrown into the regular h ousehold trash at the en d of

their lifespan . Instead, they must be del ivered to a collection locati on for electronic waste , as indicated by the following symbol: Please consult your lo cal authorities for

the appropriate disposal location.

Disposal of Battery

The battery does no t belong in the household trash! I n some states and countries, it is re quired by law to deliver batteries and rech argeable batteries to a lo cal collection

location or to a store. T his will ensure that they wil l be disposed of in an envir onmentally responsibl e manner. Batteries containing hazardous substances are identified by this image or by chemic al symbols (Cd = cadmium,

Hg = mercury, Pb = lead ).

Simplified EU Declaration of Conformity

Thames & Kosmos here by declares that the Kos moBits radio communication unit model 620141 conforms to Directive 2014/53/EU. The complete text of t he EU conformity declar ation is available at the follow ing Internet address : http:// thamesandkosmos.com/codegamer/declaration.pdf

Safe Handling of Electronic C omponents

››› Avoid contact with me tallic objects and f luids of any

kind!

››› After exp erimenting, pack all s ensitive component s in

the bags provided for t hem and keep them toget her with the other part s in the experiment k it box.

››› If the KosmoBit s hardware is not to be used fo r a long

period of time, ple ase disconnect the batt ery’s connection wire fro m the interaction board .

The toy is only to be connect ed to Class II equipment bearing the following symbol:

Kosmos Quality and Safety

More than one hundred years of expertise in publishing science experiment kits stand behind every product that bears the Kosmos name. Kosmos experiment kits are designed by an experienced team of specialists and tested with the utmost care during development and production. With regard to product safety, these experiment kits follow European and US safety standards, as well as our own refined proprietary safety guidelines. By working closely with our manufacturing partners and safety testing labs, we are able to control all stages of production. While the major ity of our products are made in Germany, all of our products, regardless of origin, follow t he same rigid quality standards.

This work, inc luding all its pa rts, is copy right protect ed. Any use out side the spec ific limits o f the copyright la w without the co nsent of the pub lisher is proh ibited and punis hable by law. This applies specifically to reproductions, translations, microfilming, and storage and processing in e lectronic sy stems and netwo rks. We do not gua rantee that all m aterial in this work is free from c opyright or ot her protecti on.

Project management: Jonathan Felder, Marc Gänssler, Sebastian Martin Text and experim ents: Feli x Homann Product development: Steffen Rothweiler Manual design concept: Atelier Bea Klenk, Berlin Layout and typesetting: Michael Schlegel, komuniki, Würzburg Illustrations: Michael Schlegel, komuniki, Würzburg Manual photos: p icsfive (all p ushpins); aska ja (all paper cli ps); Jaimie Dupl ass (all tape str ips) (all © fotolia.co m); 8vFanl (p. 61 botto m right); hopsa lka (p. 61 top); kris ta (p. 2 bottom lef t, p. 21 bottom right); te pic (p. 20 bottom) (al l © iStockphoto .com); Designu a (p. 38 bottom) (© shutterstock .com); leejeo ngsoo (p. 35 botto m); theSOARn et (p. 38 top); Petr Kr atochvil (p. 33 top) (all © pixabay.c om); Johannes ( p. 2 center right , p. 21 top right); W illi Heidelb ach (p. 27) (all published under CC BY-SA 2.5, viewable under https://creativecommons.org/licenses/bysa/2.5/deed.d e); Philip Steff an (p. 60 all, © Ma ke magazine); al l screensho ts of the Arduin o program © Arduin o; Andreas Res ch, argfx, S t. Ulrich am Wa asen (front c over, p. 1 rendering gamepad, p. 1 and p. 3 2 SensorBot s); Michael Fla ig, proStudio s, Stuttgart (p . 1 additional materials); Matthias Kaiser, Stuttgart (all other photos)

Packaging design concept, layout and typesetting: Michael Schlegel, komuniki, Würzburg Packaging photo s: Andreas Re sch, argfx , St. Ulric h am Waasen (all ren derings); Mich ael Flaig, pro-studios , Stuttgart (mat erials photo)

The publisher h as made every ef fort to locate t he holders of im age rights fo r all of the photo s used. If in any indi vidual case s any holders of i mage rights ha ve not been ackn owledged, th ey are asked to provi de evidence to t he publisher o f their image rig hts so that the y may be paid an image fee in line wi th the industr y standard.

Android, Goog le Play and the Go ogle Play logo ar e trademarks o f Google Inc . Apple and the App le Logo are trade marks of App le Inc., regi stered in the USA a nd other countries. A pp Store is a ser vice mark of App le Inc.

1st English Edi tion © 2016 Thame s & Kosmos, LLC , Providence , RI, USA Thames & Kosmos ® is a registere d trademark of T hames & Kosmos, LLC. Translation: David Gamon; Editing: Camille Duhamel and Ted McGuire; Additional Graphics and Layout: Dan Freitas

Distributed in N orth Americ a by Thames & Kosm os, LLC. Pro vidence, RI 02 903 Phone: 800-587-2872; Web: www.thamesandkosmos.com

Distributed in U nited Kingdom b y Thames & Kosm os UK, LP. Goudhur st, Kent TN17 2QZ Phone: 01580 212000; Web: www.thamesandkosmos.co.uk

We reserve the r ight to make tech nical change s.

Printed in China / I mprimé en Chin e

FCC Part 15 Statement

This device comp lies with Part 15 of t he FCC Rules. Operat ion is subject to the f ollowing two conditions: (1) t his device may not ca use harmful interfe rence, and (2) this d evice must accept any interference received, including interference th at may cause undesi red operation.

Warning: Change s or modificatio ns to this unit not expressly a pproved by the party responsible fo r compliance coul d void the user’s authorit y to operate the equipm ent.

NOTE: This equip ment has been tes ted and found to comply with t he limits for a Clas s B digital device, p ursuant to part 15 of t he FCC Rules. These l imits are design ed to provide reasonable protection against harmful interference in a residential installation. This equipment gener ates, uses and ca n radiate radio frequency e nergy and, if not ins talled and used in accorda nce with the instru ctions, may cause harmful i nterference to rad io communications. However, there is no gu arantee that interference wi ll not occur in a parti cular installation. I f this equipment doe s cause harmful interfe rence to radio or tele vision reception, whic h can be determine d by turning the equipment of f and on, the user is encouraged to try t o correct the inter ference by one or more of the fol lowing measures :

• Reorient or reloc ate the receiving an tenna.

• Increase the se paration between t he equipment and receiver.

• Connect the equip ment into an outlet on a circuit differe nt from that to which t he receiver is connected.

• Consult the deale r or an experienc ed radio/ TV technician f or help.

Shielded cable s must be used with thi s unit to ensure complian ce with the Class B FCC l imits.

FCC RF Exposure State ment

To comply with the FCC RF ex posure compliance requirements, this device and its antenna must not be c o-located or ope rating in conjunction wit h any other antenna o r transmitter.

For body worn opera tion, this devic e has been tested and meet s FCC RF exposure g uidelines when used with an ac cessory that con tains no metal and that posi tions the device a mi nimum of 5 mm from the body. U se of other accessories may not ensure compliance with FCC RF exposure guidelines.

IC Statement

RSS-Gen & RSS-247 statement:

• This device comp lies with Indust ry Canada licence-exempt RSS standard(s).

• Operation is subj ect to the followin g two conditions: (1) thi s device may not caus e interference , and (2) this device mu st accept any interference, including interference that may cause undesir ed operation of the d evice.

• Le présent appar eil est conform e aux CNR d‘Industrie Canada applicables aux appareils radio exempts de licence.

• L‘exploitation est autor isée aux deux conditions suiva ntes : (1) l‘appareil ne doit pa s produire de brouillage, et (2) l‘utilisateur de l‘appareil doit accepte r tout brouillage radioélectrique subi, même si le brouillage est susceptible d‘en compromere le fonctionnement.

RSS-102 Statement:

• This equipment co mplies with Indu stry Canada radiation e xposure limit s set forth for an uncontrolled environment.

• Cet équipement e st conforme à l‘expo sition aux rayonnement s Industry Cana da limites établies pour un environnement non contrôlé.

1000 1001 1101 101 00 100 10 1010 0

CodeGamer manual cover english.indd 2 8/9/16 10:04 AM

What’s inside your experiment kit:

Checklist: Find – Inspect – Check off

No. Description Quantity Item No.

1 KosmoDuino 1 717 982

2 Interaction board 1 717 981

3 Gamepad housing, top right 1 718 006

4 Gamepad housing, top left 1 718 007

5 Gamepad housing, bottom 1 718 005

6 Wheel with return spring 1 718 008

718 009

7 Buttons with rubber feet 1 718 010

718 011

8 Light sensor 1 717 985

9 Sound sensor 1 717 986

10 Temperature sensor 1 717 984

11 Motion sensor 1 717 983

12 Housing for sound sensor 1 718 000

718 004

13 Housing for light sensor 1 717 999

718 003

14 Housing for temperature sensor 1 717 997

718 001

No. Description Quantity Item No.

15 Housing for motion sensor 1 717 998

718 002

16 Breadboard 1 717 996

17 Jumper wire s 10 717 990

male-female

18 Jumper wire s 10 717 989

male-male

19 Resistors: 330 Ohm 5 717 991

20 LEDs: yellow 1 each 717 994

green 717 993 blue 717 995 red 717 992

21 Cable: USB to Micro-USB 1 717 988

22 Lithium polymer battery, 800 mAh 1 717 987

(not shown)

You will also need:

Smartphone or tablet with Android (4.3 or later) or iOS (Version 7 or later). The device must support Bluetooth 4 or higher. PC with Internet access.

620141 - 02 -190 716

GOOD TO KNOW! If you are missing any

parts, please contact Thames & Kosmos

customer service.

US: techsupport@thamesandkosmos.com

UK: techsupport@thamesandkosmos.co.uk



CodeGamer

› › › KIT CONTENTS

CodeGamer manual inside english.indd 1 7/19/16 12:31 PM

Safety Information .................................................. Inside front cover

Kit Contents .............................................................................................. 

Table of Contents ..................................................................................... 

How to get started with CodeGamer ......................................................

Assembling the gamepad and sensors The CodeGamer app

The World of the Microcontroller ............................................................. 

First steps ...................................................................................................... 

Installation of the Arduino Software

Project : Blink! .................................................................................................. 

Upload a program to your KosmoDuino

Project : Off switch ........................................................................................ 

Project : On switch ......................................................................................... 

The Interaction Board ..................................................................................... 

Project : Colored light ..................................................................... 

Project : At the push of a button .................................................... 

Project : A blinking die ..................................................................... 

Project : Serial monitor .....................................................................

The for loop ........................................................................................... 

Sensors .................................................................................................... 

Project : Thermometer ........................................................................

Project : Finger disco ........................................................................... 

Project : Cheep! ................................................................................... 

Project : Random sounds! .................................................................. 

Project : Siren ...................................................................................... 

Project : Musical scale ..................................................................... 

Project : Sensor organ ...................................................................... 

Project : The serial plotter ............................................................. 

Project : Clap switch ...................................................................... 

Project : Drawer monitor .............................................................. 

Project : Looking inside the fridge .............................................. 

Project : Ghostly eyes ................................................................... 

Common Error Messages ............................................................................... 

Notes ................................................................................................................... 

Publisher’s Information .......................................................Inside back cover

TIP !

You will find additional information on

the “Check It Out” pages (21, 59-61)

and “Knowledge Base” pages (24-25,

35, 41-42, and 58).

› › › TABLE OF CONTENTS



1000 1001 1101 101 00 100 10 1010 0

CodeGamer manual inside english.indd 2 7/19/16 12:31 PM

How to get started with CodeGamer

ASSEMBLING THE GAMEPAD

1. First of all, you will have to insert the little metal spring into its correct location in the left area of the bottom part of the housing. The spring will hold the wheel and ensure that it always returns to its original position.

2. Next, you will have to insert the narrow axle of the wheel into the rotation encoder hole. The rotation encoder is attached to the interaction board and marked there.

3. Connect the battery to the interaction board. The attachment is on the bottom side. The battery’s plug is shaped in such a way that it can only be connected in the correct polarity direction. Do not force it!

4. Now place the battery in the lower housing of the interaction board. Insert it so that it is securely mounted and does not jiggle.



CodeGamer

GETTING STARTED

CodeGamer manual inside english.indd 3 7/19/16 12:31 PM

ASSEMBLING THE SENSORBOTS

1. Take one of the sensors and look for the housing with the matching color (see page 1, “Kit Contents”). Insert the sensor front side forward into the half of the housing with the eyes printed on it. The sensors’ “feet” (the metal pins) are always closer to the back side.

2. Now all you have to do is attach the rear of the housing to the front part. To do that, just press the two parts firmly together.

5. Now you can insert the interaction board into the housing. Be sure that the wheel is mounted correctly in the spring (see image in circle).

6. Attach the gray rubber feet onto the bottom of each button. To do this, simply insert the thinner side of the rubber foot into the recess on the bottom of the button.

Then, insert the button plate into the right upper

gamepad housing. Be sure that the buttons are positioned correctly. You know that everything is correctly placed when you feel an explicit trigger point when the buttons are pushed. Then, attach the left upper housing.

7. Your gamepad is now completed except for its “control center,” the KosmoDuino. You can simply attach this to the interaction board. Make sure that all the pins fit and do not bend when you attach it. Press the KosmoDuino far enough in that its “feet” (the metal pins) are no longer visible.



CodeGamer manual inside english.indd 4 7/19/16 12:31 PM

◀▲

Various CodeGamer App screenshots

THE APP

To ease your entry into the world of programming, we have developed an app to help you start building experience in this area.

The core of the app is a video game in which you have to solve little programming puzzles. But don’t be afraid — they aren’t hard, and you will definitely be able to figure them out. The key to solving the puzzles lies with the code monsters that you will find at every level. Collect them all, because you will need them at the computer terminals. The computer terminals contain incomplete code. To fill in the blanks, you will need to drag the correct code monster into the matching blank spaces. To learn more about the monsters, just tap once or twice on them in your inventory — and they will tell you which blank space in the code they will complete.

Use your gamepad to control the characters in the game. To do this, you must have Bluetooth activated on your tablet or smartphone. Start the app and switch on the gamepad by sliding the switch at the upper edge to the “ON” position. The connection will then be made automatically in a few seconds. Once the connection is active, the control elements (arrows and A and B buttons) will disappear from the screen and you can control the app with just the gamepad. If you switch off your gamepad, the control elements will reappear. But the game is not nearly as much fun without the gamepad!



CodeGamer

SYSTEM REQUIREMENTS:

KosmoBits supports devices with

Android 4.3 and iOS 7 operating systems or later. The device has

to support Bluetooth 4 or higher.

Important! Take the time to read the information, tips, and hints presented in the

communication console here.

CodeGamer manual inside english.indd 5 7/19/16 12:31 PM

▲

KosmoBits controller

HOW TO DOWNLOAD THE FREE APP:

To install your app, you will need access to Google Play or the Apple App Store. Ask your parents or adult supervisor for help installing the app.

If your device runs on Android, open Google Play. Open the App Store with an iPhone or iPad. Just enter the search term CodeGamer and install the app.

You will need your four sensorbots to play the game. They are very handy for helping to clear obstacles out of your way in the game. You can simply insert them into your gamepad (see picture). As soon as you have inserted a sensorbot, your game character will turn into one of the four bots. Each one has its own special abilities. If you have inserted the blue “Newton” bot, for example, you will have to shake your gamepad vigorously back and forth to activate its abilities. We will let you find out on your own how to activate the special abilities of the other sensorbots.

Play the game once through and take a look at the other contents of the app in the main menu. You will find a lot there about your experiment kit and the topic of programming.

We hope you have a lot of fun experimenting with code!

The World of the Microcontroller

Welcome to the world of the microcontroller! It looks astonishingly similar to your own world. Or more precisely: It looks exactly like your own! All around you, there are countless microcontrollers going about their work unnoticed. There’s hardly any electronic device that works without a microcontroller — an electrical toothbrush, the remote control for your TV, the controller for your video gaming system, a digital thermometer, a talking doll, a barking toy dog, the washing machine, the smoke detector, the toaster, and so on …



CodeGamer manual inside english.indd 6 7/19/16 12:31 PM

WHAT DOES ARDUINO MEAN, ANYWAY?

In this instruction manual, you will come across the word “Arduino” a lot. That is the name for a widely-used microcontroller platform on which the KosmoDuino was based.

For a long time, microcontroller programming was only for specialists. In 2005, the founders of the Arduino project took it upon themselves to make the programming and use of simple microcontrollers as easy as possible. That way, art students and hobbyists who had never before had any experience with programming would be able to use microcontrollers in their work.

Since then, a large community has formed around the Arduino platform and lots of interesting projects have developed out of it. You can copy a lot of them with your KosmoDuino, which is compatible with an Arduino Uno board.

You can learn more about the Arduino project at www.arduino.cc.

BUT WHAT IS A MICROCONTROLLER?

A microcontroller is a small (“micro”) computer. But it is also fundamentally different from the computers that you normally deal with: It has no keyboard, no mouse, and no screen.

Instead, it has a lot of little feet, known as pins. A pin is something like a connection between the microcontroller and the outside world. Some of the pins have specified functions. Most, however, are so-called GPIO pins. That’s an abbreviation for General Purpose Input/Output. These GPIO pins can be used for both inputs and outputs. And that’s just what you need here.

. INPUT:

You can connect an input pin to a sensor, for example. This will monitor the outside world and send information about the surroundings, temperature, or brightness to the processor via fluctuating levels of electrical voltage. In your gamepad, an input pin is also activated when you press a button.

. OUTPUT:

Depending on how it is programmed, the processor can also respond to this information. For that, you will need output pins to establish the connection to LEDs or the sound module, which will then react to the level of the transmitted electrical voltage by emitting various sounds or colors.

Things really get exciting when you use several pins at the same time. That way, the microcontroller can react to the sensors all on its own — for example, by sounding an alarm when it gets too hot.

The thing your microcontroller has in common with a normal computer is the main processor that serves as the brain of any computer. That’s the little black square at the top left of your microcontroller. In the middle, there is a small processor. This is what is responsible for the communication between the microcontroller and the PC. At the right is the Bluetooth chip, which enables wireless connections with other devices.



CodeGamer

CodeGamer manual inside english.indd 7 7/19/16 12:31 PM

▲

Download page on www.arduino.cc

Preparation

To program your KosmoDuino, you will need an ordinary PC or laptop with the Arduino software installed on it. The software is also called a programming environment, since it includes a lot of tools that you will need for programming.

INSTALLATION OF THE ARDUINO SOFTWARE

Download the Arduino software from https://www. arduino.cc/en/main/software. On that page, you will find

various versions for the current operating systems. For Windows operating systems, select “Windows Installer.”

After downloading, execute the downloaded file. Since the Arduino software is constantly being revised, there are always new versions. At the time that this manual was printed, 1.6.6 was the current version, and the file was called arduino-1.6.6-windows.exe. However, we recommend working with version .., since this is the version that was extensively tested by us. You will find older versions on the “PREVIOUS RELEASES” page. After starting the installer, follow the instructions to complete the installation.

INSTALLATION OF THE KOSMOBITS LIBRARIES AND SAMPLES

In a software library, you will find lots of useful and reusable functions that will make programming easier for. The ones we developed are called the KosmoBits libraries. They also contain a lot of sample programs that you will find in this manual. You must install these libraries.

The KosmoBits libraries can be downloaded by entering

http://thamesandkosmos.com/codegamer/kosmobits_ archive.zip link into your web browser. The file is called kosmobits_archive.zip. This is a zip file that you will have

to unzip and move into the Arduino libraries folder.

On the next page, you will be asked for a contribution. The Arduino project, which promotes the development of the Arduino software, is largely financed by these kinds of donations. You can also download the software for free without making a donation by clicking on “Just Download.”

Windows:

1. Open the explorer.

2. Go to the downloads folder.

3. Double-click the kosmobits_archive.zip file to open it.

4. Select all the files and folders in the libraries folder by simultaneously pressing the “Ctrl” and “A” keys.

5. Then press “Ctrl” and “C” to copy the selected files.

6. Go to the Documents ➜ Arduino ➜ libraries folder.

7. Now simultaneously press the “Ctrl” and “V” keys to paste the files and folders into the libraries folder.

Mac:

1. Unzip the kosmobits_archive.zip file.

2. Drag the contents of the libraries folder into the Documents ➜ Arduino ➜ libraries folder.

On either platform, you can alternatively try installing

the libraries through the Arduino application itself:

1. In the Arduino application, go to the Sketch menu and choose Include Library ➜ Add .ZIP Library...

2. Navigate to the kosmobits_archive.zip file and click

Choose/Open.

THE KOSMOBITS CONTROLLER

With your KosmoBits controller, you are holding your very own microcontroller in your hands. We named it KosmoDuino because it is based on the Arduino microcontroller. (KosmoBits is the name of the electronic system in this kit.) You can do a lot with the KosmoDuino, but first you have to learn how to program it. This manual will explain how.

Okay! Now you can begin programming. You will just need to open the Arduino application to get started.



Important! You must download and install the Arduino application from:

https://www.arduino.cc/en/main/software

and you must download and install the Kosmobits libraries and programs from:

http://thamesandkosmos.com/codegamer/kosmobits_archive.zip

CodeGamer manual inside english.indd 8 7/19/16 12:31 PM

To write your first program, launch the Arduino environment on your computer. A window will open into which you can enter your program code. A few lines have already been entered for you:

void setup() { // put your setup code here, to run once:

}

void loop() { // put your main code here, to run repeatedly:

}

int ledPin = 13;

void setup() { pinMode(ledPin, OUTPUT); }

void loop() { digitalWrite(ledPin, HIGH); dela y (5 00); digitalWrite(ledPin, LOW); dela y (5 00); }

s e t u p ()

lo o p ()

ARDUINO SWITCHED ON

That is the basic skeleton for every Arduino program:

1. Your KosmoDuino starts by processing all instructions in the

s e t u p ()

function, i.e., all functions written in the

curly brackets following

s e t u p ()

2. Then, the

lo op ()

function is invoked. That means that your microcontroller executes all instructions written in the curly brackets following

lo op ()

. Once the final instruction has been processed, your controller once again invokes the

lo op ()

function. In other words, the

instructions in

lo op ()

are invoked over and over in an

endless loop. That is why it’s called a loop function.

You can visualize this idea a little more clearly in a flow diagram. The program always proceeds in the direction of the arrows: from switching on, to

s e t u p ()

, to

lo op ()

and

then back to

lo op ()

again and again.

You could upload this program right away to your KosmoDuino if you wanted. But since there are no instructions in either

s e t u p ()

lo op ()

, the program

wouldn’t do anything.

So why not give your KosmoDuino something to do? Try changing the program code like this:

▲

Flow diagram

In the field of Arduino programming, the term “sketch” is often used to refer to a

program. In this instruction manual, both terms will be used.

This is where the explanation for the program code is written. Portions taken from the code are always highlighted in

orange

PROGRAM CODE EXPLAINED:

Here is where the program code is written

// Comments on the code are always in gray. // This text is not a functional part of the // code. It provides explanation and clarity.

Your first program: Blink!

</>



CodeGamer

PROJECT 1

CodeGamer manual inside english.indd 9 7/19/16 12:31 PM

</>

To upload a sketch to your KosmoDuino, proceed as follows:

1. Connect the KosmoDuino to your computer with the USB cable. You will not need the interaction board.

2. Save your program code if necessary. To do that, click on the “save” symbol in the Arduino environment.

3. Make sure that the correct board is selected:

Too ls ➜ Board ➜ “Arduino/Genuino Uno.”

4. Make sure that you have selected the correct port:

Too ls ➜ Port ➜ e.g., “COM3” (Arduino/Genuino Uno).

5. Now click on the “upload” symbol in the Arduino environment.

Don’t let yourself be intimidated by all the strange terms and brackets! We will go through the program step by step. You will soon see that it isn’t hard to understand at all!

But before we can see what the program does, we have to upload it to

the KosmoDuino. Follow the instructions below to learn how to do this.

New Open

Upload

Save

Status line

Window for further explanations

Verify

If you did everything correctly, the following messages should appear in sequence in the status line:

1. Compiling sketch …

2. Uploading …

3. Uploading completed.

Compiling sketch

…

Uploading

…

Uplo adin g co m pleted.

UPLOADING A PROGRAM TO KOSMODUINO

You can only ever upload one program at a time to your KosmoDuino. If you want to play the KosmoBits

game with your gamepad, you will have to install the KosmoBits_App.ino file. This file comes pre-installed

on your KosmoDuino when your kit is shipped.



PROJECT 1

CodeGamer manual inside english.indd 10 7/19/16 12:31 PM

ERROR MESSAGE?

If you see an error message, take a careful look at the program text you entered. Is it possible that you wrote something incorrectly? The place where an error leads to problems in the program text is marked in red in the Arduino environment (see illustration). In any case, you should try looking for the actual error first. Even just tiny typos will lead to error messages! If you cannot find an error, then take a look at the yellow box below. There, under the “Opening the sample programs” heading, you will find an explanation of how you can use the example programs described in this manual without having to type them into the computer from scratch.

Typo: “pinnMode” instead of “pinMode!” The

location of the error is highlighted in red.

▶

BlinkOnBoar d.ino: In function 'void setu p()':

BlinkOnBoar d:11: error: 'pinnMode' was n ot declared i n this scope

'pinnMod e' was not declared i n this scope

'pinnMode' was n ot declared in this sco pe

Copy error mess ages

Did everything work? Great! If so, you will now see a little green LED — the “onboard LED” — blinking on and off on the KosmoDuino.

Opening the sample programs

All sample programs can be opened directly, so you can

bypass typing them in by hand. You will find them in the Arduino environment in this menu:

File

➜

Examples

➜

KosmoBits

EXPLANATION

Now it’s time to really understand the program. Let’s take a closer look at it.

The first line reads:

int ledPin = 13;

In the Arduino programming language, instructions must be closed with a semicolon (“;”).

This defines a variable with the name

ledPin

. Variables are important components of any program. You can save any value you like in a variable — numbers, letters, or entire words. Each variable has a name. The name allows you to invoke the saved value whenever you like.

If you want to save a value in a variable, use the equals sign (“=”). The variable goes on the left side of the equals sign, while the value goes on the right. For example,

int ledPin = 13

means that the value 13 is saved in the



PROJECT 1

CodeGamer

CodeGamer manual inside english.indd 11 7/19/16 12:31 PM

void setup() { pinMode(ledPin, OUTPUT); }

void loop() { digitalWrite(ledPin, HIGH); dela y (5 00); digitalWrite(ledPin, LOW); dela y (5 00); }

Here, a function is defined. The function is called

s e t u p ()

. When a function is invoked in the program code, all the instructions contained in it are carried out step by step. Those are all the instructions written between the curly brackets. So you can think of a function as a small sub-program.

The function

s e t u p ()

, by the way, is a special function. It is always the first thing that is automatically invoked whenever you start your KosmoDuino.

But what does the

s e t u p ()

function actually do? It

invokes another function:

pi n M o d e()

. This is the function that allows you to specify the operating mode in which a pin is going to work. In this case, the

ledPin

(pin number

13) is to work as

OUTPUT

, or the output pin.

An output pin works like a switch that you turn on or off as determined by the program. You will learn about the other possible operating modes in later projects.

If the instructions in

s e t u p ()

have been processed by

your KosmoDuino, the next thing to be invoked is the

lo op ()

function. Let’s take a look at what this function

contains:

FUNCTIONS

Functions allow you to divide up your programs into smaller blocks. That can help you keep a clear overview, and it promotes order in the program. Also, you can pack frequently used sequences of instructions into a single function. Instead of repeating the same text in the program code every time, you can simply invoke the corresponding function.

Just as with the definition of a variable, to define a function you have to start with an example. In this case, let’s take

void

. This is the so-called return type. A function, in other words, can end by returning a value to the program that invoked it. In this case, the return type is

void

, meaning “empty.” In other words, this function returns no value at all! An example

of a value that might be returned is the temperature measured by a sensor.

Important: Always give your functions a name that conveys what the function does. That will help you understand the program when you’re reading it.

variable

ledPin

. The way you say it is: “The value 13 is

assigned to the variable

ledPin

.”

Wherever you want to use the number 13 in your program, you can now write “ledPin” instead of “13.”

BUT WHAT DOES

int

MEAN?

In the Arduino programming language, a variable cannot take just any value you like. The values must be of a certain type that has to be determined. In this case, the type is

int

. That means that the variable can take a socalled integer value. For your KosmoDuino, those values are the whole numbers from -32768 to 32767.



PROJECT 1

CodeGamer manual inside english.indd 12 7/19/16 12:31 PM

What happens when

lo op ()

is invoked? The first

instruction in

lo op ()

is:

digitalW rite(le dPi n, HIG H);

You can use

digitalW rite()

to control whether voltage is applied to an output pin or not. When issuing this request, there are two things that you will have to communicate to the

digitalW rite()

function:

1. Which pin is intended?

2. Should the voltage at the pin be switch on (

HIGH

) or

off (

LOW

In this case, voltage is switched on at pin number 13 (

ledPin

), and the LED lights up! If you want to switch on another pin, let’s say pin number 9, you would write

digitalW rite(9, HIG H);

The next instruction is:

del a y(5 0 0);

You can use the

d e l ay()

instruction to delay the program sequence for a specific period of time — in other words, to make it wait. The amount of time is determined by the number that you assign with the request, in this case

500

. The time is indicated in milliseconds (thousandths of a second). 500 milliseconds is half a second. So the program waits and does nothing for half a second.

Then we have the instruction

digitalW rite(le dPi n, LO W);

. You can probably understand this one without any help. Right — the LED is switched off again!

Then the KosmoDuino waits another half a second:

del a y(5 0 0);

And then?

Then it starts all over again from the beginning!

lo op ()

is a special function in the Arduino programming. It repeats endlessly! All commands in

lo op ()

are carried out over

and over in an endless loop. This is known as the main loop. This makes

lo op ()

the most important function in any KosmoBits program. It controls what the KosmoDuino actually does, while

s e t u p ()

handles the required

preliminary steps.

You have already seen what happens when the main loop is repeated: The LED is switched on and off, over and over, in regular intervals of half a second. In other words — the LED blinks.

TYPES A few common type specifiers and their meanings

TYPE MEANING VALUES

int

Whole numbers or HIGH / LOW (on/off) -32,768 to 32,767

long

Whole numbers, large -2,147,483,648 to 2,147,483,647

float

Floating decimal numbers: numbers with a decimal point

e.g., 1.5; 3.141; 2.678

double

float

but with twice the precision

e.g., 3.141964; 21.45873

char

Individual letters

e.g.,

a; A; c; C

const

Unchangeable value Can take any values



PROJECT 1

CodeGamer

CodeGamer manual inside english.indd 13 7/19/16 12:31 PM

Off switch

In your first “blink” sketch, you learned how to use a program to make an LED blink on your KosmoDuino. To do that, you used a pin on your controller as an output pin to make the LED switch on and off.

But you can also use a pin as an input pin. In this case, the pin is not turning voltage on or off. Instead, the program can tell you whether or not an electrical voltage is supplied to the pin.

You can then use that to turn the LED on and off with a simple switch.

YOU WILL NEED

›

KosmoDuino

›

 male-male jumper wires (see explanation on p. )

PREPARATION

Attach one jumper wire to pin 9 and the other to one of the GND pins. GND stands for ground or grounding. These pins have no actual function beyond conveying current.

int ledPin = 13; int switchPin = 9; int switchValue = HIGH;

void setup() { pinMode(ledPin, OUTPUT); pinMode(switchPin, INPUT_PULLUP); }

void loop() { switchValue = digitalRead(switchPin); digitalWrite(le d Pin, switchValu e);

dela y (5 0); }

THE PLAN

Upload the sketch to your KosmoDuino as described on page 10. After uploading, the LED will light up. If you then bring the two free jumper wire contacts together and make them touch, the LED will stop shining.

THE PROGRAM

So what does the program do?

int ledPin = 13; int switchPin = 9; int switchValue = HIGH;

You will first have to define three variables:

•

ledPin

for the pin to which the LED is connected.

•

switchPin

should be assigned the value 9, because you

will be connecting your “switch” to pin 9.

•

sw itc hValue

will start by getting the value

HIGH

. Later on, you will “read out” pin 9 and save the readout value in

sw itc hValue



PROJECT 2

Warning! Not suitable for children under 8 years.

There is a risk of hot surfaces of components on the PCB (printed circuit board) when different polarities are incorrectly short-circuited or the capacitor is

subject to fault conditions.

CodeGamer manual inside english.indd 14 7/19/16 12:31 PM

void setup() { pinMode(ledPin, OUTPUT); pinMode(switchPin, INPUT_PULLUP); }

void loop() { switchValue = digitalRead(switchPin); digitalWrite(le d Pin, switchValu e);

dela y (5 0); }

</>

This is almost the same as in your first program. The

ledPin

is operated as an output pin (

OUTPUT

). Pin 9

(

switchPin

), on the other hand, is operated as an input

pin. So in the

pi n M o d e()

instruction for

switchPin

instead of the value

OUTPUT

, you will use

INPUT_PULLUP

First, use

digitalRead(switchPin)

to read out the current state of pin 9. If the pin is electrically connected to a “GND” pin, it yields the value

LOW

. That means that

there is no voltage supplied. Otherwise, it yields the value

HIGH

. Save this value in the

sw itc hValue

. Then, write this value into the LED pin. So if pin 9 is connected to the GND pin, it switches off the LED. Otherwise, the LED will be switched on.

Finally,

delay(50)

will make you wait briefly before the

entire sequence repeats.

On switch

YOU WILL NEED

›

KosmoDuino

›  male-male jumper wires

PREPARATION

Connect one jumper wire to pin 9, and the other to one of the GND pins. int ledPin = 13;

int switchPin = 9; int switchValue = HIGH;

void setup() { pinMode(ledPin, OUTPUT); pinMode(switchPin, INPUT_PULLUP); }

void loop() { switchValue = digitalRead(switchPin);

if(switchValue == LOW) { digitalWrite(ledPin, HIGH); } else { digitalWrite(ledPin, LOW); } dela y (5 0); }

THE PROGRAM

Upload the sketch to your KosmoDuino as described on page 10. This time, after uploading, the LED will remain dark. It only lights up when you touch the two free jumper wire contacts together.

THE PLAN

In the previous project, you learned how to switch off an LED with the help of a simple switch. But what do you do if you want it to work in reverse — in other words, to have the LED only come on if the contact is closed? Just change the program!



PROJECT 3

CodeGamer

Warning! Not suitable for children under 8 years. There is a risk of hot surfaces of components on the PCB (printed circuit board) when different polarities are incorrectly short-circuited or the capacitor is subject to fault conditions.

CodeGamer manual inside english.indd 15 7/19/16 12:31 PM

EXPLANATION

Let’s just take a look at the

lo op ()

function, because that’s the only

place where anything was changed relative to the “off switch” program.

void loop() { switchValue = digitalRead(switchPin);

if(switchValue == LOW) { digitalWrite(ledPin, HIGH); } else { digitalWrite(ledPin, LOW); }

dela y (5 0); }

Just as with the “off switch,” you start by reading out the

switchPin

and saving the current value, i.e.,

HIGH

LOW

in the

sw itc hValue

variable.

But you do not want to write the read value into the LED pin — just the opposite: When

sw itc hValue

has the

value of

LOW

, you want to switch on the LED

(

digitalW rite(le dPi n, HIG H)

); otherwise, you want to

switch off the LED (

digitalW rite(le dPi n, LO W)

In the program text, you express that with

if (...){...} el s e {...}

. Note the “if” and “else.” You guessed it — this lets you use the program to respond to different conditions.

The condition to which you are responding here is

switchValue == LOW

. You can understand that as a question: “Is the switch value equal to LOW?” You can evaluate the answer to that with the

if ()

instruction: If

the

sw itc hValue

is equal to

LOW

(

if(switchValue == LOW)

), the program code in the first

pair of curly brackets is carried out:

digitalW rite(le dPi n, HIG H)

. The LED is switched on.

Otherwise (

else

) the part in the second pair of curly

brackets is carried out:

digitalW rite(le dPi n, LO W)

. The

LED is switched off.

Finally,

delay(50)

will make you wait briefly before the

entire sequence repeats.

</>

JUMPER WIRES

Jumper wires serve as an easy way to connect electronic components to each other. In this experiment kit, you will find two different types: male-male and male-female. They really are called that! “Male-male” means that there is a wire on both ends. While “male-female,” on the other hand, there is a wire on one end and a socket on the other. Jumper wires are sometimes also called patch cables.

Female End«

Male End«



PROJECT 3

CodeGamer manual inside english.indd 16 7/19/16 12:31 PM

The Interaction Board

OK, we admit it. Making a little LED light up is not very exciting. Still, it helped to give you a quick introduction to programming your KosmoDuino.

To help you learn how to do more exciting things with your microcontroller as quickly as possible, we have developed the interaction board. You may have gotten to know it a little already while playing the CodeGamer video game. It has several very practical components that will come in handy for lots of projects:

To work with the interaction board, you will first have to insert your KosmoDuino into the board’s pin socket (see illustration).

NOTE!

To upload a program to the microcontroller, you will insert the USB cable into the USB port on the KosmoDuino. The USB terminal on the interaction board is only for charging the battery.

Upload program

Charge battery

• Two buttons (“button 1” and “button 2”)

• A multicolored LED (“NeoPixel”)

• A rotating wheel (“rotary encoder”)

• A speaker (“buzzer”)

And most important:

• A socket for connecting the KosmoBits sensors

(temperature, motion, brightness, loudness)

• A battery so that you can also use your

KosmoDuino when it isn’t attached to a computer.

Then you’ll be ready to start! In the following projects, you will start by exploring the interaction board’s capabilities, and then move on to the more complex projects.



CodeGamer

INTERACTION BOARD

CodeGamer manual inside english.indd 17 7/19/16 12:31 PM

Colored light

YOU WILL NEED

› KosmoDuino in the interaction board

THE PLAN

On the interaction board, you will find a multicolored LED called a NeoPixel. It’s a kind of LED that lets you decide what color and brightness level you want it to have. This

Up to now, you have only learned about variables that act as containers for numerical values. The

pixel

variable

that you are defining here is a little different: Instead of numbers, it serves as a container for an object of the KosmoBits_Pixel type. That sounds more confusing than it really is. It just means that objects can be more than simple values such as

int

. More specifically, rather than just having one value, they can bring their own functions with them. These are also known as methods. Your

pixel

, for example, is an object that you can use to control the NeoPixel on your interaction board. For that purpose, it has a method by the name of

setColor()

, that you can use to adjust the color and brightness of the NeoPixel. Next, in the main loop, you will learn how this works. To adjust the color and brightness of your NeoPixel, you will need four number values — one for the brightness and three for the primary colors red, green, and blue. These values will be saved in the corresponding variables

red

green

blue

, and

brightness

The various colors will be produced by mixing these three basic colors. You will be setting the corresponding number value to determine how strongly each of the colors in this mixture will be represented. You can use values from 0 to 255. 0 means that the corresponding color will not light up at all. With a value of 255, the color will shine with the highest possible brightness.

Kosm oBits_Pi xel pixel;

#include <Adafruit_NeoPixel.h> #include <KosmoBits_Pixel.h>

int red = 0; int green = 0; int blue = 0; int brightness = 0;

Here’s something new to you. The

#include

instruction will let you include code from other programs in your program. In this case, you will be including content from the “Adafruit_NeoPixel.h” and “KosmoBits_Pixel.h” files

You will always have to insert these two lines at the beginning of your program when you want to use the NeoPixel!

Multicolored NeoPixel LED

THE PROGRAM

little project will show you how it works, and how to get your NeoPixel to shine in all sort of colors

</>



PROJECT 4

CodeGamer manual inside english.indd 18 7/19/16 12:31 PM

void setup() { // There is nothing to do here. }

void loop() {

// 50 is a good brightness value. // The highest brightness level is 255. // It can be a bit blinding though!

brightness = 50;

// r e d

red = 255; green = 0; blue = 0; pixel.setColor(red, green, blue, brightness); dela y (5 00);

// g r e e n

red = 0; green = 255; blue = 0; pixel.setColor(red, green, blue, brightness); dela y (5 00);

// b l u e

red = 0; green = 0; blue = 255; pixel.setColor(red, green, blue, brightness); dela y (5 00);

// p u r p l e

red = 255; green = 0; blue = 255; pixel.setColor(red, green, blue, brightness); dela y (5 00);

// t u r q u o is e

red = 0; green = 255; blue = 255; pixel.setColor(red, green, blue, brightness); dela y (5 00);

// y ell o w

red = 255; green = 255; blue = 0; pixel.setColor(red, green, blue, brightness); dela y (5 00);

</>

s e t u p ()

there will be nothing for you to do this time,

since the program that you will be linking with the

#include

instruction will already be handling it for you.

In the main loop, the first thing to do is set the brightness:

brightness = 50;

. The highest level of brightness is set

with a value of 255; with 0, the NeoPixel remains dark.

Then the various colors are produced one after the other. To do that, you will be assigning the

red

green

and

blue

variables different values.

The line

pixel.setColor(red, green, blue, brightness);

is the decisive factor for each color. First of all, it tells the NeoPixel that it is supposed to display a new color! In these instructions,

setColor()

is a so-called method of

the

pixel

object. To invoke a method of an object, the method’s name is attached to the name of the object separated by a period.

With

del a y(5 0 0);

you will make your KosmoDuino wait

half a second before adjusting the net color.

The NeoPixel

shines in

various colors

▶



CodeGamer

CodeGamer manual inside english.indd 19 7/19/16 12:32 PM

// w h i t e red = 255; green = 255; blue = 255; pixel.setColor(red, green, blue, brightness); dela y (5 00); }

</>

SOFTWARE LIBRARIES

To avoid having to reinvent the wheel with every program, there are software libraries. These are not book collections. Instead, they contain reusable program functions and definitions. There are some libraries that provide mathematical functions, while there are others to make it easy to use certain types of hardware such as sensors or NeoPixels. To be able to use the tools that this kind of library can make available to you, you have to include the corresponding library in your own program. You do this with the help of the

#include

instruction:

#include <KosmoBits_Pixel.h>

includes the KosmoBits_Pixel library, for example. Some libraries, however, use functions from other libraries. They have to be additionally included, such as in the KosmoBits_Pixel library. More specifically, in order to work they require the Adafruit_NeoPixel library, which is linked via

#include <Adafruit_NeoPixel.h>

▲

Another type of library



PROJECT 4

CodeGamer manual inside english.indd 20 7/19/16 12:32 PM

Additive Color Mixing

What you see as white light is actually a mixture of different lights of

various colors. Which colors? Take a look at a rainbow and you will see them all. A rainbow is

created when the sun’s light is split up into its component colors by raindrops in the air.

This process can also work in reverse when you mix light of various colors together, resulting in a

different color. Any color monitor or screen works by this principle — whether on your TV, your

computer, your smartphone or your tablet. In all these devices, each individual picture element

(“pixel”) consists of three single-colored picture elements of red, green, and blue. Because they are

packed so tightly together, you cannot perceive the individual dots from a normal distance. You can

only see the individual dots of color if you get really close, or use a magnifying lens.

If you look carefully at the NeoPixel on the interaction board, you will be able to see three different

regions (as long as it isn’t shining). Each region can only produce one single color — red, green, or

blue. With the help of the

s e t C ol or ()

method, you can tell the NeoPixel how brightly you want

each of the different regions to shine.

Experiment with mixing together other colors by

varying the individual color values. The picture next to the

table below will serve as a reference for anticipating which

mixtures will produce which colors. Enter your findings into

the following table:

Color name Red Value Green Value Blue Value

Red 255 0 0

Green 0 255 0

Blue 0 0 255

CHECK IT OUT



CodeGamer

Enlarged photograph of a screen, reveling the

individual dots of color.

In this close-up, you can easily see the three

individual LEDs of the NeoPixel.

▶

▲

You can see

the component

colors of

sunlight in a

rainbow.

CodeGamer manual inside english.indd 21 7/19/16 12:32 PM

At the push of a button

In this project, you will learn how to use the buttons on the interaction board to make the NeoPixel light up in different colors.

YOU WILL NEED

› KosmoDuino in the interaction board

THE PLAN #include <Adafruit_NeoPixel.h>

#include <KosmoBits_Pixel.h> #include <KosmoBits_Pins.h>

Here, you are defining two constants for the pins to which the two interaction board buttons are connected. These are abbreviated as

const

. This keyword communicates to the program that an object or a variable cannot be changed.

As in the previous program, you are saving the various color values and the brightness in corresponding variables that you define here.

To be able to control the NeoPixel on the interaction board, you once again need a KosmoBits_Pixel object. You are defining that here.

const int button1 = KOSMOBITS_BUTTON_1_PIN; const int button2 = KOSMOBITS_BUTTON_2_PIN;

int red = 0; int green = 0; int blue = 0; const int brightness = 50;

Kosm oBits_Pi xel pixel;

First, we want the NeoPixel to stay dark. If you press button 1, the NeoPixel will glow red, while if you press button 2 it will glow blue. If you press both at the same time, it glows purple.

THE PROGRAM

You learned in the last project how to link to libraries and code from other files in a program. The new library here is

KosmoBits_Pins.h

. This defines names for the various KosmoDuino pins used by the interaction board. We will take a closer look at the KosmoBits libraries a little later on in this manual.

▲

Finger pushes right button — NeoPixel glows red

▲

Finger pushes left button — NeoPixel glows blue

▲

Two fingers push both buttons simultaneously — NeoPixel glows purple



PROJECT 5

CodeGamer manual inside english.indd 22 7/19/16 12:32 PM

</>

s e t u p ()

, you use

pi n M o d e()

to set the operating mode for the button pins. Since the buttons are connected to the pins via a resistor, you will use the

INPUT

operating type.

In the first if instruction

digitalRead()

is used to read out the pin to which button 1 is connected. When the button is pressed, it yields the value

LOW

: The value

255

i.e., the largest possible value, is assigned to

red

If the button is not pressed,

red

is set to 0.

The entire sequence is repeated for button 2 in the second

instruction. The only difference is that the value for

blue

is given.

Finally,

pixel.setColor(red, green, blue, brightness);

sets the new color value for the NeoPixel.

At the end of the main loop, you make the controller wait another 50 milliseconds.

void setup() { pinMode(button1, INPUT); pinMode(button2, INPUT); }

void loop() {

if (digitalRead(button1) == LOW) { red = 255; } else { red = 0; }

if (digitalRead(button2) == LOW) { blue = 255; } else { blue = 0; } pixel.setColor(red, green, blue, brightness);

dela y (5 0); }

WHAT ACTUALLY HAPPENS WHEN YOU UPLOAD SOMETHING?

When you upload a program to your KosmoDuino, actually, a whole lot of things happen. The microcontroller does not really understand the program as you have written it. It simply doesn’t speak the programming language. That’s why the program first has to be translated into machine language. That is something handled by a so-called compiler.

The programming language that you use, in other words, is just an intermediate language that is not only easy for you to understand and write, but most important of all, is one that the compiler can easily translate into machine language.



CodeGamer

CodeGamer manual inside english.indd 23 7/19/16 12:32 PM

Only under one condition:

The “if” instruction

You have already used the

instruction in the

program code. Now it’s time to take a closer look. By

using the

instruction, you can require that

portions of your program will be carried out only

if a certain condition is fulfilled:

// Simple if instruction

if (Condition) {

/ The following is only carried out

/ if the condition is fulfilled.

nstruction 1;

nstruction 2;

...

}

OPERATOR MEANING EXAMPLE

true

== equal to a == b when a is equal to b

< less than a < b when a is less than b

> greater than a > b when a is greater than b

!= unequal a != b when a is unequal to b

<= less than or equal to a <= b when a is less than or equal to b

>= greater than or equal to a >= b when a is greater than or equal to b

ATTENTION!

A common and not always easy-to-find error in an

statement is instead of the double equal sign to use a

single equal sign. For example, instead of

if (a == b)

the incorrect statement would be

if (a = b)

In the case of this

statement the value of

assigned the value

. If that value is greater than zero

(

true

), the block of text in the curly brackets is

executed.

The parts of the program in the curly brackets will only be carried out if the condition is fulfilled.

Otherwise, the entire block in the curly brackets will simply be skipped.

The condition must return a truth value either

true

false

. Usually, two numerical values are

compared. In addition, there are relational operators that will probably be familiar to you from math class:

INSTRUCTION 1

INSTRUCTION 2

Truth values are also known as

Boolean data types, abbreviated as

bo ol

These can only take the values true

or false.

KNOWLEDGE BASE



CodeGamer manual inside english.indd 24 7/19/16 12:32 PM

You can also extend an

instruction with an

else

statement. The

else

statement is carried out if and

only if the condition is not fulfilled.

// if instruction with else statement

if (Condition) {

/ The following is only carried out

/ if the condition is fulfilled.

Instruction 1; I

nstruction 22; ...

} else {

/ This block is carried out if

/ the condition is not fulfilled.

nstruction 3;

Instruction 4;

}

Finally, you can build in the additional block

else if

to check another condition if the first one is not fulfilled.

// if instruction with else block

if (Condition 1) {

/ The following is only carried out

/ if the condition is fulfilled.

Instruction 1; I

nstruction 2;

...

} else if (Condition 2){

/ This block is carried out if

/ the condition is not fulfilled.

nstruction 3;

Instruction 4;

} else {

/ This block is carried out if

/ none of the previously checked

/ conditions are fulfilled.

nstruction 5;

...

}

You can also omit the closing

else

statement. In

addition, you can line up as many

else if

statements in a row as you like.



CodeGamer

CodeGamer manual inside english.indd 25 7/19/16 12:32 PM

A blinking die

With this project, you will be turning your KosmoDuino into a simple die. At the push of a button, it will generate a random number from 1 to 6 and signal the result by blinking the NeoPixel.

YOU WILL NEED

› KosmoDuino in the interaction board

#include <KosmoBits_Pins.h> #include <Adafruit_NeoPixel.h> #include <KosmoBits_Pixel.h>

Kosm oBits_Pi xel pixel;

const int buttonPin = KOSMOBITS_BUTTON_1_PIN; const int blinkDuration = 500; // M ill i s e c o n d s const int blinkPause = 250; // M illi s e c o n d s const int brightness = 50;

s e t u p ()

, you prepare your controller for the upcoming

tasks in the usual manner: Use

pinMode(buttonPin, INPUT)

to set the pin connected to

button 1 as the input pin.

Later, you will be generating a random number. This will be handled by a random generator, which will need as random a value as possible to start with. To get that, read out pin 12 with

analogRead(12)

. Since nothing is connected there, any values that you get will be random. You will learn more about the

analogRead()

function a

little later. Then

ra n d o m S e e d(...)

delivers the read value

to the random generator itself as a starting value.

Finally,

pixel.setColor(0, 0, 255, brightness);

makes the NeoPixel glow blue.

void setup() { pinMode(buttonPin, INPUT); randomSeed(analogRead(12)); // Starting value

// for random generator

pixel.setColor(0, 0, 255, brightness); // B l u e

// signals operational readiness

}

void loop() { if (digitalRead(buttonPin) == LOW) { r o l l () ; } }

You start by including the familiar libraries and add a KosmoBits_Pixel to address the NeoPixel on the interaction board.

Then, you add a few constants to make the code legible.

THE PLAN:

• If the controller is ready, the NeoPixel will glow blue.

• If you press button 1, the NeoPixel will begin to blink green in accordance with the die result, i.e., once if the rolled result was one, twice if it was two, etc.

• After a brief pause, the NeoPixel will return to blue. That means that it’s ready to roll again.

In the main

lo op ()

, you read out the

buttonPin

with

digitalRead()

. When it is pushed, the result is

LOW

. With

the help of the if instruction the

r oll()

function is invoked, which calculates and outputs the result of the die roll. Otherwise,

lo op ()

does nothing.

</>

THE PROGRAM

This is a shortened version of the notation that you learned in Project 4. The numbers in the brackets control

the RGB value (red/green/blue).



PROJECT 6

CodeGamer manual inside english.indd 26 7/19/16 12:32 PM

loop on pages 30/31

</>

Here’s where you define your own function by the name of

r oll()

. It will calculate and then output a random number in the range of 1 to 6. Let’s go through it step by step:

First (1), you turn off the NeoPixel light and wait briefly. You know the corresponding commands by now.

Now we come to the actual roll. Since your KosmoDuino cannot literally roll dice, you have to get the result by some other means: You query a random number generator.

You do that with

random(1, 7)

(2). That lets you ask the random generator for a randomly selected number. The first parameter, 1 in this case, indicates that the smallest possible number is to be 1. The second parameter, 7 in this case, means that the randomly selected number should be less than 7.

Important: The second parameter must always be 1 greater than the largest possible number to be produced by the random generator. That may be a little confusing, but it’s just how it is. The random number produced in this way is saved in the

number

variable.

Now the random number is to be output by blinking (3). For that, you make use of a so-called

for

loop. You will

learn all about the composition of the

for

loop on the following pages. For now, the only important thing to know is that the code in the curly brackets is carried out exactly the indicated

number

of times. If

number

has

the value of 1, it will be 1 time. If

number

has the value

of 2, then 2 times, and so on.

What’s happening inside the curly brackets? Exactly — The NeoPixel lights up in green for the length of time indicated by

blink D u rat ion

and then switches off for

the length of time indicated by

blink P a use

. In brief: The

NeoPixel blinks green a single time. But since the

for

loop is executed

number

times, the NeoPixel blinks

number

times altogether. So the result of the roll is

output by blinking.

Finally (4), after another short pause (

delay(blinkDurati o n)

)

the NeoPixel returns to blue to

signal that you can roll again.

Since

r oll()

is only invoked from the main loop

lo op ()

in your program, it then returns to the main

loop. So the next thing that happens is another check in

lo op ()

to see whether the button is pressed or not.

Have fun rolling!

You will find more information about the

for

loop on

pages 30 and 31.

void roll() {

// (1) // Light off at first, to show that it is // ready to respond to the push of the button.

pixel.setColor(0, 0, 0, 0); // Light off dela y (5 00);

// (2) Generate random number

int number = random(1, 7);

// (3) Blink number times

for (int i = 0; i < number; ++i) { pixel.setColor(0, 255, 0, brightness); // G r e e n delay(blink D uration); pixel.setColor(0, 0, 0, 0); // Light off delay(blink Pause); }

// (4) Signal conclusion of rolling.

delay(blink D uration); // Pause at end

// somewhat longer

pixel.setColor(0, 0, 255, brightness); // Blue

// signals state of readiness

}



PROJECT 6

CodeGamer

CodeGamer manual inside english.indd 27 7/19/16 12:32 PM

Insert the line

Seri al.b e gin(115200);

s e t u p ()

Whenever you want to output something to the serial monitor, you can do that by using the commands

Seri al.pri nt()

and

Seri al.pri ntln()

. The difference

between the two versions is that

Seri al.pri ntln()

inserts an extra line break. The next output, in other words, starts on a new line.

Let’s take a look with the help of a little example:

void setup() { Serial.begin(115200); }

void loop() { Serial.print("Hello!"); dela y (5 00); }

Upload the program to your KosmoDuino. Nothing will seem to happen. Now click on the magnifying glass symbol at the top right of the Arduino environment. A new window will open for the serial monitor.

At first, you will probably just see some funny symbols. You can fix that in a jiffy by setting the transmission rate correctly. At the bottom right in the serial monitor, you will find a drop-down list with a “115200 baud” option. Select that, and you should see one “Hello!” after another appear in the window.

▲

A click on the magnifying glass at the

upper right will launch the serial monitor.

▲

If the wrong baud rate is set (9600 baud in this

case), you will only see a jumble of symbols.

▲

Once the right transmission rate is set, you can

receive “messages” from the KosmoDuino.

</>

чффхфхххфхфххфххфхххфххъъъффхххххфф

Hello!H ell o!H ell o!

115200 Baud

9600 Baud

Senden

No line ending

The serial monitor

YOU WILL NEED

› KosmoDuino › Computer › USB cable

THE PLAN

With the help of the serial monitor, you can send yourself a brief message from your KosmoDuino and have it appear on your computer screen.

To be able to use the serial monitor, proceed as follows:

THE PROGRAM



PROJECT 7

CodeGamer manual inside english.indd 28 7/19/16 12:32 PM

Now close the serial monitor. In the main loop, replace the request

Seri al.pri nt("Hello!");

with

Seri al.pri ntln("Hello!");

void loop() { Serial.println("Hello!"); dela y (5 00); }

Load the changed program to the controller and restart the serial monitor. Each “Hello!” now gets its own line.

Seri al.pri ntln()

doesn’t just let you output previously determined messages, though. It can also output newly determined measurement readings. You will learn about that in the project “Thermometer,” on page 33.

▲

Unlike with Serial.print() you always get a new line with the

Serial.println() output..

</>

Hello! Hello! Hello! Hello! Hello! Hello! Hello! Hello! Hello! Hello!

115200 Baud

Senden

No line ending

NOTE!

If you try to load a program to your KosmoDuino while the serial monitor is open, you may sometimes get an error message. If that happens, close the serial monitor and try uploading the program again.



CodeGamer

PROJECT 7

CodeGamer manual inside english.indd 29 7/19/16 12:32 PM

The for loop

When parts of a program are repeatedly carried out, you call that a loop. You already learned about one import kind of loop — the main loop,

lo op ()

. Your KosmoDuino uses that to handle the most important tasks in your program. It reads out input pins, processes the measurement data, and then responds — over and over again from the beginning.

You may often prefer, however, not to get caught in an endless loop, and you might rather have just a certain number of repetitions. For that, you can use a

for

loop.

You will usually be using it in the following manner as a so-called counting loop:

i < 20;

This is the test condition: Before each pass through the loop, this condition is checked. If the condition is met, the loop is passed through, meaning that the entire program code inside the curly brackets is carried out. If the condition is not met, the loop is abandoned: The program code in the curly brackets is not carried again. Instead, the program continues with the next instruction following the loop.

++i

First of all, this is an abbreviation for

i = i + 1

. The

value of the counter variable i in other words, is increased by 1. But when? After each pass through the loop!

As long as the value of the counter variable

is not

changed, the following is what happens:

Before the first pass, i has the value 0. That is less than

20. So the test condition is met, and the loop is passed through. After the instructions in the loop body have been carried out, the value of the counter variable is raised by 1. The value of i is now 1. The condition is still met, the loop body is carried out, i is raised by 1 again and so on and so forth. If i finally has the value of 19, the loop body is carried out one more time and i is then increased to the value of 20. The test condition is then no longer met, and the loop is abandoned.

How often has the loop body now been carried out? It has been carried out for the following values of the counter variable i: 0, 1, 2, 3, ..., 19. The numbers 1 to 19 yield 19 passes, and one more pass is added for the value 0. So there are 20 passes in all!

The counter variable, by the way, is not just there to count. You can use its current value at any time in the loop body. If, for example, you want to output all numbers from 1 to 42 on the serial monitor, you can do as follows:

for (int i = 0; i < 20; ++i) { Instruction 1; Instruction 2; ... }

What does that mean? The loop is introduced by the word

for

. The instructions that are carried out repeatedly are

in the block inside the curly brackets. This block with the instructions to be repeated is often called the loop body. For the loop to know how often to repeat these instructions, the

for

loop needs some more information — which you can find inside the parentheses. Let’s take a closer look:

int i = 0;

This is known as the initialization of the loop. Before the loop is run through the first time, you apply the counter variable i and give it the value of 0. You can give the counter variable any name and starting value you like. As long as the counter variable has no special meaning, you usually use the letters i, j, and k as names. As a rule, you generally start with the starting value of 0.

// Outputs the numbers 1, 2, 3,..., 42:

for (int i = 1 ; i <= 42; ++i) { Serial.println(i); // Outputs the current

// value from i

}



THE FOR LOOP

CodeGamer manual inside english.indd 30 7/19/16 12:32 PM

Here, the loop starts with 2 and

i = i + 2

raises the

counter variable by 2 after each pass through the loop.

Here, the loop starts with the starting value of 1. This time, instead of testing whether

is less than 42, it tests whether i is less than or equal to 42. That means that the loop is also passed through one more time for the value of

42. But it also works in the opposite direction:

// Outputs the numbers 42, 41, 40, ..., 1:

for (int i = 42; i >= 1; --i) { Serial.println(i); }

The loop starts with the value of 42. It keeps running through as long as i has a value that is greater or equal to 1. The

--i

means that i is reduced by 1 after each pass through the loop. In other words, it counts backwards.

// Outputs the numbers 2, 4, 6, ..., 42:

for (int i = 2; i <= 42; i = i + 2) { Serial.println(i); }

You can actually use any instructions you like in place of

++i

--i

. For example, you can just use even numbers:



THE FOR LOOP

CodeGamer

CodeGamer manual inside english.indd 31 7/19/16 12:32 PM

Temperature sensor

Motion sensor

Sound sensor

Light sensor

Sensors

So far, you have learned how your KosmoDuino can react to the push of a button. In this experiment kit, though, you will also find a lot of sensors that can be used to help your microcontroller respond to its environment. These are the KosmoBits modules!

Your controller can use the temperature sensor to monitor the temperature, while the light sensor monitors brightness. The motion sensor lets you record even the slightest movements of the KosmoDuino, and the sound sensor lets you listen for noises.

But how does the KosmoDuino get the information from the sensors? How does it learn how warm or how bright it is?

Simple: The sensors relay their measurement readings to the microcontroller in the form of electrical voltage. The microcontroller can then read this voltage through one of the pins. A lot of the pins can do a lot more than distinguish “on” from “off.” They can also measures different voltage levels. That’s what is handled by the order

analogRead()

, which lets you determine the voltage at a pin. The result is a numerical value from 0 to 1023. The higher the voltage arriving at a pin, the greater the numerical value. 0 indicates no voltage at all, while 1023 indicates 5 volts.

Of course, you will also have to tell

analogRead()

which

pin to read. In general, it will be the

KOSMOBITS_SENSOR_PIN

, which is defined in the

KosmoBits_Pins.h

file. So you should always link this

file with

#include <KosmoBits_Pins.h>

if you want to

access the KosmoBits sensor modules.

You have already learned about the serial monitor. It’s an important tool for working with the sensors. See the next projects to find out why.



SENSORS

CodeGamer manual inside english.indd 32 7/19/16 12:32 PM

Thermometer

YOU WILL NEED

› KosmoDuino in the interaction board › Temperature sensor

PREPARATION

Mount the temperature sensor on the interaction board.

THE PLAN

In this project, you will be turning your KosmoDuino into a thermometer for measuring the temperature with the help of the temperature sensor. The temperature is output via the serial monitor.

The program is easy to explain. The

analogRead()

portion ensures that the voltage is repeatedly read at the

sensorPin

. The measurement reading is then output

through the serial monitor. You will be using this program

whenever you want to learn about a new sensor.

So open the serial monitor and take a look at the measurement readings. Place your finger on the black dot sticking up out of the sensor housing. You should see the measurement readings change. It won’t yet look like a temperature reading, though. You still have to convert the measurement readings into temperatures. The KosmoBits library can help you with that. It includes a function for that very task, called

thermistor_measure m ent_in_celsius()

To use this function, you will first have to link the

KosmoBits_Thermistor.h

file.

#include <KosmoBits_Pins.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN;

void setup() { pinMode(sensorPin, INPUT); Serial.begin(115200); }

void loop() { int value = analogRead(sensorPin);

Serial.print("measurementReading: "); Seri al.pri n tln(v alu e); delay(1000); }

</>

THE PROGRAM

Now, write the following code and upload it to the controller:

◀

Board with temperature sensor



CodeGamer

PROJECT 8

CodeGamer manual inside english.indd 33 7/19/16 12:32 PM

SO CHANGE YOUR PROGRAM LIKE THIS:

Close the serial monitor, upload the program, and reopen the serial monitor. You will see that the current temperature is now being output at regular intervals.

#include <KosmoBits_Pins.h> #include <KosmoBits_Thermistor.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN;

void setup() { pinMode(sensorPin, INPUT);

Serial.begin(115200); // Enable output via

// serial monitor.

}

void loop() { int measurement = analogRead(sensorPin); float celsius = thermistor_measurement_in_ celsius(measurement); // C o n v e r t

// measurement into degrees Celsius.

Serial.print(celsius); // Celsius value

// is output.

Serial.println(" degrees Celsius"); // Output

// of"Degrees Celsius" and line break.

delay(1000); }

</>



PROJECT 8

CodeGamer manual inside english.indd 34 7/19/16 12:32 PM

You have already learned a little about numbers and variables that can incorporate numbers. They aren’t

much use, however, if you can’t use them to calculate. After all, you will normally be using your KosmoDuino to read a numerical value from a sensor and then using

that to control something else. To do that, you have to be able to calculate another numerical value from the measurement.

In the Arduino programming language, all the basic

calculation types are available to you for this. For

adding and subtracting, you use the typical “+” and “-“ symbols. For multiplication, use a star (“*”). For division, use a simple forward slash (“/”).

By the way, you can also use the previous value of a

variable to calculate something new with it:

There is even an abbreviation for the frequently used

calculation step

i = i + 1;

CALCULATING IN THE PROGRAM:

// Addition (plus)

int x; // x is a whole number. x = 1 + 4; // x has the value 5.

// Subtraction (minus)

x = 5 - 3; // x has the value 2.

// Multiplication (times)

x = 3 * 4; // x has the value 12.

// Division (divided by)

x = 12 / 6; // x has the value 2.

// Follow order of operations

x = 4 * 3 + 2; // x has the value 14.

int x = 4; x = x + 2; // x has the value 6.

x = 2 * x; // x has the value 12.

int i = 0; i++; // means x = x + 1.

++i; // also means x = x + 1.

KNOWLEDGE BASE



CodeGamer

CodeGamer manual inside english.indd 35 7/19/16 12:32 PM

THE PROGRAM

Finger disco

YOU WILL NEED

›

KosmoDuino in the

interaction board

› Motion sensor

PREPARATION

With the motion sensor, your KosmoDuino will be able to record even the tiniest movements. To develop the proper feel for it, start by inserting the motion sensor into the interaction board. Then upload the “ReadSensor” sketch to your KosmoDuino.

You will now be able to observe the motion sensor’s readings in the serial monitor. As long as you do not move the controller, the reading will just fluctuate slightly around an average value.

Now try moving the controller in different directions and rotating and tipping it. You will see how there are movement and rotation directions that cause the reading to change sharply. In other directions the reading may hardly change at all.

Now try drumming gently, and then somewhat more strongly with your fingers on the interaction board housing.

Start by linking to the required libraries via the

#include

instructions, defining the

sensorPin

to be able to read

the sensor readings, and defining the

pixel

in order to be

able to control the NeoPixel.

To be able to recognize deviations from a resting state, you still have to define the

restingValue

variable. The

resting average will be saved there.

#include <Adafruit_NeoPixel.h> #include <KosmoBits_Pins.h> #include <KosmoBits_Pixel.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN; Kosm oBits_Pi xel pixel;

int restingValue = 0;

In fact, the sensor merely measures the sensor’s acceleration along the so-called z-axis, or the “forwardand-backward axis.” That’s why the reading changes when you move the controller away from you or back towards you. Up-and-down movements, on the other hand, will not change the reading

▲

Fingers drum on the board and the NeoPixel blinks.

Even though the shaking caused by your fingers is very slight, it is registered by the sensor. If you place the controller on a table, you can even trigger the sensor by just drumming on the table.

We can make use of this to turn your KosmoDuino into a finger-drumming disco lighting device. To do that, use the following program:

THE PLAN

Bright lights dancing in rhythm to your fingers. With this project, you will be able to turn your KosmoDuino into a

Finger Disco.



PROJECT 9

CodeGamer manual inside english.indd 36 7/19/16 12:32 PM

int determineRestingValue() { const int N = 20; // measurement numbers float average = 0; for (int i = 0; i < 20; ++i) { average = average + analogRead(sensorPin); dela y (1 0); } average = average / N; return average; }

void setup() { pinMode(sensorPin, INPUT); restingValue = determineRestingValue(); }

void loop() { int value = analogRead(sensorPin); int difference; if (value > restingValue) { difference = value - restingValue; } else { difference = restingValue - value; }

pixel.setColor(2 * difference, 100 - 2 *

difference, 0, difference); // RGB value and

// b r i g h t n e s s .

dela y (1 0); }

</>

To determine the resting value, calculate the average of 20 readings. The number of readings will be saved in the N constant, so it can easily be changed. The average is stored in the

average

variable.

You know all about the

for

loop now. It will be passed

through N times, or 20 times in this case.

With each pass through the loop, another measurement reading will be added to the current

average

. There is a

pause of 10 milliseconds before each subsequent reading

When the loop is abandoned, the sum of the 20 measurement readings is saved in the

average

variable. To calculate the average from that, the total must be divided by the number of readings. That happens in the

average = average / N;

line.

Finally,

return average;

returns the calculated

average.

It’s simple:

pinMode(sensorPin, INPUT);

sets the

sensorPin

as the input pin. Finally, the resting value is

calculated and stored in the

restingValue

variable.

In the main loop, a current sensor value is first read and saved in

valu e

. Now it’s time to determine the deviation

from the average and save it in the

differen ce

variable. The deviation always has to be positive. Since you don’t know if the current sensor reading is greater than or less than

restingValue

, the if instruction will be used to

decide between two cases: If

valu e

is greater than

restingValue, differen ce

is calculated as

valu e - re stingValue

; otherwise, it is calculated as

restingValue - value

Now,

pixel.setColor()

is used to set the NeoPixel color

independently of the

differen ce

value: The greater the difference, the higher the red portion, and the lower the green portion.

Do you have your own ideas about how the NeoPixel color should react

to the deviation from the resting value? Try it! You’re sure to come up with all sorts of interesting

variations.



PROJECT 9

CodeGamer

CodeGamer manual inside english.indd 37 7/19/16 12:32 PM

</>

Cheep!

You can also use the interaction board to produce sounds. This little project will show you how it works.

YOU WILL NEED

› KosmoDuino

in the interaction board

THE PLAN

So far, the KosmoDuino just beeps at regular intervals. Don’t worry — you will learn how to turn it into a siren or even a musical instrument.

THE PROGRAM

Start by including the

KosmoBits_Pins.h

file and

defining the

buzzerPin

constant in order to address the pin to which the “buzzer” (the miniature speaker) is connected.

#include <KosmoBits_Pins.h>

const int buzzerPin = KOSMOBITS_BUZZER_PIN;

void setup() { // Nothing to do. }

void loop() { tone(buzzerPin, 440); dela y (5 00); noTone(buzzerPin); dela y (5 00); }

This time, you won’t have to do anything in

s e t u p ()

The composition of the

lo op ()

will probably look familiar to you. It matches the “Blink” program, which was the very first program that you uploaded to your KosmoDuino. But this time, instead of making an LED blink, you will be making sounds. These two commands will help:

tone(buzzerPin, 440);

produces a tone with a frequency of 440 Hz. This is the standard pitch of A. The tone stays on until you switch it off again with

noTo n e(buzze rPi n);

To switch the tone on and off again

at regular intervals, use

del a y(5 0 0);

to attach a half-

second pause to each of these commands.



PROJECT 10

CodeGamer manual inside english.indd 38 7/19/16 12:32 PM

Infrasound Audible

Frequencies

Ultrasound

</>

Random sounds!

You just learned in the “Cheep!” project how to make your KosmoDuino start beeping. But it can get a little boring listening to the same tone over and over. Here’s where you learn how to get random sounds out of your controller.

YOU WILL NEED

› KosmoDuino

in the interaction board

THE PLAN

The random generator will determine the pitch of the tones as well as their duration.

THE PROGRAM

The program is pretty simple. In

s e t u p ()

, you give the random generator a starting value just as you did in the die-rolling project.

Then, in the main loop,

int freq = random(110,1000);

randomly determines the frequency (

freq

) of the next

tone, and then its duration in the same manner.

Finally, the tone is output with

to n e(buzzer Pin,fre q);

At the end,

del a y(d a u e r);

ensures that the tone is played

for the duration indicated by

duration

#include <KosmoBits_Pins.h>

const int buzzerPin = KOSMOBITS_BUZZER_PIN;

void setup() { randomSeed(analogRead(12)); }

void loop() { int freq = random(110, 1000); int duration = random(10, 150); tone(buzzerPin, freq); delay(duration); }

SOUND

When the air pushing against our ear drums vibrates back and forth, we perceive it as sound. The faster the air vibrates, the higher the sound. Physicists measure that as “vibrations per second,” or frequency. The unit of frequency is known as a Hertz, abbreviated Hz. One Hertz means that the air completes one full oscillation (vibration back and forth) per second. The higher the frequency of a sound, the higher the pitch of the sound we hear. Humans can perceive sounds with frequencies between 16 and 20,000 Hertz. A lot of animals, on the other hand, are able to perceive sounds in the infrasonic and ultrasonic range.



CodeGamer

PROJECT 11

CodeGamer manual inside english.indd 39 7/19/16 12:32 PM

</>

Siren

Now it’s time to bring some order to the acoustic chaos. This project will let you make your KosmoDuino howl like a siren.

YOU WILL NEED

› KosmoDuino

in the interaction board

Here’s where you specify the frequency range within which the sound pitch is to move.

FREQ_MIN

corresponds

to the deepest sound of the siren, and

FREQ_MAX

the highest. You can also experiment with these parameters by changing the values, and find a siren noise to suit your taste.

DEL AY

determines how long any given sound will be held.

The variable

freq

finally, saves the current frequency.

The siren starts at

FREQ_MIN

#include <KosmoBits_Pins.h>

const int buzzerPin = KOSMOBITS_BUZZER_PIN; const int FREQ_MIN = 440; const int FREQ_MAX = 660; const int DELAY = 4;

int freq = FREQ_MIN; // Frequency of the sound

// that is output.

void setup() { // Nothing to do here. }

void loop() { tone(buzzerPin, freq); // (1) del ay(DE L AY); ++freq; // Short for: freq = freq + 1; if (freq > FREQ_MAX) { freq = FREQ_MIN; } }

This time, you won’t have to do anything in

s e t u p ()

The main loop starts by outputting a sound with the frequency

freq

(1). After a pause of length

DEL AY

, the

frequency

freq

is raised by 1 with

++ fr e q;

. The

instruction then checks whether the maximum frequency has been exceeded. If so, the frequency

freq

is returned to

the starting value

FREQ_MIN

In the next project, you will be producing an entire musical scale. But first you will have to learn about an important programming tool: Arrays.

THE PLAN

With every pass through the main loop, a new sound will be output. Each time, the pitch will be raised a little. Once a certain frequency, or sound pitch, is attained, the pitch drops back to its starting value and the whole thing starts over from the beginning.

THE PROGRAM



PROJECT 12

CodeGamer manual inside english.indd 40 7/19/16 12:32 PM

Arrays

If you want to save a lot of values of the same type, for

example the last 100 values, it can be pretty timeconsuming and confusing to have to enter all that in. You would have to apply a separate variable for each

individual value, as follows:

int value 1;

int value 2; int value 3; ...e tc... int value 100;

It’s a lot simpler to use what’s called an array.

In an array, you can store many values at one time. To

make it possible to access the individual variables in

the array, they are all consecutively numbered. So you can think of an array as a kind of table in which the individual values are entered into numbered columns.

The numbering of the columns, however, starts with 0 rather than 1:

INDEX 0 1 2 3 … n

VALUES Value 0 Value 1 Value 2 Value 3 … Value n

In general, an array is created as follows:

type arrayName[length];

You can also assign values to an array by specifying the individual values in curly brackets:

The type specifies which type of data can be saved in the array (int, float, etc.). The number of values that can be

stored in an array is known as its length.

int myArray[10]; // An array that can

// take 10 int values

int myArray[4] = {0, 4, 2, 3};

In that case, you don’t necessarily have to indicate how many values there are. You can also write:

int myArray[] = {0, 4, 2, 3};

So, for example, to create an array that can take 10

integer values, you proceed as follows:

KNOWLEDGE BASE

An array is sometimes called a Field or Data Field. However the term Array is

the much more common name.



CodeGamer

CodeGamer manual inside english.indd 41 7/19/16 12:32 PM

You will often want all individual values to be set to

zero. You can do that quickly by writing as follows:

int myArray[10] = {}; // Array of

// length 10 with all the values

// set to 0.

To access the individual values of an array, you indicate the value in square brackets for the index that you want

to access. So if you think of the array as a table, the index corresponds to the column number.

int myArray[100] = {}; // Array of

// length 100 with all values set to 0.

myArray[2] = 42; // The value at index

// position 2 is now 42.

int x = myArray[2]; // x contains the

// value saved at index position 2 // in myArray, in this case it is 42.

You may often want to calculate a new value from all

the individual ones, for example the sum of all individual values. Since you can now address the

individual values via their index, you can easily do this

with a

for

loop:

// values is an array of length 100.

int sum = 0;

for (int index = 0; index < 100; ++i n d e x) {

um = sum + values[index];

}

With the first pass through the loop, the value

va l u e s[0]

is added to

sum

. Then,

index

is raised by

1, and the next value is added. This is repeated until the last value (

val u e s [9 9]

) has been added.

In the next project, you will use an array to play a musical scale.

NOTE!

Since the index for the first value is 0 rather than 1, the

highest possible index for an array of length N is not N, but rather N-1. With an array of length 100, in other words, the highest possible index would be 99. If you use

a higher index, it will result in an error in the program sequence. It’s impossible to predict what would happen

then. So be careful only to use valid values for the index.

KNOWLEDGE BASE



CodeGamer manual inside english.indd 42 7/19/16 12:32 PM

</>

Musical scale

YOU WILL NEED

› KosmoDuino

in the interaction board

THE PLAN

Your KosmoDuino will play a musical scale.

THE PROGRAM

First you include the

KosmoBits_Pins.h

file and define

the

buzzerPin

and

freqRoot

constants. Finally, you

apply the

sc al e[]

array, in which the frequency relationships of the notes of a major-key scale will be placed. To determine the frequency of a note, you will have to multiply the corresponding value by the frequency of the root chord.

#include <KosmoBits_Pins.h>

const int buzzerPin = KOSMOBITS_BUZZER_PIN; const int freqRoot = 220; // This is the

// note A (one octave deeper than the standard // pitch A from project 10).

float scale[] = {1.f, 9.f/8, 5.f/4, 4.f/3, 3.f/2,

5.f/ 3, 1 5.f/8, 2.f };

void setup() { for (int i = 0; i < 8; ++i) { tone(buzzerPin, scale[i] * freqRoot); dela y (5 00); } noTone(buzzerPin); }

void loop() { // Nothing is done here. }

This time, everything is happening in

s e t u p ()

. In the

for

loop, the variable i is counted up from 0 to 7. For each value of i then, the i-th note of the scale is output with

tone(buzzerPin, scale[i] * freqRoot);

. As

described above, the frequency of the root chord

freqRoot

is multiplied by the corresponding frequency

relationship

scal e[i]

to determine the right frequency.

After a pause, the

for

loop is passed through again until

the highest note of the scale is reached. Then it’s quiet:

noTo n e(buzze rPi n);

This time, nothing is done in the main loop. The scale is just played through a single time, in other words. To make the scale play again, you can press the reset button on the KosmoDuino. That will reset the code and carry it out again from the beginning.



PROJECT 13

CodeGamer

CodeGamer manual inside english.indd 43 7/19/16 12:32 PM

Sensor organ

Now that you have learned how to play musical scales, it’s time to program an actual musical instrument.

YOU WILL NEED

› KosmoDuino in the interaction board › Motion sensor

#include <KosmoBits_Pins.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN; const int buzzerPin = KOSMOBITS_BUZZER_PIN; const int buttonPin = KOSMOBITS_BUTTON_2_PIN;

const float scale[] = {1.f, 9.f/8, 5.f/4, 4.f/3,

3.f/ 2, 5.f/ 3, 1 5.f/ 8, 2.f}; const int freqRoot = 220; // This is the

// note A.

const int measurementMin = 300; const int measurementMax = 400; const int scaling = (measurementMax measurementMin) / 9;

const int N = 10; // Number of values that

// are averaged.

int values[N] = {}; // Here is where the last

// 10 values are stored.

int index = 0;

This is where each of the pin modes is set. void setup() {

pinMode(sensorPin, INPUT); pinMode(buttonPin, INPUT); }

void loop() {

// Reads a new value from the sensor and // saves it in values[].

values[index] = a nalog Read(sensorPin);

First, you will define a few constants for sensor pin, buzzer pin, and button pin. Then, as you did in the last project, you will apply an array for the scale as well as a constant for the root chord.

With the

measurementMin

and

measurementMax

constants, you will be regulating how far the controller has to be tipped in order to play the highest or the lowest note. You can adjust these values to suit your own preferences later on. You will be using the

scaling

constant later on to determine the pitch from a measurement reading, dividing practically the entire measurement range into 9 portions.

The motion sensor is quite sensitive, so the readings will fluctuate a little. To keep the pitch from wavering too much, you won’t be taking the last reading to measure the pitch. Instead, you will be calculating the average of 10 readings. The last 10 measurement readings will be saved in the

val u es[]

array for this purpose. All values in it will

first be set to 0 by

int values[N] = {};

With the

index

variable, the array will be run through,

starting with 0 as usual.

THE PLAN

You will produce musical notes at the push of a button. The pitch of the note can be changed by moving the interaction board. With a little practice, you can play an actual melody this way.

</>

THE PROGRAM

You will start by taking a new measurement reading and saving it in the

valu es

array at the

index

position. To ensure that the next measurement reading is saved at the subsequent position,

++ ind e x;

raises the

index

by 1. If

the value of N is reached, the if instruction sets

index



PROJECT 14

CodeGamer manual inside english.indd 44 7/19/16 12:32 PM

Admittedly, this was a little more involved. But the results make it all worthwhile!

// Raise the index by 1, so the next // value can be saved at the next location // in the values[] field.

++in dex;

// If index == N, the field is // fully described. // index is then set to 0, so that // the oldest value // is overwritten in the next pass.

if (index == N) { index = 0; }

// Now the average of the last N // measurement readings is calculated.

int average = 0; // Start with the value 0

// Total the measurement values.

for (int i = 0; i < N; ++i) { average = average + values[i]; } // Divide the total by the number of values. average = average / N;

int noteIndex = (average - measurementMin) / sc aling;

// noteIndex must not be less than 0 or // greater than 7:

if (noteIndex < 0) { noteIndex = 0; } else if (noteIndex > 7) { noteIndex = 7; }

// Output note if (digitalRead(buttonPin) == LOW) { tone(buzzerPin, scale[noteIndex] * freqRoot); dela y (1 0); } else { noTone(buzzerPin); dela y (1); } }

</>

back to 0. The array is filled from the beginning again.

Then it’s a matter of determining the average of the last 10 measurements. To do that, the

average

variable is first

set to 0. In the

for

loop, then, all the values saved in the

val u e[]

array are added to

average

. To calculate the average from that, the result has to be divided by the number of values:

average = average / N;

With

int noteIndex = (average - m easure ment Min) / scaling;

, you will be determining the “note index”: Which note in the scale sequence should be played?

It might happen that

noteIndex

has an invalid value — in other words, that it is less than 0 or greater than 7. That’s why you will be correcting it with the

if-else

instruction in case of doubt.

Finally, the last if query checks whether the button is pushed. If so, the corresponding note is output. If not, no note is output.



CodeGamer

PROJECT 14

CodeGamer manual inside english.indd 45 7/19/16 12:32 PM

There isn’t a whole lot that the code does. With each pass of the main loop, a new value is read by the sensor pin and output by

Seri al.pri ntln()

#include <KosmoBits_Pins.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN;

void setup() { pinMode(sensorPin, INPUT); Serial.begin(115200); }

void loop() { Serial.println(analogRead(sensorPin)); }

The serial plotter

YOU WILL NEED

› KosmoDuino in the interaction board › Sound sensor

THE PLAN

The sound sensor is basically a small microphone that you can read via the sensor pin. To understand how it works,

115200 Baud

Now start the Serial Plotter from the “Tools” menu. (If you do not see the Serial Plotter in the Tools menu, you may need to update your Arduino software to a newer version.)

A new window will open with some crazy-looking things happening.

Now try to make various sounds, such as whistling or singing. You will see how the image changes in the serial plotter.

The scale along the left edge makes it easy to read the magnitude of the values delivered by the sensor. In the example shown here, you can see that 0 is the lowest value. That should be obvious — after all

analogRead()

wouldn’t be able to deliver anything smaller. The largest measured reading is about 250. But if you clap your hands, the readings may rise to 800.

You will be able to make excellent use of this in your next project.

</>

THE PROGRAM

Plug the sound sensor into the interaction board and then upload the following little program to your KosmoDuino:

the best thing is to use another cool tool from the Arduino environment — the serial plotter.



PROJECT 15

CodeGamer manual inside english.indd 46 7/19/16 12:32 PM

Clap switch

Wouldn’t it be cool if your KosmoDuino could respond to clapping? You can easily program it to do that with the help of your sound sensor.

YOU WILL NEED

› KosmoDuino in the interaction board › Sound sensor

#include <KosmoBits_Pins.h> #include <Adafruit_NeoPixel.h> #include <KosmoBits_Pixel.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN; const int threshold = 500;

Kosm oBits_Pi xel pixel;

bool on = false;

s e t u p ()

, the pin mode of the sensor pin is set and the

NeoPixel is switched off.

void setup() { pinMode(sensorPin, INPUT); pi x el.setColor(0, 0, 0, 0); }

void loop() { int sensorValue = analogRead(sensorPin); Seri al.println(sens orValue); if (sensorValue > threshold) { t o g gl e (); dela y (20 0); } }

void toggle() { if (on) { pi x el.setColor(0, 0, 0, 0); on = false; } else { pixel.setColor(255, 0, 0, 30); on = true; } }

The usual files are linked and the

sensorPin

constant is

defined for the sensor pin. The

threshold

constant controls the sensitivity of your clap switch. If the value set there is exceeded by the measurement reading, the switch toggles over — either from “on” to “off” or vice-versa. In the on variable, you will be storing the current state of the NeoPixel. If it is on, the variable is assigned the value

true

, otherwise it is assigned the value

false

. At the

beginning of the program, the NeoPixel is off:

bool on = false;

</>

THE PROGRAM

In the main loop, the sound sensor is continuously read. If the measured value is greater than the value set in

threshold

, the

to g gl e ()

function is invoked and there

is a brief pause.

Here, you will write your own

vo i d t o g g l e()

function. This queries whether the NeoPixel is currently on. If so, the NeoPixel is switched off and on is assigned the value

false

. Otherwise (“else”), the NeoPixel is switched on and on is assigned the value

true

In brief:

to g gl e ()

does exactly what its name suggests. It

switches back and forth between “on” and “off.”

THE PLAN

If you clap once, it turns on the NeoPixel on the interaction board. If you clap again, it turns off.



PROJECT 16

CodeGamer

CodeGamer manual inside english.indd 47 7/19/16 12:32 PM

Drawer monitor

Have you ever had the suspicion that your brother or sister might be secretly looking through your things when you’re not home? With this drawer monitor, you will be able to catch them! And the best thing about it is that the perpetrator won’t even know that the drawer is under surveillance. There is no alarm, and nothing to indicate to the culprit that his deed has been noticed. It is only when you ask the KosmoDuino that you will know whether someone has been peeking around!

YOU WILL NEED

› KosmoDuino

in the i

nteraction board

› Light sensor

THE PLAN

It’s dark inside a closed drawer, and bright in an open one. So you can use a light sensor to tell whether your drawer has been opened or not.

You will be programming your KosmoDuino to do the following:

1. After it is switched on, it will wait for a push on button 1 to be armed.

2. Once the drawer monitor is armed, it will wait for the drawer to be closed. That’s when it will start guarding the drawer.

3. If the drawer is opened again, there are two possibilities for what will happen then:

a) If the drawer is closed again, it will count as “drawer

was opened.”

b) If you push button 2, the NeoPixel will show you how

often it was opened.

PREPARATION: MEASURING SENSOR VALUES

To know whether the drawer has been opened or not, you will be using the light sensor. It measures the brightness of the light that falls on it. As long as your KosmoDuino is in the darkness, the reading that it takes will be low. If the drawer is opened, though, the measurement will rise. Unfortunately, it is rarely completely dark in any closed

drawer. What level of brightness signals that the drawer has been opened? Try to find out! Start by inserting your light sensor into the interaction board. Now you have to find out how bright it is in daylight. Do that by reading the sensor and outputting the reading through the serial monitor. As usual, you will do it with the ReadSensor sketch on page 33.

Note down the readings output by the sketch when you:

• set the light sensor out under daylight,

• set the light sensor out at dusk,

• cover the sensor completely with your hand,

• shine a flashlight on the sensor.

LIGHT READING

Daylight

Dusk

Shaded

Flashlight

You will need these readings later on when you think about when the drawer should count as closed.



PROJECT 17

CodeGamer manual inside english.indd 48 7/19/16 12:32 PM

THE MATRIX

In this project, we will be using the NeoPixel and both buttons. So we will link to the required libraries here.

#include <Adafruit_NeoPixel.h> #include <KosmoBits_Pins.h> #include <KosmoBits_Pixel.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN; const int button1Pin = KOSMOBITS_BUTTON_1_PIN; const int button2Pin = KOSMOBITS_BUTTON_2_PIN;

int button1 = HIGH; int button2 = HIGH; int sensorValue = 0;

enum Mode {IDLE, COUNTDOWN, WAIT_UNTIL_DARK, CLOSED, OPEN};

Mode mode = IDLE;

const int DARK_VALUE = 100; unsigned long counter = 0; Kosm oBits_Pi xel pixel;

void reset() { pixel.setColor(0, 0, 0, 0); // Pixel off

mode = IDLE; counter = 0; Serial.println("Reset!"); }

</>

We are defining three constants for reading the sensor and the buttons, as well as the three variables

button1

button2

, and

sensorValue

, which will store the current

measurement readings.

To make sure the program code remains clear, it helps to think of the program as a machine that can be operated in various operating modes. Different things happen in the main loop depending on the mode.

For that purpose, we are using

enum Mode

to define a so-

called enumeration type: a variable of the

Mode

type can

only take the values written between the curly brackets —

IDLE, COUNTDOWN

, etc.

Next, we define the

mode

variable in which the current

operating mode is stored. We begin in

IDLE

mode.

The

DARK_VALUE

constant specifies the lowest light sensor reading at which the drawer should start to count as open. A lot of drawers will let in a little light even when they are closed. So adjust the value to what makes sense for yours. The readings that you took in your preliminary work should help!

The

counter

variable stores the number of times the

drawer is opened. Finally,

pixel

gives us access to the

NeoPixel.

When the surveillance is over, we will want to return to the starting state — as if we had just turned on the KosmoDuino. For that, we are introducing the

r e s e t ()

function. The NeoPixel is switched off,

mode

is set to

IDLE

and

counter

back to 0. As a check, “Reset!” is

output via the serial interface.



PROJECT 17

CodeGamer

CodeGamer manual inside english.indd 49 7/19/16 12:32 PM

void setup() { pinMode(sensorPin, INPUT); pinMode(button1Pin, INPUT); pinMode(button2Pin, INPUT); Serial.begin(115200); reset(); }

void loop() { sw itc h (m o d e) { case IDLE: loopIdle(); break; case COUNTDOWN: loopCountdown(); break; case WAIT_UNTIL_DARK: l o o p U n t i l D a r k (); break; case CLOSED: loopClosed(); break; case OPEN: loopOpen(); break; } }

</>

s e t u p ()

as usual, we determine the operating modes of the pins being used and initialize the output through the serial interface. Then,

r e s e t ()

is invoked to return the

drawer monitor to its starting state.

In the main loop, depending on operating mode, different loop functions may be invoked. The

swit c h(m o de)

instruction handles that, introducing a case differentiation. For each case, or possible

mode

value, a

different function is invoked:

• If

mode

has the value

IDLE

loopIdle()

is invoked.

• If

mode

has the value

COUNTDOWN

loopCountdown()

is invoked, etc.

The

break;

instruction is important here for breaking off the treatment of a case and ending the case differentiation. Without the

break;

instruction, the code

for the next case would also be carried out.

That ends the basic skeleton of our program. Now we will just have to think about what exactly we want the drawer monitor to do in its various operating modes.

◀

Board with light sensor



PROJECT 17

CodeGamer manual inside english.indd 50 7/19/16 12:33 PM

void loopIdle() { Serial.println("Idle"); bool pressed = false; while(digitalRead(button1Pin) == LOW) { // Button 1 was pressed.

// Wait for it to be released again.

pixel.setColor(0, 255, 0, 25); pressed = true; dela y (5 0); } if (pres s e d) { mode = COUNTDOWN; } }

void loopCountdown() { const int COUNTDOWN_NUMBER = 5; Serial.println("Countd own"); pixel.setColor(0, 0, 0, 0); // Pixel OFF dela y (5 00); // The actual countdown: Like Blink. for (int i = 0; i < COUNTDOWN_NUMBER; ++i) { pixel.setColor(0, 255, 0, 25); // G r e e n dela y (5 00); pixel.setColor(0, 0, 0, 0); // Pixel off dela y (5 00); } pixel.setColor(255, 0, 0, 25); // R e d delay(1000); pixel.setColor(0, 0, 0, 0); // Pixel off mode = WAIT_UNTIL_DARK; }

</>

By now you probably have a pretty good understanding of the code. The

pressed

variable remembers whether the

button was pressed. If button 1 is pressed, the

w h i l e()

loop is run through: The NeoPixel glows green, and the

pressed

variable is set to the

true

value. When button 1

is released, the

w h i l e()

loop is abandoned. Finally, the

if ()

instruction tests whether the button was pressed. If

so, the mode is set to

COUNTDOWN

. Otherwise,

loopIdle()

is quit and the main loop is invoked again. It

in turn invokes

loopIdle()

again, since the mode hasn’t

changed.

IN IDLE

When in its idle state, the drawer monitor is waiting for button 1 to be pushed before it starts monitoring. What’s responsible for that is the

loopIdle()

function, which is

invoked by the main loop in

IDLE

mode.

COUNTDOWN

Here, too, you will be familiar with most of the code. First, the

COUNTDOWN_NUMBER

determines how many seconds the countdown should last: 5 seconds, in this case. The NeoPixel is turned off and after 500 milliseconds the actual countdown is started in the

fo r ()

loop: 5 times “on — wait — off.” Then, the NeoPixel is set to “red” for one second (1000 milliseconds). Finally, the mode is set to

WAIT_UNTIL_DARK

and

loopCountdown()

is quit.

void loopUntilDark() { Seri al.println("Wait until dark"); while (analogRead(sensorPin) > DARK_VALUE) { dela y (1 0); } mode = CLOSED; delay(1000); }

WAIT_UNTIL_DARK

This is easy: It keeps running through the

while

loop as long as it’s dark. Measurements are taken every 10 milliseconds. When the

w h i l e()

loop is abandoned, the

mode is set to

CLOSED

and

loopUntilDark()

is quit.



PROJECT 17

CodeGamer

CodeGamer manual inside english.indd 51 7/19/16 12:33 PM

void loopClosed() { Seri al.println("In the dark"); sensorValue = analogRead(sensorPin); if (sensorValue < DARK_VALUE) { // It is

// still dark.

delay(1000); // Wait 1 second, loop() invokes

// this function again.

} else { // It is bright! Check again

// after 0.5 seconds.

dela y (5 00); if (analogRead(sensorPin) >= DARK_VALUE) { // It is bright: drawer opened! mode = OPEN; } } }

void loopOpen() { Serial.println("Opened"); dela y (5 0); button2 = digitalRead(button2Pin); sensorValue = analogRead(sensorPin);

if (button2 == LOW) { output(); } else if (sensorValue < DARK_VALUE) { // Drawer closed again. ++counter; mode = CLOSED; } }

</>

MONITORING (CLOSED

)

The actual monitoring of the drawer happens in

CLOSED

mode, i.e. in

loopClosed()

. First, the current level of brightness is measured. If it’s dark, it waits one second (1000 milliseconds).

loopClosed()

is then invoked once

again from the main loop.

If it’s bright, another reading is performed in 0.5 seconds. If it’s still bright, it counts as “drawer is open.” The mode is set to

OPEN

: In the next pass through the loop, then,

lo op OP E N()

is invoked.

INTRUDERS? (OPEN

)

If the drawer has been opened, the drawer monitor still has to find out if it’s due to an intruder. Maybe, after all, you opened it yourself. That task is handled by

loopOpen()

This function is invoked from the main loop whenever

mode

has the value

OPEN

. We start by checking button 2: If it is

pressed, the monitoring result is output by invoking the

output()

function.

If button 2 is not pressed, the brightness is checked in the

else if

part. If it is now dark, the drawer was closed

again.

counter

is then raised by the value of 1 with

++counter

If button 2 is not pressed and the drawer has not been closed again, the function is abandoned and invoked once again by the main loop.

void output() { Serial.print("The drawer was opened "); Serial.print(counter); Serial.print(" times!\n"); if (counter > 0) { pixel.setColor(255, 0, 0, 25); } else { pixel.setColor(0, 255, 0, 25); } delay(2000); reset(); }

OUTPUT

The

output()

function is what takes care of the monitoring result output. First, the exact result is output via the serial interface. For a quick check without having a computer connected, though, the result is also output via the NeoPixel. If the drawer has been opened and then closed again (i.e.,

counter > 0

), the NeoPixel glows red for 2 seconds. Otherwise, it glows green. Then the monitor is returned to its starting state with

r e s e t ()



PROJECT 17

CodeGamer manual inside english.indd 52 7/19/16 12:33 PM

Looking inside the fridge

How can you actually know if the light inside the fridge really does go out when you close the refrigerator door? You can’t exactly check just by looking. You would have to open the door, and then the light would just turn on again. With your KosmoDuino, though, it’s no problem at all!

YOU WILL NEED

› KosmoDuino in the interaction board › Light sensor ›  Male-female jumper wires

PREPARATION

Remove one strand of 4 wires from the strand of malefemale jumper wires. Insert the plug ends into the socket that you otherwise stick the KosmoBits sensor module into.

Then, insert the light sensor into the socket ends of the wires. Make sure that each of the light sensor pins is connected via the jumper wire to exactly the right socket into which it would normally be inserted. In other words, the wires must not be allowed to cross.

THE PLAN

You will be using the light sensor to measure the brightness inside the fridge, and you will have the NeoPixel light up on the interaction board in accordance with the measured level of brightness. But how can you have a display outside the fridge for the brightness on the inside? Easy: You will use extension wires to hook up the sensor! Then, you will be using the wires to keep the sensor inside the fridge while KosmoDuino and its interaction board remain on the outside.

The wires are so thin that you will still be able to close the refrigerator door!



PROJECT 18

CodeGamer

Warning! Not suitable for children under 8 years.

There is a risk of hot surfaces of components on the PCB (printed circuit board) when different polarities are incorrectly short-circuited or the capacitor is

subject to fault conditions.

CodeGamer manual inside english.indd 53 7/19/16 12:33 PM

#include <Adafruit_NeoPixel.h> #include <KosmoBits_Pixel.h> #include <KosmoBits_Pins.h>

const int sensorPin = KOSMOBITS_SENSOR_PIN; Kosm oBits_Pi xel pixel;

void setup() { pinMode(sensorPin, INPUT); pi x el.setColor(2 55, 255, 255, 0); }

void loop() { int brightness = analogRead(sensorPin); if (brightness > 255) { brightness = 255; } pi x el.setColor(2 55, 255, 255, b r ig h tn ess); dela y (1 0); }

You can probably understand the program without any help. In brief: In

s e t u p ()

you set the sensor pin mode and switch off the NeoPixel. In the main loop, you use the light sensor to measure the brightness and store the reading in the

brightness

variable. Since the brightness value

must not be greater than 255 with

pixel.setColor()

limit the

brightness

value to 255 with the help of the

instruction.

Now you just need to place the sensor in the fridge and close the door. And what’s the answer? Does the light go out?

</>

THE PROGRAM

▲

Jumper wire in fridge



PROJECT 18

CodeGamer manual inside english.indd 54 7/19/16 12:33 PM

Ghostly eyes

How would you like to turn your jack-o’-lantern into something even spookier this Halloween? With your KosmoDuino, you will be able to give it ghostly eyes.

YOU WILL NEED

› KosmoDuino in the interaction board ›  Resistors › Green LED › Red LED ›  Male-male jumper wires ›  Male-female jumper wires › Breadboard

THE PLAN

Make your jack-o’-lantern’s eyes blink colorfully. On top of that, you can have it make a gruesome hissing noise at irregular intervals.

PREPARATION

This time, you will need more than just the interaction board, because you will have to build a small electronic circuit. Assemble it out of the parts listed on the left, following the illustration.

Be careful to get the polarity of the LEDs correct! They only work in one direction. Pay attention to the orientation of their long and short legs.

• One jumper wire connects one GND pin with the (–) strip of the breadboard.

• One jumper wire connects pin 11 of the KosmoDuino with hole j 57 of the breadboard.

• One jumper wire connects pin 6 of the KosmoDuino with hole j 51 of the breadboard.

• The resistors connect the (–) strip and hole a 57 along with the (–) strip and hole a 51.

• The long leg of the red LED is inserted in hole f 57, the short one in e 57. Place the short leg of the green LED in hole f 51 and the long leg in hole e 57.

• To guide the LEDs from the breadboard to the jack-o’lantern’s eyes, use the 4 male-female jumper wires to connect the correspondingly positioned LEDs with the breadboard.

IN THIS EXAMPLE, THE ASSEMBLY GOES AS FOLLOWS:



CodeGamer

PROJECT 19

Warning! Not suitable for children under 8 years.

There is a risk of hot surfaces of components on the PCB (printed circuit board) when different polarities are incorrectly short-circuited or the capacitor is

subject to fault conditions.

CodeGamer manual inside english.indd 55 7/19/16 12:33 PM

#include <KosmoBits_Pins.h>

const int buzzerPin = KOSMOBITS_BUZZER_PIN; const int redPin = 11; const int greenPin = 6;

void setup() { randomSeed(analogRead(3)); pinMode(redPin, OUTPUT); pinMode(greenPin, OUTPUT); }

void loop() { // Blinking analogWrite(redPin, random(0, 256)); analogWrite(greenPin, random(0, 256)); dela y (2 00);

// H i s si n g if (random(0, 1000) > 900) { for (int i = 0; i < 3000; ++i) { analogWrite(buzzerPin, random(0, 256)); } } }

The program is extremely simple. First, the constants are defined for the pins you are using. In

s e t u p ()

, we will

give a starting value to the random generator.

In the main loop, the brightness of each LED is first set to a random value,

random(0, 256)

, with

a n al o g W r it e()

That will produce the flickering of the ghostly eyes.

To produce the hissing noise, you will use

ra nd o m(0, 10 0 0)

in the if statement to create another random number — this time between 0 (smallest possible value) and 999 (greatest possible value). If the random number is greater than 900, write 3000 random values into the

buzzerPin

with

analogWrite(buzzerPin, random(0, 256));

in the

adjacent

for

loop. That will produce the hissing sound in

the sp eake r.

The random numbers to be produced with the help of the

random()

function are evenly distributed. That means that every possible number will occur just as often as any other over a long period of time. The hissing will only be output, however, when the random number is greater than

900. That happens about one tenth of the time. If you want the hissing to happen less often, just choose a number larger than 900.

Now you can install these ghostly flickering eyes in a jack-o’-lantern or a homemade ghost.

The ghostly eyes can be combined with lots of other excellent ideas. How about a siren than howls when you shine a flashlight on the jack-o’-lantern? You have already learned how to do that. No doubt, you will also have a lot of other great ideas of your own!

</>

THE PROGRAM

▲

Ghostly eyes



PROJECT 19

CodeGamer manual inside english.indd 56 7/19/16 12:33 PM

BREADBOARD

The breadboard gives you an easy way to assemble electronic circuits. The outer red- and blue-marked rows are electrically connected to each other. This is where you usually connect the power supply. To do that, you connect one of the microcontroller pins marked with “GND” (for “ground”) with a (-) hole and one “5V” pin with a (+) hole in the breadboard. The vertical columns (a to e and f to j) are also electrically connected to each other — although only up to the “ditch” in the middle of the board. You can see all these details in the illustration.

Where does it go from here?

You have now acquired a solid foundation in Arduino programming. You can and should build on it. The CodeGamer kit and the KosmoBits system give you a good start, because in addition to the actual microcontroller you already have a breadboard, some LEDs, jumper wires and, of course, sensors. With the help of the battery, you will even be able to operate the entire setup independently of a computer and without any extra parts. The battery has a pretty high capacity. You will notice that by the fact that it rarely needs to be recharged. In short: You are well equipped!

You will find a lot of other project ideas on the Internet. Every once in a while, you will probably need an extra electronic component for one of those projects. You already have the rest though. Most important, you have even learned how to program by writing real code!

Now let your imagination run wild!



CodeGamer

CodeGamer manual inside english.indd 57 7/19/16 12:33 PM

Let’s take a simple example:

It could be written as follows:

Or — even worse — as follows:

if (digitalRead(button1) == LOW) {

red = 255;

} else {

ed = 0;

}

if (digitalRead(button1) == LOW) { red = 255; } else {

red = 0; }

if (digitalRead(button1) == LOW) {red = 255;} else {red = 0;}

Indented

You may have wondered why a lot of the lines found in

the programming text are indented, or moved a little to the right compared to the others. The reason for it is

simple: It makes the programming text easier to read.

All these versions mean the same thing, it’s just the formatting that changes. And yet, in the first example

you can see the structure of the program at a glance. It is easier to read the code.

That is why it makes sense to indent the program code whenever it begins a new block. Also, as a rule, each

individual instruction should get its own line.

The Arduino environment will help you with this, and usually moves new blocks to the right all by itself. If

you ever want to indent portions of text by hand, though, use the tab key rather than the space key.

◀

Automatic formatting

KNOWLEDGE BASE



CodeGamer manual inside english.indd 58 7/19/16 12:33 PM

CHECK IT OUT



CodeGamer

▲

The logbook page with moth

▲

Harvard Mark II

What is a bug, anyway?

When a program doesn’t do what it’s supposed to do, the error is called a bug. You can just call it

an error, but the term bug is used much more often. There’s an amazing story behind this term!

Earlier computers, such as the Harvard Mark II, completed in 1947, did not yet have any

microprocessors. Instead, they performed calculations with the help of electromechanical relays.

A relay basically consists of an electromagnet and a magnetically activated switch. If the

electromagnet is turned on, it activates the switch. If the magnet is turned on again, it moves the

switch back to the “off” setting. The important thing is that this kind of relay involves the actual

movement of something, namely the switch.

On September 9, 1947, the

technicians responsible for

the Mark II were looking

for the source of an error.

They found it: There was a

moth that had wedged

itself into a relay! The first

bug in a computer program,

in other words, literally was

an insect. The moth,

meanwhile, was dutifully

taped into the

Mark II logbook.

CodeGamer manual inside english.indd 59 7/19/16 12:33 PM

Maker project

▶

▲

Workshop at a Maker Faire

CHECK IT OUT



Arduino and the Maker

Have you ever dreamed of being an inventor? Of

thinking up new machines and gadgets and turning

them into reality? More and more people are moving

beyond merely dreaming, and deciding to actually

do it. They are makers!

Makers used to be called tinkerers or hobbyists. But

those words aren’t quite right anymore. While most

tinkerers used to like to keep themselves busy all

alone in their own workshops, makers also like to come out into the open and share their projects.

So a lot of hackerspaces or makerspaces have been created in cities around the world. These are

like a cross between a meeting place and a community workshop. They are places where the

makers can compare notes, present their latest ideas, give each other advice, and have access to

shared parts and tools.

There are also more and more Maker Faires popping up around the world, which allow makers to

present themselves to a larger public. They also typically offer an array of workshops for

experienced makers to add to their knowledge and for beginners to take their first steps.

In the makers’ projects, microcontrollers such as the

one from Arduino often play an important role. They

are what makes it possible to create complex gadgets

without first having to develop expensive specialized

electronics.

At a Maker Faire

▶

CodeGamer manual inside english.indd 60 7/19/16 12:33 PM

3D Printers

What good will the best electronics

and the greatest software do you

if you can’t find an appropriate housing for your

project? This is where a recent maker solution comes in: 3D printers.

These are devices that are capable of printing out three-dimensional (3D) objects rather than just

two-dimensional (2D) images on paper. It may sound like science fiction, but it’s very simple in

principle. You typically start with a plastic material rolled up like thread on a spool. This filament

is then heated to the melting point in a nozzle. In molten form, the plastic is computer-guided to a

certain location and then squirted out. The plastic then cools and hardens. Drop by drop, layer by

layer, even complicated and intricate structures can be built in this way.

Devices capable of doing this kind of thing have existed for a while, but it is only in the last few

years that they have become affordable for hobbyists.

By the way: The first test versions of the KosmoBits

controller were created in this way too!



CodeGamer

◀

A 3D printer at work

◀

Various 3D-printed prototypes from the CodeGamer development stages

▲

Filament for a 3D Printer

CodeGamer manual inside english.indd 61 7/19/16 12:33 PM

Common Error Messages

Here, a semicolon was expected before the closing parenthesis, but it was not found.

A name used in the program is not familiar to the computer. This is often an indication of a simple typo.

A type used in the program is not familiar to the compiler. In most cases, this either involves a typo or you forgot to include the corresponding file.

error: expected ';' before ')'

error: '...' was not declared in this scope

error: '...' does not name a type

EXAMPLE:

In function 'int average2()': DoubleClap:86: error: expected ';' before ')' t o k e n for (int i = 0; i < N, ++i) { ^ exit status 1 expected ';' before ')' token

error: 'pinnMode' was not declared in this scope

pi nn M o d e(A1, I NP U T);

error: 'KosmoBits_Pixel' does not name a type Kosm oBits_Pi xel pixel;

#include <Adafruit_NeoPixel.h> #include <KosmoBits_Pixel.h>

SOLUTION:

The comma has to be replaced with a semicolon after

i < N

Correct typo: It is actually called

pinMode

Include “KosmoBit_Pixel.h”:



ERROR MESSAGES

CodeGamer manual inside english.indd 62 7/19/16 12:33 PM

You presumably forgot to close the serial monitor before trying to upload the program.

1. You forgot to connect the KosmoDuino to the computer.

You might also have inserted the USB cable into the interaction board’s charge socket by mistake.

2. The wrong port has been set. Check Tool s

➜

Port and

change the port if necessary.

avrdude: ser_open(): can't open device "\\.\COM4": Access is denied.

avrdude: ser_open(): can't open device "\\.\COM4": The system cannot find the file specified.

Low memory available, stability problems may occur.

EXAMPLE:

int array[1000] = {}; // That is too large!

SOLUTION:

Change your program by using a smaller array.

Close the serial monitor and re-upload the program.

Use the USB cable to connect your computer to the KosmoDuino via the USB port.

Select a different port.

Your program is using almost all the microcontroller’s RAM or is even too large for it. You may have applied a large array.

Not enough memory.



CodeGamer

CodeGamer manual inside english.indd 63 7/19/16 12:33 PM



NOTES

CodeGamer manual inside english.indd 64 7/19/16 12:33 PM

Thames & Kosmos Code Gamer Experiment Manual

Specifications and Main Features

Frequently Asked Questions

User Manual