Posted on

# Raspberry Pi and A Robot Ferris Wheel you can build at home for less than \$100

Some of the links in this article are affiliate links. We don’t carry in our shop all the materials you would need to complete this activity, so we use links to share with you the products you would want to use so that you can do this activity at home. Some of those links are affiliates and we will make a small percentage commission, at no additional cost to you, if you use our links to purchase your supplies.

Have you ever wanted to build your own Lego Ferris Wheel or Train and be able to control it like a robot? Now you can!–and BONUS it counts as a math class activity. Keep reading to find out how to do it and at the bottom I’ll show you where in your Algebra II with Trig course this activity would fall so you can schedule it in your lessons.

You can connect your legos to a Raspberry Pi Controller, a small and easy to use motherboard that will talk to an easy to code computer program that tells your robot to move and perform simple functions.

### Taking an AskDrCallahan Math Course? Here’s where this project fits into your lessons.

Algebra II With Trig:  Functions, pg. 215 Chapter 3, Lesson 3 | Computer Science Pg. 51 (Chapter 1 Lesson 5) , pg. 240 (Chapter 3 Lesson 4) pg. 282 (Chapter 3 Review) and others. This text includes a complete subject reference at the back of the book where you can look up topics like “computer science” to see places where a computer based activity would apply.

# Let’s Get Started:

Here’s what it looks like to use a Raspberry Pi to Control a Ferris Wheel:

As you can see, you build the Ferris Wheel from scratch (Or from Legos) first, then you connect the Ferris Wheel to a Raspberry Pi, that talks to the computer program you build inside software you download.

That’s how it works. Need more detail? yes, I did as well. For those of you who are creative, but not neccesarily techy, or amybe you are a first time raspberry pi user, here’s the full instructions.

Step 1: Construct your lego Ferris Wheel. (or train, or whatever. It’s Pi Day so we are sticking with things that are circles since circles use Pi).

You can use popsicle sticks, glue, and paint to build it and find those instructions here.

Or you can use the Lego kit, which you can purchase here.

Step 2: Connect your Ferris Wheel to the Raspberry Pi.

Supples you will need, listed prices are approximate and don’t include shipping. Shipping is Free if you have amazon prime, so be sure to select that!

If you’re not sold out on the Ferris Wheel and want to do other projects, too, I like this kit for beginners. It’s \$30 plus shipping and includes everything you need to do several coding/science projects like robots. The kit also includes instructions. Grab that here (or by clicking the image above).

Once you have your supplies, you want to follow these instructions. (Credit: SparkFun. Check out their website here.)

Two Methods:
Use SparkFun’s Way

For your convenience, I am copying what SparkFun wrote out about how to use the Raspberry Pi here. Visit their website and the full tutorial here.

Some further notes on that bill of materials:

• Your Raspberry Pi should have an SD card with Raspbian installed on it. Check out our How to Install Raspbian tutorial for help with that.
• We’re also assuming you have the necessary mouse, keyboard and display hooked up to your Pi.
• Your Pi will need an Internet connection to download WiringPi. You can use either Ethernet or WiFi (check out our Raspberry Pi WiFi tutorial for help with that.
• The Pi Wedge isn’t quite required, but it does make life a lot easier. If you want to skip the breakout, you can instead use Male-to-Female jumpers to connect from Pi to breadboard.
• Of course, feel free to swap in your preferred button and LEDs.

This tutorial will assume you have Raspbian installed on your Raspberry Pi. Raspbian is the most popular, well-supported Linux distribution available for the Pi. If you don’t have Raspbian set up, check out our Setting Up Raspbian tutorial before continuing down this rabbit hole.

Other, more general purpose tutorials you might be interested in reading include:

• Pulse-Width Modulation – You can use PWM to dim LEDs or send signals to servo motors. The RPi has a single PWM-capable pin.
• Light-Emitting Diodes (LEDs) – To test the output capabilities of the Pi, we’ll be driving a lot of LEDs.
• Switch Basics – And to test inputs to the Pi, we’ll be using buttons and switches.
• Pull-Up Resistors – The Pi has internal pull-up (and pull-down) resistors. These are very handy when you’re interfacing buttons with the little computer.

### Suggested Viewing

Check out our Raspberry Pi video tutorials if you want a more visual introduction to the Pi!

• Getting Started With The Raspberry Pi

## GPIO Pinout

The Raspberry Pi offers up its GPIO over a standard male header on the board. Over the years the header has expanded from 26 pins to 40 pins while maintaining the original pinout.

Header configuration for early and late model Pi computers

If you’re coming to the Raspberry Pi as an Arduino user, you’re probably used to referencing pins with a single, unique number. Programming the Pi’s hardware works much the same, each pin has its own number…and then some.

There are (at least) two, different numbering schemes you may encounter when referencing Pi pin numbers: (1) Broadcom chip-specific pin numbers and (2) P1 physical pin numbers. You’re usually free to use either number-system, but many programs require that you declare which scheme you’re using at the very beginning of your program.

Here’s a table showing all 26 pins on the P1 header, including any special function they may have, and their dual numbers:

Element14 pin description, annotated

 Wedge Silk Python (BCM) WiringPi GPIO Name P1 Pin Number Name WiringPi GPIO Python (BCM) Wedge Silk 3.3v DC Power 1 2 5v DC Power SDA 8 GPIO02 (SDA1, I2C) 3 4 5v DC Power SCL 9 GPIO03 (SCL1, I2C) 5 6 Ground G4 4 7 GPIO04 (GPIO_GCLK) 7 8 GPIO14 (TXD0) 15 TXO Ground 9 10 GPIO15 (RXD0) 16 RXI G17 17 0 GPIO17 (GPIO_GEN0) 11 12 GPIO18 (GPIO_GEN1) 1 18 G18 G27 27 2 GPIO27 (GPIO_GEN2) 13 14 Ground G22 22 3 GPIO22 (GPIO_GEN3) 15 16 GPIO23 (GPIO_GEN4) 4 23 G23 3.3v DC Power 17 18 GPIO24 (GPIO_GEN5) 5 24 G24 MOSI 12 GPIO10 (SPI_MOSI) 19 20 Ground MISO 13 GPIO09 (SPI_MISO) 21 22 GPIO25 (GPIO_GEN6) 6 25 G25 (no worky 14) GPIO11 (SPI_CLK) 23 24 GPIO08 (SPI_CE0_N) 10 CD0 Ground 25 26 GPIO07 (SPI_CE1_N) 11 CE1 IDSD 30 ID_SD (I2C ID EEPROM) 27 28 ID_SC (I2C ID EEPROM) 31 IDSC G05 5 21 GPIO05 29 30 Ground G6 6 22 GPIO06 31 32 GPIO12 26 12 G12 G13 13 23 GPIO13 33 34 Ground G19 19 24 GPIO19 35 36 GPIO16 27 16 G16 G26 26 25 GPIO26 37 38 GPIO20 28 20 G20 Ground 39 40 GPIO21 29 21 G21

This table shows the Pi pin header numbers, element14 given names, wiringPi numbers, Python numbers, and related silkscreen on the wedge.

Note: The Broadcom pin numbers above relate to Pi Model 2 and later only. If you have an older Rev1 Pi, check out this link for your Broadcom pin numbers.

As you can see, the Pi not only gives you access to the bi-directional I/O pins, but also Serial (UART), I2C, SPI, and even some PWM (“analog output”).

## Hardware Setup

To get a head start you can assemble the circuit now. We’ll use this setup for both the C and Python examples. We’ll use two LEDs to test the output functionality (digital and PWM), and a button to test the input.

connections to original pi

connections to the pi B + and pi 2 B

Our two LEDs are connected to the Pi’s GPIO 18 and GPIO 23 – those are the Broadcom chip-specific numbers. If you’re basing your wiring off the P1 connector pin numbers, that’d be pins 12 and 16.

The button is connected to Broadcom GPIO 17, aka P1 pin 11.

If you have Pi Wedge, the hookup should be pretty straight-forward. It’ll look a little something like this when you’re done:

If you don’t have a Pi Wedge, male-to-female jumper wires help to make an easy transition from Pi to breadboard.

## Python (RPi.GPIO) API

We’ll use the RPi.GPIO module as the driving force behind our Python examples. This set of Python files and source is included with Raspbian, so assuming you’re running that most popular Linux distribution, you don’t need to download anything to get started.

On this page we’ll provide an overview of the basic function calls you can make using this module.

### Setup Stuff

In order to us RPi.GPIO throughout the rest of your Python script, you need to put this statement at the top of your file:

``````import RPi.GPIO as GPIO
``````

That statement “includes” the RPi.GPIO module, and goes a step further by providing a local name – `GPIO` – which we’ll call to reference the module from here on.

#### Pin Numbering Declaration

After you’ve included the RPi.GPIO module, the next step is to determine which of the two pin-numbering schemesyou want to use:

1. `GPIO.BOARD` – Board numbering scheme. The pin numbers follow the pin numbers on header P1.
2. `GPIO.BCM` – Broadcom chip-specific pin numbers. These pin numbers follow the lower-level numbering system defined by the Raspberry Pi’s Broadcom-chip brain.

If you’re using the Pi Wedge, we recommend using the `GPIO.BCM` definition – those are the numbers silkscreened on the PCB. The `GPIO.BOARD` may be easier if you’re wiring directly to the header.

To specify in your code which number-system is being used, use the `GPIO.setmode()` function. For example…

``````GPIO.setmode(GPIO.BCM)
``````

…will activate the Broadcom-chip specific pin numbers.

Both the `import` and `setmode` lines of code are required, if you want to use Python.

#### Setting a Pin Mode

If you’ve used Arduino, you’re probably familiar with the fact that you have to declare a “pin mode” before you can use it as either an input or output. To set a pin mode, use the `setup([pin], [GPIO.IN, GPIO.OUT]` function. So, if you want to set pin 18 as an output, for example, write:

``````GPIO.setup(18, GPIO.OUT)
``````

Remember that the pin number will change if you’re using the board numbering system (instead of 18, it’d be 12).

### Outputs

#### Digital Output

To write a pin high or low, use the `GPIO.output([pin], [GPIO.LOW, GPIO.HIGH])` function. For example, if you want to set pin 18 high, write:

``````GPIO.output(18, GPIO.HIGH)
``````

Writing a pin to `GPIO.HIGH` will drive it to 3.3V, and `GPIO.LOW` will set it to 0V. For the lazy, alternative to `GPIO.HIGH`and `GPIO.LOW`, you can use either `1`, `True`, `0` or `False` to set a pin value.

#### PWM (“Analog”) Output

PWM on the Raspberry Pi is about as limited as can be – one, single pin is capable of it: 18 (i.e. board pin 12).

To initialize PWM, use `GPIO.PWM([pin], [frequency])` function. To make the rest of your script-writing easier you can assign that instance to a variable. Then use `pwm.start([duty cycle])` function to set an initial value. For example…

``````pwm = GPIO.PWM(18, 1000)
pwm.start(50)
``````

…will set our PWM pin up with a frequency of 1kHz, and set that output to a 50% duty cycle.

To adjust the value of the PWM output, use the `pwm.ChangeDutyCycle([duty cycle])` function. `[duty cycle]` can be any value between 0 (i.e 0%/LOW) and 100 (ie.e 100%/HIGH). So to set a pin to 75% on, for example, you could write:

``````pwm.ChangeDutyCycle(75)
``````

To turn PWM on that pin off, use the `pwm.stop()` command.

Simple enough! Just don’t forget to set the pin as an output before you use it for PWM.

### Inputs

If a pin is configured as an input, you can use the `GPIO.input([pin])` function to read its value. The `input()` function will return either a `True` or `False` indicating whether the pin is HIGH or LOW. You can use an `if` statement to test this, for example…

``````if GPIO.input(17):
print("Pin 11 is HIGH")
else:
print("Pin 11 is LOW")
``````

…will read pin 17 and print whether it’s being read as HIGH or LOW.

#### Pull-Up/Down Resistors

Remember back to the `GPIO.setup()` function where we declared whether a pin was an input or output? There’s an optional third parameter to that function, which you can use to set pull-up or pull-down resistors. To use a pull-up resistor on a pin, add `pull_up_down=GPIO.PUD_UP` as a third parameter in `GPIO.setup`. Or, if you need a pull-down resistor, instead use `pull_up_down=GPIO.PUD_DOWN`.

For example, to use a pull-up resistor on GPIO 17, write this into your setup:

``````GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)
``````

If nothing is declared in that third value, both pull-resistors will be disabled.

### Etc.

#### Delays

If you need to slow your Python script down, you can add delays. To incorporate delays into your script, you’ll need to include another module: `time`. This line, at the top of your script, will do it for you:

``````include time
``````

Then, throughout the rest of your script, you can use `time.sleep([seconds])` to give your script a rest. You can use decimals to precisely set your delay. For example, to delay 250 milliseconds, write:

``````time.sleep(0.25)
``````

The time module includes all sorts of useful functions, on top of `sleep`. Check out the reference here.

#### Garbage Collecting

Once your script has run its course, be kind to the next process that might use your GPIOs by cleaning up after yourself. Use the `GPIO.cleanup()` command at the end of your script to release any resources your script may be using.

Your Pi will survive if you forget to add this command, but it is good practice to include wherever you can.

Now then. Lets incorporate everything we learned here into an example script to try everything out.

## Python (RPi.GPIO) Example

Follow along as we use the basic RPi.GPIO functions from the last page to create a simple example GPIO script.

### 1. Create a File

To begin, we need to create a Python file. You can do this through the GUI-based file explorer. Or, if you want a terminal-based solution, open up LXTerminal, and navigate to a folder you’d like the file to live (or create one). And create a new folder with these commands:

[email protected] ~/code \$ mkdir python
[email protected] ~/code \$ cd python

Create a file – we’ll call ours “blinker” – and terminate it with a .py extension. Then open it up in your favorite text editor. Nano works, as does Pi’s default GUI text editor, Leafpad.

[email protected] ~/code/python \$ touch blinker.py

That’ll open up a blank text file (the “&” will open it in the background, leaving the terminal in place for future use). Time for some code!

### 2. Codify

Here’s an example sketch that incorporates everything we learned on the last page. It does a little input and output, and even handles some PWM. This assumes you’ve set up the circuit as arranged on the Hardware Setup page.

``````# External module imports
import RPi.GPIO as GPIO
import time

# Pin Definitons:
pwmPin = 18 # Broadcom pin 18 (P1 pin 12)
ledPin = 23 # Broadcom pin 23 (P1 pin 16)
butPin = 17 # Broadcom pin 17 (P1 pin 11)

dc = 95 # duty cycle (0-100) for PWM pin

# Pin Setup:
GPIO.setup(ledPin, GPIO.OUT) # LED pin set as output
GPIO.setup(pwmPin, GPIO.OUT) # PWM pin set as output
pwm = GPIO.PWM(pwmPin, 50)  # Initialize PWM on pwmPin 100Hz frequency
GPIO.setup(butPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # Button pin set as input w/ pull-up

# Initial state for LEDs:
GPIO.output(ledPin, GPIO.LOW)
pwm.start(dc)

print("Here we go! Press CTRL+C to exit")
try:
while 1:
if GPIO.input(butPin): # button is released
pwm.ChangeDutyCycle(dc)
GPIO.output(ledPin, GPIO.LOW)
else: # button is pressed:
pwm.ChangeDutyCycle(100-dc)
GPIO.output(ledPin, GPIO.HIGH)
time.sleep(0.075)
GPIO.output(ledPin, GPIO.LOW)
time.sleep(0.075)
except KeyboardInterrupt: # If CTRL+C is pressed, exit cleanly:
pwm.stop() # stop PWM
GPIO.cleanup() # cleanup all GPIO
``````

After you’ve typed all of that in (don’t forget your whitespace!) save.

### Running the Script

The RPi.GPIO module requires administrator privileges, so you’ll need to tag a `sudo` on to the front of your Python script call. To run your “blinker.py” script, type:

[email protected] ~/code/python \$ sudo python blinker.py

With the code running, press the button to turn on the digital LED. The PWM-ing LED will invert its brightness when you press the button as well.

Press CTRL+C to cleanly exit the script.

## C (WiringPi) Setup

Python is a great GPIO-driving option, especially if you’re used to it. But if you’re a rickety old programmer, unfamiliar with the whitespace-driven scripting language, and would rather live within the happy confines of C, then let me introduce the WiringPi library.

### 1) Install Wiring Pi

WiringPi is not included with Raspbian, so, to begin, you’ll need to download and install it. That means your Pi will need a connection to the Internet – either via Ethernet or WiFi.

[email protected] ~/code \$ git clone git://git.drogon.net/wiringPi
[email protected] ~/code \$ cd wiringPi
[email protected] ~/code/wiringPi \$ git pull origin
[email protected] [email protected] ~/code/wiringPi/wiringPi \$ ./build

### 2) Test Wiring Pi

WiringPi is awesome because it’s actually more than just a C library, it includes a command-line utility as well! You can test your installation of WiringPi with the `gpio` utility.

Open up a terminal, and try some of these system calls:

[email protected] ~/code \$ gpio -g mode 18 output
[email protected] ~/code \$ gpio -g write 18 1
[email protected] ~/code \$ gpio -g write 18 0

As long as your LED is still connected to pin 18 it should blink on and off following the last two commands.

Or, to test the button, type:

[email protected] ~/code \$ gpio -g mode 17 up
[email protected] ~/code \$ gpio -g read 17

Either 0 or 1 will be returned, depending on whether the button is pressed or not. Try typing that last line again while pressing the button.

The `gpio` utility, as stated in the manual, is a “swiss army knife” command-line tool. We highly recommend checking out the man page (type `man gpio`) to discover everything it can do.

If you’re ready to get on with some C-style programming, head over to the next page. We’ll overview some of the most useful functions provided by the WiringPi library.

## C (WiringPi) API

On this page we’ll discuss some of the most useful functions provided by the WiringPi library. It’s tailored to look a lot like Arduino, so if you’ve done any Arduino programming some of this may look familiar.

### Setup Stuff

To begin, you’ll need to include the library. At the beginning of your program, type:

``````#include <wiringPi.h>
``````

After you’ve included the library, your first steps should be to initialize it. This step also determines which pin numbering scheme you’ll be using throughout the rest of your program. Pick one of these function calls to initialize the library:

``````wiringPiSetup(); // Initializes wiringPi using wiringPi's simlified number system.
wiringPiSetupGpio(); // Initializes wiringPi using the Broadcom GPIO pin numbers
``````

WiringPi’s simplified number system introduces a third pin-numbering scheme. We didn’t show it in the table earlier, if you want to use this scheme, check out their pins page for an overview.

### Pin Mode Declaration

To set a pin as either an input or output, use the `pinMode([pin], [mode])` function. Mode can be either `INPUT`, `OUTPUT`, or `PWM_OUTPUT`.

For example, to set pin 22 as an input, 23 as an output, and 18 as a PWM, write:

``````wiringPiSetupGpio()
pinMode(17, INPUT);
pinMode(23, OUTPUT);
pinMode(18, PWM_OUTPUT);
``````

Keep in mind that the above example uses the Broadcom GPIO pin-numbering scheme.

### Digital Output

The `digitalWrite([pin], [HIGH/LOW])` function can be used to set an output pin either HIGH or LOW. Easy enough, if you’re an Arduino user.

To set pin 23 as HIGH, for example, simply call:

``````digitalWrite(23, HIGH);
``````

#### PWM (“Analog”) Output

For the lone PWM pin, you can use `pwmWrite([pin], [0-1023])` to set it to a value between 0 and 1024. As an example…

``````pwmWrite(18, 723);
``````

…will set pin 18 to a duty cycle around 70%.

### Digital Input

If you’re an Arduino veteran, you probably know what comes next. To read the digital state of a pin, `digitalRead([pin])` is your function. For example…

``````if (digitalRead(17))
printf("Pin 17 is HIGH\n");
else
printf("Pin 17 is LOW\n");
``````

…will print the status of pin 22. The `digitalRead()` function returns 1 if the pin is HIGH and 0 if it’s LOW.

#### Pull-Up/Down Resistors

Need some pull-up or pull-down resistors on your digital input? Use the `pullUpDnControl([pin], [PUD_OFF, PUD_DOWN, PUD_UP])` function to pull your pin.

For example, if you have a button on pin 22 and need some help pulling it up, write:

``````pullUpDnControl(17, PUD_UP);
``````

That comes in handy if your button pulls low when it’s pressed.

### Delays

Slowing down those blinking LEDs is always useful – assuming you actually want to differentiate between on and off. WiringPi includes two delay functions to choose from: `delay([milliseconds])` and `delayMicroseconds([microseconds])`. The standard delay will halt the program flow for a specified number of milliseconds. If you want to delay for 2 seconds, for example, write:

``````delay(2000);
``````

Or you can use `delayMicroseconds()` to get a more precise, microsecond-level delay.

Now that you know the basics, let’s apply them to an example piece of code.

## C (WiringPi) Example

The intention of WiringPi is to make your I/O code look as Arduino-ified as possible. However keep in mind that we’re no longer existing in the comfy confines of Arduino – there’s no `loop()` or `setup()`, just `int main(void)`.

Follow along here as we create an example C file, incorporate the WiringPi library, and compile and run that program.

Using the terminal, navigate to a folder of your choice and create a new file – “blinker.c”. Then open that file in a text editor (Nano or Leafpad are included with Raspbian).

[email protected] ~/code \$ mkdir c_example
[email protected] ~/code \$ cd c_example
[email protected] ~/code/c_example \$ touch blinker.c

### Program!

Here’s an example program that includes a little bit of everything we talked about on the last page. Copy and paste, or write it yourself to get some extra reinforcement.

``````#include <stdio.h>    // Used for printf() statements
#include <wiringPi.h> // Include WiringPi library!

// Pin number declarations. We're using the Broadcom chip pin numbers.
const int pwmPin = 18; // PWM LED - Broadcom pin 18, P1 pin 12
const int ledPin = 23; // Regular LED - Broadcom pin 23, P1 pin 16
const int butPin = 17; // Active-low button - Broadcom pin 17, P1 pin 11

const int pwmValue = 75; // Use this to set an LED brightness

int main(void)
{
// Setup stuff:
wiringPiSetupGpio(); // Initialize wiringPi -- using Broadcom pin numbers

pinMode(pwmPin, PWM_OUTPUT); // Set PWM LED as PWM output
pinMode(ledPin, OUTPUT);     // Set regular LED as output
pinMode(butPin, INPUT);      // Set button as INPUT
pullUpDnControl(butPin, PUD_UP); // Enable pull-up resistor on button

printf("Blinker is running! Press CTRL+C to quit.\n");

// Loop (while(1)):
while(1)
{
if (digitalRead(butPin)) // Button is released if this returns 1
{
pwmWrite(pwmPin, pwmValue); // PWM LED at bright setting
digitalWrite(ledPin, LOW);     // Regular LED off
}
else // If digitalRead returns 0, button is pressed
{
pwmWrite(pwmPin, 1024 - pwmValue); // PWM LED at dim setting
// Do some blinking on the ledPin:
digitalWrite(ledPin, HIGH); // Turn LED ON
delay(75); // Wait 75ms
digitalWrite(ledPin, LOW); // Turn LED OFF
delay(75); // Wait 75ms again
}
}

return 0;
}
``````

### Compile and Execute!

Unlike Python, which is an interpreted language, before we can run our C program, we need to build it.

To compile our program, we’ll invoke gcc. Enter this into your terminal, and wait a second for it to finish compiling:

That command will create an executable file – “blinker”. The “-l wiringPi” part is important, it loads the wiringPi library. A successful compilation won’t produce any messages; if you got any errors, try to use the messages to track them down.

Type this to execute your program:

[email protected] ~/code/c_example \$ sudo ./blinker

The blinker program should begin doing it’s thing. Make sure you’ve set up the circuit just as modeled on the hardware setup page. Press the button to blink the LED, release to have it turn off. The PWM-ing LED will be brightest when the button is released, and dim when the button is pressed.

If typing all of that code in a bland, black-and-white, non-highlighting editor hurt your brain, check out the next page where we introduce a simple IDE that makes your programming more efficient.

## Using an IDE!

Thus far we’ve been using simple text-editors – Leafpad or Nano – to write our Python and C programs. So seasoned programmers are probably missing a whole lot of features assumed of even the most basic editors: auto-tabbing, context-highlighting, even automated building. If you want to incorporate any of those features, we recommend using an IDE (integrated development environment). One of our favorite Pi IDE’s is Geany, here’s how to get it up and running.

Geany isn’t included with Raspbian, so you’ll need an Internet connection to download it. You can use the magical `apt-get` utility to install it with this command:

[email protected] ~/code \$ sudo apt-get update
[email protected] ~/code \$ sudo apt-get install geany

Once installed, you can run Geany by going to the “Start” menu, and looking under the “Programming” tab.

Or, from the terminal, you can type `sudo geany`. You can even open a file in Geany, directly from the command line. To open our previous C file, for example, type `sudo geany blinker.c`.

### Using Geany…

Once Geany is running, you can create a new file by going to File > New. Saving the file as either “.c” or “.py” (or any other common language file extension) will immediately inform Geany what kind of language you’re working with, so it can start highlighting your text.

Geany can be used with most languages, including the Python and C examples we’ve just examined. Some tweaks to the default IDE options are necessary, though. Here’s an overview of using Geany with each language.

#### …with C and WiringPi

Let’s recreate our WiringPi Example with Geany. Open the “blinker.c” created earlier within the confines of Geany. You should immediately be presented with some very pleasant color-coding.

Before trying to compile the code, though, you’ll need to tweak some of the build options. Go up to Build and Set Build Commands. Inside the “Compile” and “Build” text blocks, tack this on to the end of the default command: `-l wiringPi`. That will load the wiringPi library.

While you’re here, add “sudo” to the beginning of your execute command. Make sure your build commands look like the window above and click “OK”.

Once you’ve adjusted that setting, you should be ready to go. Click the Build menu, then click Build (or click the red cinder-block-looking icon up top). Upon building, the IDE will switch focus to the bottom “Compiler” tab, and relay the results of your compilation. If the build was successful, go ahead and run with it.

To run your built file, click Build > Execute (or click the gear icon up top). Executing will bring up a new terminal window, and start your program running. You can stop the program by pressing CTRL+C in the terminal window.

#### …with Python

You can also use Geany with Python. To test it out, go ahead an open up the “blinker.py” file we created earlier. As with the C file, you’ll be greeted with some pleasnt context highlighting.

No building required with Python! Once you’re script is written, simply click the “Execute” gear up top. Again, running will produce a separate terminal to pop up. To exit, simply press CTRL+C.

—————————————————————————————————————————————————————————————————-

Again, remember this tutorial came from Spark Fun so check out their website for the full version, tutorials, demonstrations, and more. (We are not affiliated with Spark Fun we just like this activity)

If your student likes activities like these, they may be headed into a STEM based major in college. Do you know if they are getting all the math they need to be ready? We have outlined a full road map to college so you can know exactly what your student needs to be taking in high school, including how many credits they need and the key concepts to be sure and learn in order to be ready to go to college in a STEM based field. Enter your email below to get your free copy of that guide now.