Documents

Connecting to a Remote Desktop on the Raspberry Pi

cstanton — Tue, 15 Oct 2024 10:19:54 GMT

Current Revision posted to Documents by cstanton on 10/15/2024 10:19:54 AM

When I first received my Raspberry Pi, I didn't have a monitor available, so every time I wanted to work with it I would have to go through the trouble of hooking it up to the TV or borrowing the monitor I used for my main computer. That didn't always go over well with my dearest, who's not into decor that incorporates multiple cables strewn randomly into its design.

Now that I have set up Remote Desktop on my Pi, I can easily access it via a window on my iMac, which means more time tinkering and less time dealing with setup details. It also means I can put the Pi anywhere else in the house (or in the yard or greenhouse!) and still have easy access. And as a bonus, it also means I get fewer dirty looks from my dearest ("fewer" being the key word there ).

If you are new to the Raspberry Pi, it will likely still be easiest to do the initial setup using your TV and maybe a borrowed keyboard/mouse, but then after you'll never have to go through all of that trouble again!

The process is quite simple actually - you will need to install a bit of software onto your Raspberry Pi, and you'll need a bit of software on the PC you'll be using to access it. The RPi software can even be installed remotely from your PC, if you have already set up your RPi.

Let's break your RPi free from all those peripherals right now, in just 3 easy steps! The other 17 steps are difficult . I'm kidding! It's just 6 easy steps. 7 if you plan on taking over the world.

Please note that I've written this tutorial for the Raspbian operating system, but the exact same steps can likely be used for any of the other distributions available for the RPi.

1. Set Up Your Raspberry Pi

First things first: if you have not already done so you will need to do the initial setup for your Raspberry Pi. There's no getting around that step, but do not fear - it's also fairly easy and automated. There are many tutorials available for that, so I will leave you to the experts for this step.

2. Find the IP Address of your RPi

To connect to your RPi, you will need to know its special phone number, known as the IP Address. Every device connected to your network will have their own special IP Address.

To find the IP Address for your RPi, use ifconfig from a command line on your RPi. Type the following at the command line and press the 'enter' key:

ifconfig

If you have already disconnected your keyboard and monitor from your RPi, you can still find its IP Address by asking your router for that information. On an Apple network, for example, Airport Utility can be used. I've attached an image of what this looks like.

For other routers, you can often connect to the admin panel of the router via a browser to find out this information.

Note that IP addresses can change over time, and you might have to repeat this step in the future to find it again. However, you can set a fixed IP address for your RPi with a little bit of effort. Please see Additional Notes #2 at the bottom of this article.

You can also choose to put in a little bit of extra effort so that your Pi can be accessed by name, instead of just by IP address.

Please refer to these URLs for instructions of how that works, and how to set it up:

How-To Geek: How to Assign the .local Domain to Your Raspberry Pi

Arne's Blog: How to setup mDNS lookups on the Raspberry Pi

3. Using SSH

Now that you have the IP Address for your RPi, you can connect to it from your PC by simply using SSH.

SSH is a feature that comes already installed in Raspbian (and most Linux systems, including Mac OS).

On Mac or Linux, open a Terminal window. The Terminal application can be found under Applications, in the Utilities folder.

In my case, my Raspberry Pi's IP Address was 10.0.1.10, so I typed the following command (followed by pressing 'enter', of course)

ssh pi@10.0.1.10

Non-Apple networks tend to use IP addresses in the 192.168 range, so yours may look more like:

ssh pi@192.168.2.2

It will then ask for your password (the default is "raspberry"). On that note, if your RPi is visible to the outside world, it's best to change that password to something else - ANYthing else.

In Windows, you can download an application named PuTTY (or similar Windows SSH client).

For the new session, enter the IP address and select SSH. Keep default port of 22.

You will now have command line access to your Raspberry Pi, conveniently from your PC!

All of the following steps can be accomplished from this SSH connection, from your PC.

4. Stop the GUI Desktop From Starting Automatically

Since you will be starting the GUI desktop for your Pi remotely on your PC, we don't want to start it automatically on the Pi when it starts, as that would unnecessarily use up precious memory and cause startup to take longer.

Use raspi-config to do this. At the command line, simply type the following command (followed by the enter key, of course)

sudo raspi-config

Because this is a task requiring root permissions, you need to use sudo, and you may need to enter your password.

This will start a text-based interface to allow you to change some of the Raspberry Pi startup settings.

Select the option "Enable Boot to Desktop/Scratch" and press 'enter' to select it.

Next, select the "Console - Text console, requiring login" option and press 'enter' to select it.

Now press the right-arrow key until <Finish> is highlighted, and press 'enter' again.

Press 'enter'' one last time to say 'yes' to rebooting.

If you are using SSH, your connection will close and you'll have to wait for your RPi to restart before you can login again. Restart will be faster now that the GUI doesn't need to be started

Note that you can always use "startx" to start the GUI manually when working directly on the RPi. You can also use the same steps (choosing to boot to GUI instead) to re-enable the auto-start of the GUI.

Intermission <pleasant intermission music goes here> ...

If you don't intend to ever use a remote GUI for your RPi, you can stop right here and happily go on using your RPi remotely using SSH. Note that you can still open GUI windows for individual applications using just SSH (See Note #5 below).

For the more graphically oriented amongst us, continue on, our goal is not too far away now...

5. Install the Remote Desktop Server software on the Raspberry Pi

The next step is to install the software on your Raspberry Pi that provides the connection to the Remote Desktop software that will run on your PC.

On the command line, type the following:

sudo apt-get install xrdp

Press 'y' when prompted to continue.

This will download and install the remote desktop server. This process can take a minute or two, depending on the speed of your internet connection.

6. Install the Remote Desktop application on your PC

Remote Desktop is an application by Microsoft, and is available for free in the Mac App store (and, I assume, as a download for Windows and Linux). Just search for "remote desktop". The app's name (in the Mac App Store) is "Microsoft Remote Desktop".

In Linux, you can install rdesktop (sudo apt-get install rdesktop), and for a graphical interface you can also install grdesktop (sudo apt-get install grdesktop).

I haven't checked on a Windows machine - it may already be installed, or you may have to download and install it now.

After installing Remote Desktop, open the application and add the following settings:

For PC name, type in the IP address for your RPi.

I also chose to uncheck "Start session in full screen" and I checked "Scale content", as I prefer to work with it inside of a window alongside the rest of the things I need to see when I'm on my main computer.

When you connect, it will open a window on your local machine that looks exactly like the GUI screen you would see when you log in directly on your RPi.

Done!

That's it, that's all you need to remotely access your Raspberry Pi using a convenient GUI window on your main PC.

Taking Over the World

Now that you know how to set up one Raspberry Pi with Remote Desktop, simply repeat the process so that you can have an army of RPis around the house all controlled via one computer in a secret lair!

Additional Notes

1* I found that the Remote Desktop App for Android does not work properly with Raspberry Pi. Maybe, hopefully, they will fix this in a future release.

2* Most home networks do not assign fixed IP addresses, so your Pi might get a new address at some point in the future. You could change your router settings to assign a fixed address to your RPi. How to do that varies, so check what is required for your router. Mac Time Capsule and Airport allow you to assign a fixed IP address to a machine based on Mac Address using Airport Utility. Other routers will likely have the same functionality implemented in their own special ways, so please check your router manual for those details.

OR:

You can also choose to put in a little bit of extra effort so that your Pi can be accessed by name, instead of just by IP address.

Please refer to these URLs for instructions of how that works, and how to set it up:

How-To Geek: How to Assign the .local Domain to Your Raspberry Pi

Arne's Blog: How to setup mDNS lookups on the Raspberry Pi

3* You can use FTP to move files to and from your RPi using similar settings. Use an FTP application like FileZilla.

4* From a Mac, you can use X11 to connect directly to an RPi without needing to install anything on the RPi. However, I found that this only allowed it to run in full screen, and kind of mixed with my Mac desktop.

5* You can also use SSH to open GUI windows for individual applications, without starting a complete GUI window for the RPi. Check out Enrico's post for more information.

6* Other alternatives to Remote Desktop also exist. Look for x11vnc and RealVNC. Complete instructions for setting up your Raspberry Pi with RealVNC are available at their website.

Tags: rpi2, raspberry-pi, rpi, desktop, raspberry_pi_projects, remote

PIK3A: The Raspberry Pi 3 IKEA Retro Gaming Table

cstanton — Tue, 16 Jul 2024 10:04:44 GMT

Current Revision posted to Documents by cstanton on 7/16/2024 10:04:44 AM

Gaming is the perfect way to help newcomers to the Raspberry Pi to connect it with a recognisable lifestyle technology. It's the perfect stepping stone to bring people eye-to-eye with the Raspberry Pi; if it can play all those awesome, classic arcade games, it can also do so much more!

And that's why gaming is often our go-to project when it's time to show people what the Pi is all about. But this time around, with the Raspberry Pi 3 now in the wild, we wanted to do something a little bit different, too. So here's how to make your own minimalist, contemporary interpretation of the classic coin-op cocktail cabinet that uses an IKEA coffee table and a Raspberry Pi 3.

Meet the PIK3A Gaming Table!

Parts, Bits and Pieces

So here's the gist of this simple, but super-stylish project.

It's an IKEA Lack coffee table with an LCD monitor cut into the top, arcade controls next to the monitor, and a Raspberry Pi 3 and accessories buried inside the table.

Let's begin with an overview of the parts you'll need:

The Cabinet: IKEA Lack coffee table.
The Brains: Raspberry Pi
The Controls: Arduino Leonardo
The Joystick: A classic, four-way ball-top joystick.
The Buttons: From CPC - From MCM
The Display: An old 17" LCD monitor (4:3 ratio is better given the square shape of the table).
The Sound: This pair of USB-powered computer speakers.
The Power: A Raspberry Pi 2.5A USB power supply, and a mains extension.
The Stuff: Cables, connectors, screws.

Table Top Gaming

This isn't really intended as a woodworking project, but we trashed at least one table when prototyping this so maybe we can help you to make only the holes the table needs. So, let's begin with the hacking and sawing, and then we'll look at the innards.

Dismantle Your Monitor

The old Acer AL1716 monitors we used seem fairly generic, in terms of 17" LCD screens, so hopefully yours will pan out the same. By taking the screen chassis out of the plastic casing (nothing complicated there -- take out the screws and prize the two halves apart) you should be left with the screen inside the shielding housing that's almost exactly the same depth as a LACK coffee table. This means that once you've got the screen, all you need to do is drop it into the hole we're about to cut into the PIK3A table top.

And by removing the bezel around the LCD, the screen will sit flush with the top of the table, and give you that essential minimalist finish.

{gallery:autoplay=false} Removing the LCD from the Monitor Housing
Remove the stand, and any screws in the back of the monitor's housing.
It's probably all clipped together, so carefully pry the back of the housing away from the silver bezel around the screen.
You don't need to remove any of the shielding inside once the housing is apart. This is better left in place, to protect the back of the LCD. Note that you might need to relocate (and protect/insulate) the small PCB with the monitor's buttons on.
Remove any small screws that fix the bezel to the LCD's shielding.
Leaving you with an LCD panel that'll sit nice and flush to the table top.

{gallery:autoplay=false} Removing the LCD from the Monitor Housing

Remove the stand, and any screws in the back of the monitor's housing.

It's probably all clipped together, so carefully pry the back of the housing away from the silver bezel around the screen.

You don't need to remove any of the shielding inside once the housing is apart. This is better left in place, to protect the back of the LCD. Note that you might need to relocate (and protect/insulate) the small PCB with the monitor's buttons on.

Remove any small screws that fix the bezel to the LCD's shielding.

Leaving you with an LCD panel that'll sit nice and flush to the table top.

Screen Mounting

The first time out we used a Dremel with a router attachment to cut the hole in the table top for the monitor, which actually worked very nicely. However, these ultra-cheap tables really don't warrant that much power tool action, when a Stanley knife does the job just as easily and with a lot less mess. The choice is yours, of course.

Below you can see how we drew around the screen to get the sizing for the hole, and then drilled 13mm holes in each corner to give the cut-out some nice, radius corners.

Clamp a straight edge along the outside of the line you want to cut, and repeatedly run the knife along it. Remember not to cut all the way into the hole on the opposite side from where you started. Chances are the knife will continue and make a mess of the nice radius you put in there. Instead, stop 10cm short and cut again from the other end.

Go around all four sides (it won't take a lot of effort) and prize out the cut-out piece. It won't just come free, as it's glued to the structural filling inside the table, so take care when prizing it up so as not to damage the surface of the table. Run a knife around the honeycomb paper filling, and pull it out. You now have a hole to drop the monitor in.

{gallery:autoplay=false} Mounting the Screen in the Table
Lay the dismantled monitor on the table and draw around it. I also put the joystick and buttons roughly in place, to help locate the monitor in its ideal position.
Use the drill bit for the corners to mark where to drill. This'll give you nice, rounded corners on the cut out.
Drill the four corner holes for the cut out.
Mask off the area around the hold, to protect the surface of the table when you clamp a straight edge to it.
Clamp a straight edge to the outside of the cut out (so if you slip, the damage will be on the piece you're removing), and make lots of gentler cuts from one hole along the straight edge, stopping short of the second hole. Cut from the second hole, back along the same line to prevent the knife from slipping and damaging the radius of the second hole.
When you've cut right through the table top on all four sides, carefully pry the cut out up. It'll be stuck to the innards of the table, but will come free with a little effort. Save the cut out for later on.
Run a knife around the honeycomb and rip it out.
You've a nice, neat, monitor-shaped hole in the table!
If it's all gone well, take a moment to feel a little smug about yourself.

{gallery:autoplay=false} Mounting the Screen in the Table

Lay the dismantled monitor on the table and draw around it. I also put the joystick and buttons roughly in place, to help locate the monitor in its ideal position.

Use the drill bit for the corners to mark where to drill. This'll give you nice, rounded corners on the cut out.

Drill the four corner holes for the cut out.

Mask off the area around the hold, to protect the surface of the table when you clamp a straight edge to it.

Clamp a straight edge to the outside of the cut out (so if you slip, the damage will be on the piece you're removing), and make lots of gentler cuts from one hole along the straight edge, stopping short of the second hole. Cut from the second hole, back along the same line to prevent the knife from slipping and damaging the radius of the second hole.

When you've cut right through the table top on all four sides, carefully pry the cut out up. It'll be stuck to the innards of the table, but will come free with a little effort. Save the cut out for later on.

Run a knife around the honeycomb and rip it out.

You've a nice, neat, monitor-shaped hole in the table!

If it's all gone well, take a moment to feel a little smug about yourself.

Control Mounting

Flip the table top over and cut a letter box into the back. This gives you access to the inside-back of the table top so you can mount the joystick and buttons. Cut it out the same way as before and remove the honeycomb.

Mark where you want to mount your joystick and buttons -- we went with four buttons -- and drill 28mm holes for each one. This is the standard size for arcade buttons, and also gives the joystick plenty of room to move without the hole being visible around the round, flat cover that comes with the joystick.

But we didn't want any fixings visible on the PIK3A table top, which meant we couldn't use the mounting holes in the joystick's plate. Instead, we removed the mounting plate and used the screws that attach it to the body of the joystick (where the microswitches are) to fix the joystick in place. They're a little bit short, but when you countersink the holes in the table top, they'll still reach and grab hold of the thread solidly.

You'll need to remove the mounting plate's screws and the ball top, and then offer the joystick up from underneath the table. It's a little tricky, as the plate will be loose when you're inserting the joystick into the table, but it's not too hard. When it's in place, replace the mounting plate's screws when passing them through the table top, put the round cover over the stick, put the ball top back on, and you've fixed the joystick in place without any visible screws.

The buttons are a simple matter -- drill the 28mm hole, and put the nut on the back of the button! We went with a diamond arrangement for the buttons, plus a start button and coin button on the side of the table top.

{gallery:autoplay=false} Mounting the Controls
I was a bit rougher cutting the access panel in the back, as it's not as visible as the table top. So mark it up, and cut out the minimum that you need (to help maintain the table's already waning stability).
The access panel cut out.
Mark where you want your buttons and joystick (including those on the edge for coin and start), and drill 28mm holes for each one.
Remove the mounting plate from the joystick. These are the mounting holes you'll use to hold the joystick in place.
Use the mounting plate to mark the four holes just around the centre. You'll also need to countersink these holes so the screw heads sit flush.
Remove the ball top from the joystick, hold the mounting plate in place underneath and screw the joystick in place from above.
Put the round cover over the joystick and screw the ball top back in place. And you can now fix all the buttons in place, too.

{gallery:autoplay=false} Mounting the Controls

I was a bit rougher cutting the access panel in the back, as it's not as visible as the table top. So mark it up, and cut out the minimum that you need (to help maintain the table's already waning stability).

The access panel cut out.

Mark where you want your buttons and joystick (including those on the edge for coin and start), and drill 28mm holes for each one.

Remove the mounting plate from the joystick. These are the mounting holes you'll use to hold the joystick in place.

Use the mounting plate to mark the four holes just around the centre. You'll also need to countersink these holes so the screw heads sit flush.

Remove the ball top from the joystick, hold the mounting plate in place underneath and screw the joystick in place from above.

Put the round cover over the joystick and screw the ball top back in place. And you can now fix all the buttons in place, too.

Control Interface

Arcade controls are actually very simple. Even the joysticks are effectively just normally open push buttons (one for each of the four directions). The thing is, computers like the Raspberry Pi don't generally accept such simple buttons as a controller! So we've opted for an Arduino Leonardo as a way to interface the arcade controls with the Raspberry Pi (moreover, the video game emulators the Pi will be running), as it can be set to identify itself to the computer/Raspberry Pi as a standard keyboard.

So each button is connected into one of the Leonardo's inputs, which translates them into keyboard key presses. A ground wire loops around the other side of each microswitch. Because we love the old coin-ops, we set ours up using the standard keyboard controls for MAME. You don't have to do this, but it'll save you a job if you do it this way.

Download and install the Arduino IDE, if you haven't already, and plug in your Leonardo to your computer via a USB cable. Below is the code we hammered together that translates the joystick and buttons into key presses (using the MAME standards, as previously mentioned). But coders we ain't, so if you can improve on this sketch, please post it in the comments.

Before that, here's what to do if you've never played with Arduino before (skip ahead if you know how to upload the sketch to your Leonardo).

- A "sketch" is a program that your Leonardo will run after it's been uploaded. You can copy and paste the code below into the Arduino IDE window, or download the attached sketch file and open it using the IDE window. It's the same code, but take your pick of how to get onto the Arduino.
- Take a read through, and you'll see how each input relates to a specific keyboard key press. You can make any desired changes here before uploading to the Leonardo.
- Click the "Tools" menu and select "Arduino Leonardo" from the "Board" option.
- Click "Tools" again, and select your Leonardo from the list in the "Ports" option. It's now ready for uploading your sketch.
- Click the "Upload" button (a circular button with a right-facing arrow in it) to upload the sketch, and the Leonardo is ready to rock.

Sketch Code:

//element14 PIK3A Gaming Table Controls, using an Arduino Leonardo//

void setup() {
  Keyboard.begin();


  //Joystick and buttons pin allocations
  pinMode(0, INPUT_PULLUP); //Joystick Up
  pinMode(1, INPUT_PULLUP); //Joystick Down
  pinMode(2, INPUT_PULLUP); //Joystick Left
  pinMode(3, INPUT_PULLUP); //Joystick Right
  pinMode(4, INPUT_PULLUP); //Button 1
  pinMode(5, INPUT_PULLUP); //Button 2
  pinMode(6, INPUT_PULLUP); //Button 3
  pinMode(7, INPUT_PULLUP); //Button 4
  pinMode(8, INPUT_PULLUP); //Coin
  pinMode(9, INPUT_PULLUP); //Start
}


void loop() {


  // Button labels:
  int joystickUp = digitalRead(0);
  int joystickDown = digitalRead(1);
  int joystickLeft = digitalRead(2);
  int joystickRight = digitalRead(3);
  int button1 = digitalRead(4);
  int button2 = digitalRead(5);
  int button3 = digitalRead(6);
  int button4 = digitalRead(7);
  int coin = digitalRead(8);
  int start = digitalRead(9);


  // Joystick Up - Arrow Up Key
  if (joystickUp == LOW) {
    Keyboard.press(218);
  }
  else {
    Keyboard.release(218);
  }


  // Joystick Down - Arrow Down Key
  if (joystickDown == LOW) {
    Keyboard.press(217);
  }
  else {
    Keyboard.release(217);
  }


  // Joystick Left - Arrow Left Key
  if (joystickLeft == LOW) {
    Keyboard.press(216);
  }
  else {
    Keyboard.release(216);
  }


  // Joystick Right - Arrow Right Key
  if (joystickRight == LOW) {
    Keyboard.press(215);
  }
  else {
    Keyboard.release(215);
  }


  // Button 1 - Left CTRL
  if (button1 == LOW) {
    Keyboard.press(128);
  }
  else {
    Keyboard.release(128);
  }


  // Button 2 - Left ALT
  if (button2 == LOW) {
    Keyboard.press(130);
  }
  else {
    Keyboard.release(130);
  }


  // Button 3 - Left CTRL
  if (button3 == LOW) {
    Keyboard.press(32);
  }
  else {
    Keyboard.release(32);
  }


  // Button 4 - Left CTRL
  if (button4 == LOW) {
    Keyboard.press(129);
  }
  else {
    Keyboard.release(129);
  }


  // Coin - 5
  if (coin == LOW) {
    Keyboard.press(53);
  }
  else {
    Keyboard.release(53);
  }


  // Start - 1
  if (start == LOW) {
    Keyboard.press(49); delay(100);
  }
  else {
    Keyboard.release(49);
  }
  
}

Audio

These cube-shaped USB speakers from CPC were perfect for this job. Admittedly, you're about to void the warranty, but they're not expensive

What's great about them is that they're powered externally, so you get better volume, they're small, and the volume control is beautifully low profile; we're going to transplant that onto the edge of the PIK3A's table top next to the start and coin buttons. The speakers themselves are mounted inside the table, pointing downwards (so the grille holes aren't visible from the top).

There's nothing fancy about this task. Dismantle the speakers, desolder and then resolder each cable in turn so you can remove the speaker housings. You'll also need to extend the wires for the right speaker, as they're very short on account of being in the same housing as the volume control board. The 3.5mm jack goes into the Pi's audio output.

Fix the speakers inside the table on either side of the access hole for the joystick and buttons, and drill a 10mm hole in the front edge of the table for the volume control potentiometer. We then used heat glue to keep the volume control board in place.

{gallery:autoplay=false} Dismantling and Installing the Speakers
Unscrew the front of the speakers and remove the volume control. You'll need to pry the dial off the back and unscrew the nut holding it in place.
Desolder and reattach the various cables (one at a time, ideally) from the volume control board so you can remove the cube-shaped housings. Extend the wires for the right speaker, too.
Drill a mounting hole in the edge of the table to relocate the volume control.
Mark the mounting holes for the speakers on either side of the rear access panel.
Drill a few holes for the sound to get out, and then you can fix the speakers in place and the volume control in place. It's probably easier to do it before the joystick and buttons are in place.

{gallery:autoplay=false} Dismantling and Installing the Speakers

Unscrew the front of the speakers and remove the volume control. You'll need to pry the dial off the back and unscrew the nut holding it in place.

Desolder and reattach the various cables (one at a time, ideally) from the volume control board so you can remove the cube-shaped housings. Extend the wires for the right speaker, too.

Drill a mounting hole in the edge of the table to relocate the volume control.

Mark the mounting holes for the speakers on either side of the rear access panel.

Drill a few holes for the sound to get out, and then you can fix the speakers in place and the volume control in place. It's probably easier to do it before the joystick and buttons are in place.

Power

There wasn't really much room left to embed a mains extension inside the table. We cut a connector into the bottom, and wired the extension lead into that. This way we can add a longer power cable if required, or even use one for different regions should the PIK3A table find itself going abroad.

We've powered the speakers and Pi separately, just to spread the load out a bit, but to be honest the Pi3 could handle the speakers from its USB ports. The choice is yours, here.

The monitor, Pi3 and speakers are all connected into the mains extension, powering everything up while hiding the connections beneath the table.

{gallery:autoplay=false} Powering all the Parts
Mark a square in the back corner underneath the table and cut a hole for the power connector. The mains extension is going to connect to the rear of this IEC connector.
Remove the plug from the back of the mains extensions, feed the cable through the inside of the table and bring it out of the hole for the IEC connector. You can now solder the wires to the reverse of the IEC connector, and fit it in place.
It doesn't hurt to screw the mains extension to the bottom of the table, too. In my experience, they tend to fall off the eyelet holes if there's a light breeze, so this one is screwed in place from inside. You can plug the monitor and a couple of USB adapters into this, to power the screen, Raspberry Pi and speakers, while only requiring one power cable.

{gallery:autoplay=false} Powering all the Parts

Mark a square in the back corner underneath the table and cut a hole for the power connector. The mains extension is going to connect to the rear of this IEC connector.

Remove the plug from the back of the mains extensions, feed the cable through the inside of the table and bring it out of the hole for the IEC connector. You can now solder the wires to the reverse of the IEC connector, and fit it in place.

It doesn't hurt to screw the mains extension to the bottom of the table, too. In my experience, they tend to fall off the eyelet holes if there's a light breeze, so this one is screwed in place from inside.

You can plug the monitor and a couple of USB adapters into this, to power the screen, Raspberry Pi and speakers, while only requiring one power cable.

Finishing Touches

The monitor is a bit vulnerable here, so we decided to get a piece of 3mm acrylic cut to the same size as the table top (550mm by 550mm). It's just screwed into the table top in each corner, and the screws hidden behind screw caps. It's a cheap way to keep things protected.

I also added a panel mount USB port next to the access panel underneath, just in case I ever need to plug a USB keyboard (or other peripheral -- it could be a joypad if you wanted) into the Pi3.

{gallery:autoplay=false} Finishing Touches
An external USB port that goes into the Pi. This is a good one, as it also has a dust cap, since this probably isn't going to get a lot of use.
If you decide to put an acrylic or polycarbonate sheet on top to protect the monitor, remember to put it in place before you insert the buttons, as they'll need to pass through the sheet. Here we've screwed it in place in each corner, and covered the screw heads with caps.
Remember how you saved the cut out from the monitor hole? Trim it down to make a cover for the access panel on the back, after notching the bottom of the table as an exit for the power cables.
The finished PIK3A table is strong enough to hold Baxter here, but given how much we've hollowed it out, be careful about how much weight you put on it. Definitely don't stand on it to change a light bulb (mind you, I wouldn't trust these enough do that with a new Ikea table).

{gallery:autoplay=false} Finishing Touches

An external USB port that goes into the Pi. This is a good one, as it also has a dust cap, since this probably isn't going to get a lot of use.

If you decide to put an acrylic or polycarbonate sheet on top to protect the monitor, remember to put it in place before you insert the buttons, as they'll need to pass through the sheet.

Here we've screwed it in place in each corner, and covered the screw heads with caps.

Remember how you saved the cut out from the monitor hole? Trim it down to make a cover for the access panel on the back, after notching the bottom of the table as an exit for the power cables.

The finished PIK3A table is strong enough to hold Baxter here, but given how much we've hollowed it out, be careful about how much weight you put on it. Definitely don't stand on it to change a light bulb (mind you, I wouldn't trust these enough do that with a new Ikea table).

Then it's just a case of screwing the legs to the table top, and installing RetroPie on the SD card. There's one additional step you might have to perform for the time being, to get RetroPie running in the Raspberry Pi 3. The developers will undoubtedly fix things very soon, but for the moment we had to copy over the "*.elf" files (that'd be start.elf, start_cd.elf, start_db.elf and start_x.elf) from the "Boot" partition of an SD card that had the official, Raspberry Pi NOOBs image.

Not a complex or particularly onerous task, but a necessary one for the time being. This should get RetroPie booted up and running beautifully on your awesome new PIK3A retro gaming table. I'm sure it won't be long at all before this step becomes unnecessary, of course -- likely by the time you've built your cab.

UPDATE: The RetroPie guys have already released an updated image, so you don't have to jump through any hoops to get RetroPie working on your Raspberry Pi 3! Great work, guys!

http://blog.petrockblock.com/2016/03/02/retropie-3-6-is-released/

As you can see, this is a pretty fascinating interpretation of the classic gaming system, so we'd be particularly interested in seeing how you might do the same, as much as copy our build part for part. Post your own retro gaming projects right here in the Raspberry Pi Projects sections, and casually blow our minds!

If you want to see them in action right away, join us as we head out and about on the Raspberry Pi 3's launch day in Leeds and Chicago!

And if you're looking to delve a little deeper into the Raspberry Pi 3, why not sign up for our RoadTest right now and review the unit for the world to see?

Supporting Downloads/Files

- PIK3A Supporting Files

NEW! Raspberry Pi 3 Model B
Frequently Asked Questions	Comparison Chart	Technical Specifications
Unboxing Video	40 Pin Out

Tags: fruitful_three, retro gaming, raspberry pi arcade cabinet, picade, pi3, pik3a, gaming, raspberry pi 3, raspberry_pi_projects, pikea, video games

PIK3A: The Raspberry Pi 3 IKEA Retro Gaming Table

cstanton — Tue, 16 Jul 2024 10:02:27 GMT

Revision 2 posted to Documents by cstanton on 7/16/2024 10:02:27 AM

Meet the PIK3A Gaming Table!

Parts, Bits and Pieces

So here's the gist of this simple, but super-stylish project.

It's an IKEA Lack coffee table with an LCD monitor cut into the top, arcade controls next to the monitor, and a Raspberry Pi 3 and accessories buried inside the table.

Let's begin with an overview of the parts you'll need:

The Cabinet: IKEA Lack coffee table.
The Brains: Raspberry Pi
The Controls: Arduino Leonardo
The Joystick: A classic, four-way ball-top joystick.
The Buttons: From CPC - From MCM
The Display: An old 17" LCD monitor (4:3 ratio is better given the square shape of the table).
The Sound: This pair of USB-powered computer speakers.
The Power: A Raspberry Pi 2.5A USB power supply, and a mains extension.
The Stuff: Cables, connectors, screws.

Table Top Gaming

Dismantle Your Monitor

And by removing the bezel around the LCD, the screen will sit flush with the top of the table, and give you that essential minimalist finish.

{gallery:autoplay=false} Removing the LCD from the Monitor Housing
Remove the stand, and any screws in the back of the monitor's housing.
It's probably all clipped together, so carefully pry the back of the housing away from the silver bezel around the screen.
You don't need to remove any of the shielding inside once the housing is apart. This is better left in place, to protect the back of the LCD. Note that you might need to relocate (and protect/insulate) the small PCB with the monitor's buttons on.
Remove any small screws that fix the bezel to the LCD's shielding.
Leaving you with an LCD panel that'll sit nice and flush to the table top.

{gallery:autoplay=false} Removing the LCD from the Monitor Housing

Remove the stand, and any screws in the back of the monitor's housing.

It's probably all clipped together, so carefully pry the back of the housing away from the silver bezel around the screen.

Remove any small screws that fix the bezel to the LCD's shielding.

Leaving you with an LCD panel that'll sit nice and flush to the table top.

Screen Mounting

Below you can see how we drew around the screen to get the sizing for the hole, and then drilled 13mm holes in each corner to give the cut-out some nice, radius corners.

{gallery:autoplay=false} Mounting the Screen in the Table
Lay the dismantled monitor on the table and draw around it. I also put the joystick and buttons roughly in place, to help locate the monitor in its ideal position.
Use the drill bit for the corners to mark where to drill. This'll give you nice, rounded corners on the cut out.
Drill the four corner holes for the cut out.
Mask off the area around the hold, to protect the surface of the table when you clamp a straight edge to it.
Clamp a straight edge to the outside of the cut out (so if you slip, the damage will be on the piece you're removing), and make lots of gentler cuts from one hole along the straight edge, stopping short of the second hole. Cut from the second hole, back along the same line to prevent the knife from slipping and damaging the radius of the second hole.
When you've cut right through the table top on all four sides, carefully pry the cut out up. It'll be stuck to the innards of the table, but will come free with a little effort. Save the cut out for later on.
Run a knife around the honeycomb and rip it out.
You've a nice, neat, monitor-shaped hole in the table!
If it's all gone well, take a moment to feel a little smug about yourself.

{gallery:autoplay=false} Mounting the Screen in the Table

Lay the dismantled monitor on the table and draw around it. I also put the joystick and buttons roughly in place, to help locate the monitor in its ideal position.

Use the drill bit for the corners to mark where to drill. This'll give you nice, rounded corners on the cut out.

Drill the four corner holes for the cut out.

Mask off the area around the hold, to protect the surface of the table when you clamp a straight edge to it.

Run a knife around the honeycomb and rip it out.

You've a nice, neat, monitor-shaped hole in the table!

If it's all gone well, take a moment to feel a little smug about yourself.

Control Mounting

{gallery:autoplay=false} Mounting the Controls
I was a bit rougher cutting the access panel in the back, as it's not as visible as the table top. So mark it up, and cut out the minimum that you need (to help maintain the table's already waning stability).
The access panel cut out.
Mark where you want your buttons and joystick (including those on the edge for coin and start), and drill 28mm holes for each one.
Remove the mounting plate from the joystick. These are the mounting holes you'll use to hold the joystick in place.
Use the mounting plate to mark the four holes just around the centre. You'll also need to countersink these holes so the screw heads sit flush.
Remove the ball top from the joystick, hold the mounting plate in place underneath and screw the joystick in place from above.
Put the round cover over the joystick and screw the ball top back in place. And you can now fix all the buttons in place, too.

{gallery:autoplay=false} Mounting the Controls

The access panel cut out.

Mark where you want your buttons and joystick (including those on the edge for coin and start), and drill 28mm holes for each one.

Remove the mounting plate from the joystick. These are the mounting holes you'll use to hold the joystick in place.

Use the mounting plate to mark the four holes just around the centre. You'll also need to countersink these holes so the screw heads sit flush.

Remove the ball top from the joystick, hold the mounting plate in place underneath and screw the joystick in place from above.

Put the round cover over the joystick and screw the ball top back in place. And you can now fix all the buttons in place, too.

Control Interface

Before that, here's what to do if you've never played with Arduino before (skip ahead if you know how to upload the sketch to your Leonardo).

- A "sketch" is a program that your Leonardo will run after it's been uploaded. You can copy and paste the code below into the Arduino IDE window, or download the attached sketch file and open it using the IDE window. It's the same code, but take your pick of how to get onto the Arduino.
- Take a read through, and you'll see how each input relates to a specific keyboard key press. You can make any desired changes here before uploading to the Leonardo.
- Click the "Tools" menu and select "Arduino Leonardo" from the "Board" option.
- Click "Tools" again, and select your Leonardo from the list in the "Ports" option. It's now ready for uploading your sketch.
- Click the "Upload" button (a circular button with a right-facing arrow in it) to upload the sketch, and the Leonardo is ready to rock.

Sketch Code:

//element14 PIK3A Gaming Table Controls, using an Arduino Leonardo//

void setup() {
  Keyboard.begin();


  //Joystick and buttons pin allocations
  pinMode(0, INPUT_PULLUP); //Joystick Up
  pinMode(1, INPUT_PULLUP); //Joystick Down
  pinMode(2, INPUT_PULLUP); //Joystick Left
  pinMode(3, INPUT_PULLUP); //Joystick Right
  pinMode(4, INPUT_PULLUP); //Button 1
  pinMode(5, INPUT_PULLUP); //Button 2
  pinMode(6, INPUT_PULLUP); //Button 3
  pinMode(7, INPUT_PULLUP); //Button 4
  pinMode(8, INPUT_PULLUP); //Coin
  pinMode(9, INPUT_PULLUP); //Start
}


void loop() {


  // Button labels:
  int joystickUp = digitalRead(0);
  int joystickDown = digitalRead(1);
  int joystickLeft = digitalRead(2);
  int joystickRight = digitalRead(3);
  int button1 = digitalRead(4);
  int button2 = digitalRead(5);
  int button3 = digitalRead(6);
  int button4 = digitalRead(7);
  int coin = digitalRead(8);
  int start = digitalRead(9);


  // Joystick Up - Arrow Up Key
  if (joystickUp == LOW) {
    Keyboard.press(218);
  }
  else {
    Keyboard.release(218);
  }


  // Joystick Down - Arrow Down Key
  if (joystickDown == LOW) {
    Keyboard.press(217);
  }
  else {
    Keyboard.release(217);
  }


  // Joystick Left - Arrow Left Key
  if (joystickLeft == LOW) {
    Keyboard.press(216);
  }
  else {
    Keyboard.release(216);
  }


  // Joystick Right - Arrow Right Key
  if (joystickRight == LOW) {
    Keyboard.press(215);
  }
  else {
    Keyboard.release(215);
  }


  // Button 1 - Left CTRL
  if (button1 == LOW) {
    Keyboard.press(128);
  }
  else {
    Keyboard.release(128);
  }


  // Button 2 - Left ALT
  if (button2 == LOW) {
    Keyboard.press(130);
  }
  else {
    Keyboard.release(130);
  }


  // Button 3 - Left CTRL
  if (button3 == LOW) {
    Keyboard.press(32);
  }
  else {
    Keyboard.release(32);
  }


  // Button 4 - Left CTRL
  if (button4 == LOW) {
    Keyboard.press(129);
  }
  else {
    Keyboard.release(129);
  }


  // Coin - 5
  if (coin == LOW) {
    Keyboard.press(53);
  }
  else {
    Keyboard.release(53);
  }


  // Start - 1
  if (start == LOW) {
    Keyboard.press(49); delay(100);
  }
  else {
    Keyboard.release(49);
  }
  
}

Audio

These cube-shaped USB speakers from CPC were perfect for this job. Admittedly, you're about to void the warranty, but they're not expensive

{gallery:autoplay=false} Dismantling and Installing the Speakers
Unscrew the front of the speakers and remove the volume control. You'll need to pry the dial off the back and unscrew the nut holding it in place.
Desolder and reattach the various cables (one at a time, ideally) from the volume control board so you can remove the cube-shaped housings. Extend the wires for the right speaker, too.
Drill a mounting hole in the edge of the table to relocate the volume control.
Mark the mounting holes for the speakers on either side of the rear access panel.
Drill a few holes for the sound to get out, and then you can fix the speakers in place and the volume control in place. It's probably easier to do it before the joystick and buttons are in place.

{gallery:autoplay=false} Dismantling and Installing the Speakers

Unscrew the front of the speakers and remove the volume control. You'll need to pry the dial off the back and unscrew the nut holding it in place.

Desolder and reattach the various cables (one at a time, ideally) from the volume control board so you can remove the cube-shaped housings. Extend the wires for the right speaker, too.

Drill a mounting hole in the edge of the table to relocate the volume control.

Mark the mounting holes for the speakers on either side of the rear access panel.

Drill a few holes for the sound to get out, and then you can fix the speakers in place and the volume control in place. It's probably easier to do it before the joystick and buttons are in place.

Power

We've powered the speakers and Pi separately, just to spread the load out a bit, but to be honest the Pi3 could handle the speakers from its USB ports. The choice is yours, here.

The monitor, Pi3 and speakers are all connected into the mains extension, powering everything up while hiding the connections beneath the table.

{gallery:autoplay=false} Powering all the Parts
Mark a square in the back corner underneath the table and cut a hole for the power connector. The mains extension is going to connect to the rear of this IEC connector.
Remove the plug from the back of the mains extensions, feed the cable through the inside of the table and bring it out of the hole for the IEC connector. You can now solder the wires to the reverse of the IEC connector, and fit it in place.
It doesn't hurt to screw the mains extension to the bottom of the table, too. In my experience, they tend to fall off the eyelet holes if there's a light breeze, so this one is screwed in place from inside. You can plug the monitor and a couple of USB adapters into this, to power the screen, Raspberry Pi and speakers, while only requiring one power cable.

{gallery:autoplay=false} Powering all the Parts

Mark a square in the back corner underneath the table and cut a hole for the power connector. The mains extension is going to connect to the rear of this IEC connector.

You can plug the monitor and a couple of USB adapters into this, to power the screen, Raspberry Pi and speakers, while only requiring one power cable.

Finishing Touches

I also added a panel mount USB port next to the access panel underneath, just in case I ever need to plug a USB keyboard (or other peripheral -- it could be a joypad if you wanted) into the Pi3.

{gallery:autoplay=false} Finishing Touches
An external USB port that goes into the Pi. This is a good one, as it also has a dust cap, since this probably isn't going to get a lot of use.
If you decide to put an acrylic or polycarbonate sheet on top to protect the monitor, remember to put it in place before you insert the buttons, as they'll need to pass through the sheet. Here we've screwed it in place in each corner, and covered the screw heads with caps.
Remember how you saved the cut out from the monitor hole? Trim it down to make a cover for the access panel on the back, after notching the bottom of the table as an exit for the power cables.
The finished PIK3A table is strong enough to hold Baxter here, but given how much we've hollowed it out, be careful about how much weight you put on it. Definitely don't stand on it to change a light bulb (mind you, I wouldn't trust these enough do that with a new Ikea table).

{gallery:autoplay=false} Finishing Touches

An external USB port that goes into the Pi. This is a good one, as it also has a dust cap, since this probably isn't going to get a lot of use.

If you decide to put an acrylic or polycarbonate sheet on top to protect the monitor, remember to put it in place before you insert the buttons, as they'll need to pass through the sheet.

Here we've screwed it in place in each corner, and covered the screw heads with caps.

Remember how you saved the cut out from the monitor hole? Trim it down to make a cover for the access panel on the back, after notching the bottom of the table as an exit for the power cables.

UPDATE: The RetroPie guys have already released an updated image, so you don't have to jump through any hoops to get RetroPie working on your Raspberry Pi 3! Great work, guys!

http://blog.petrockblock.com/2016/03/02/retropie-3-6-is-released/

If you want to see them in action right away, join us as we head out and about on the Raspberry Pi 3's launch day in Leeds and Chicago!

And if you're looking to delve a little deeper into the Raspberry Pi 3, why not sign up for our RoadTest right now and review the unit for the world to see?

Supporting Downloads/Files

- PIK3A Supporting Files

NEW! Raspberry Pi 3 Model B
Frequently Asked Questions	Comparison Chart	Technical Specifications
Unboxing Video	40 Pin Out

Tags: fruitful_three, retro gaming, raspberry pi arcade cabinet, picade, pi3, pik3a, gaming, raspberry pi 3, raspberry_pi_projects, pikea, video games

Geocaching with the element14 Circuit Board Trackable

cstanton — Wed, 15 Dec 2021 13:13:06 GMT

Current Revision posted to Documents by cstanton on 12/15/2021 1:13:06 PM

Polite note: signups have now long since ended (2015), but please continue to post where you get to if you were one of the lucky ones to receive one...

We have a project, and you can help, we want to connect the world!

If you're lucky enough to sign up and be sent one of the 1,500 element14 Circuit Board trackables on the 15th of June 2015 then it is your duty to help create a virtual circuit between landmarks of Scientific and Engineering Achievement with your trackable travelling from each geocache to your chosen destination! How far can you get your trackable to go?

Do not worry if you aren't one of the first to get hold of a trackable, you can still play your part and participate by finding one that is out there in a geocache and help it on its journey!

We want to see you when you've found a circuit board trackable - take a photo' of yourself with it and post it onto the element14 Facebook and Twitter with the hashtag #ConnectedWorld Or here on the Community!

Trackable Circuit Board?

If you're familiar with Geocaching, these Circuit Board trackables work like geocoins. Each trackable is uniquely identifiable because they each have a code along with an activation code, and when you activate it on Geocaching.com you can send it on its journey and see where it has travelled or which geocache it is stored in. Along with whom has helped it along its way!

When you discover the trackable when it is in circulation, you then have the perfect opportunity to look it up on the Geocaching.com site where you can get a cool icon for finding it, read more about what to do with it and then share your experience, either blogging, sharing photo's or even just commenting here!

Find one of the 1,500 element14 trackable circuit boards using a GPS receiver and log it on Geocaching.com
Take a photograph with the trackable to show your hard work and claim credit!
We no longer have the 'Atlas of Scientific Achievements'

We want to hear from you!

Have you been geocaching before? Is this your first time doing so? Have you requested a trackable or want to go and find one?

We want to see and hear about your geocaching adventures, your project builds or what you currently use to geocache with!

So join us, as part of the Community of Engineers, Makers, Educators and Inventors on a Geocaching adventure!

Build a Raspberry Pi GPS Project?

We have an example here: /products/raspberry-pi/raspberrypi_projects/b/blog/posts/putting-together-the-pieces---raspberry-pi-2-gps-geocaching-project

Tags: geocaching, element14_trackable, raspberry_pi_2, raspberry_pi_geocaching, raspberry_pi_projects

Geocaching with the element14 Circuit Board Trackable

cstanton — Wed, 15 Dec 2021 13:06:37 GMT

Revision 4 posted to Documents by cstanton on 12/15/2021 1:06:37 PM

Polite note: signups have now long since ended (2015), but please continue to post where you get to if you were one of the lucky ones to receive one...

We have a project, and you can help, we want to connect the world!

Do not worry if you aren't one of the first to get hold of a trackable, you can still play your part and participate by finding one that is out there in a geocache and help it on its journey!

Trackable Circuit Board?

Find one of the 1,500 element14 trackable circuit boards using a GPS receiver and log it on Geocaching.com

Take a photograph with the trackable to show your hard work and claim credit!

We want to hear from you!

Have you been geocaching before? Is this your first time doing so? Have you requested a trackable or want to go and find one?

We want to see and hear about your geocaching adventures, your project builds or what you currently use to geocache with!

So join us, as part of the Community of Engineers, Makers, Educators and Inventors on a Geocaching adventure!

Build a Raspberry Pi GPS Project?

We have an example here: /products/raspberry-pi/raspberrypi_projects/b/blog/posts/putting-together-the-pieces---raspberry-pi-2-gps-geocaching-project

Tags: geocaching, element14_trackable, raspberry_pi_2, raspberry_pi_geocaching, raspberry_pi_projects

Geocaching with the element14 Circuit Board Trackable

cstanton — Wed, 15 Dec 2021 13:06:13 GMT

Revision 3 posted to Documents by cstanton on 12/15/2021 1:06:13 PM

Polite note: signups have now long since ended (2015), but please continue to post where you get to if you were one of the lucky ones to receive one...

We have a project, and you can help, we want to connect the world!

Do not worry if you aren't one of the first to get hold of a trackable, you can still play your part and participate by finding one that is out there in a geocache and help it on its journey!

Trackable Circuit Board?

Find one of the 1,500 element14 trackable circuit boards using a GPS receiver and log it on Geocaching.com

Take a photograph with the trackable to show your hard work and claim credit!

We want to hear from you!

Have you been geocaching before? Is this your first time doing so? Have you requested a trackable or want to go and find one?

We want to see and hear about your geocaching adventures, your project builds or what you currently use to geocache with!

So join us, as part of the Community of Engineers, Makers, Educators and Inventors on a Geocaching adventure!

Build a Raspberry Pi GPS Project?

We have an example here: /products/raspberry-pi/raspberrypi_projects/b/blog/posts/putting-together-the-pieces---raspberry-pi-2-gps-geocaching-project

Tags: geocaching, element14_trackable, raspberry_pi_2, raspberry_pi_geocaching, raspberry_pi_projects

Geocaching with the element14 Circuit Board Trackable

cstanton — Wed, 15 Dec 2021 13:02:47 GMT

Revision 2 posted to Documents by cstanton on 12/15/2021 1:02:47 PM

Polite note: signups have now long since ended (2015), but please continue to post where you get to if you were one of the lucky ones to receive one...

We have a project, and you can help, we want to connect the world!

Do not worry if you aren't one of the first to get hold of a trackable, you can still play your part and participate by finding one that is out there in a geocache and help it on its journey!

Trackable Circuit Board?

Find one of the 1,500 element14 trackable circuit boards using a GPS receiver and log it on Geocaching.com

Take a photograph with the trackable to show your hard work and claim credit!

We want to hear from you!

Have you been geocaching before? Is this your first time doing so? Have you requested a trackable or want to go and find one?

We want to see and hear about your geocaching adventures, your project builds or what you currently use to geocache with!

So join us, as part of the Community of Engineers, Makers, Educators and Inventors on a Geocaching adventure!,

Tags: geocaching, element14_trackable, raspberry_pi_2, raspberry_pi_geocaching, raspberry_pi_projects

Geocaching Ideas!!

Former Member — Fri, 08 Oct 2021 08:31:01 GMT

Current Revision posted to Documents by Former Member on 10/8/2021 8:31:01 AM

List of any unique container ideas!!

List of any cool puzzle caches!!
Ideas to better cache hides!!

I love geocaching and would love to step things up a notch so can anyone please give so ideas on better hides and really cool or unique containers?

Tags: geocaching, raspberry_pi_geocaching, raspberry_pi_projects

Geocaching

Former Member — Fri, 08 Oct 2021 08:30:07 GMT

Current Revision posted to Documents by Former Member on 10/8/2021 8:30:07 AM

Right now I am getting travel bugs ready to drop tomorrow, its fun to watch them travel. I get messages from all over the world.

They will be going to a TB Hotel in a cemetery cache. I would love to hear your interests and how you spend your time. Let's share!!

Tags: geocachers, raspberry_pi_geocaching, raspberry_pi_projects, adventures

Raspberry Pi 3 B+ GPS Treasure Tracker

biglesp — Wed, 06 Oct 2021 21:31:55 GMT

Current Revision posted to Documents by biglesp on 10/6/2021 9:31:55 PM

Raspberry Pi 3 B+ GPS Treasure Tracker

With the release of the Raspberry Pi 3 B+ we wanted to create a project that would use the new Pi in a fun and engaging way. So The Raspberry Pi 3B+ Treasure Tracker was born. With this device, users can place treasure upon a map, and use GPS to track their progress to the treasure.

For this project we will need

A Raspberry Pi 3B +
The official Raspberry Pi Screen
A Microstack Baseboard
A Microstack GPS
GPS Antenna
Enclosure for the project
USB battery with 2 outputs (1 @ 2A > and another @ 1A >)
2 x micro USB to USB A leads
A 3G/4G Mobile wireless device or hot spot.

Raspberry Pi 3 B +?

Yes we have a new Raspberry Pi! This incremental update to the original Raspberry Pi 3 offers a slightly faster quad core CPU (1.4Ghz) 1 GB RAM but the real improvement is with the networking. There is new WiFi! Via wireless ac (5GHz) which joins the already great wireless package (2.4GHz b/g/n) and we also have Bluetooth 4.2 and BLE! Not to feel left out, the Ethernet has been beefed up to around 300Mb/s thanks to using a LAN7515 chip over a USB2.0 interface. So now we have much better Ethernet speeds, still not Gigabit, but enough...well until the Pi 4 comes out. Along side the now standard 40pin GPIO we see four new pins marked PoE, Power over Ethernet. Yes this Pi can be powered over PoE via a new add on board, available soon! So with the power of the new Raspberry Pi 3 B + we can create our own GPS Treasure Tracker. So what are we waiting for?

Building the kit

With the Raspberry Pi 3 B + powered down, connect the Raspberry Pi 3B + to the official screen via the instructions included with the kit.

We shall be powering the screen from a separate micro USB power supply as the GPIO pins will be in use.

Now attach the Microstack add on board to the first 26 pins of the GPIO, these are the pins nearest the micro SD slot.

Now attach the Microstack GPS unit to the Microstack board, the location of the connections for the GPS unit are quite clearly marked on the Microstack board, and the GPS unit will only fit in one way.

Connect the antenna to the GPS unit but do not allow the metal connectors to touch the Raspberry Pi as this will create a short. Power up the Raspberry Pi and boot to the desktop and we start by configuring the Raspberry Pi 3 B + to use UART. On previous models of Pi (up to Pi 3) UART was found at /dev/ttyAMA0 but that is now used by Bluetooth, and from Pi 3 onwards we can now find the UART device at /dev/ttyS0. But first we need to tell the Pi so. In a terminal type in the following to go to the config.txt document

sudo nano /boot/config.txt

Go to the end of the document and make a new line, then add the following.

#Enable UART for Pi 3
dtparam=spi=on
dtoverlay=pi3-disable-bt-overlay
core_freq=250
enable_uart=1
force_turbo=1

Now close the editor by pressing CTRL + X, then Y and finally Enter.

Now lets edit the cmdline.txt file which Raspbian uses every time it boots. We need to remove a reference to “console=serial0,115200” and keep “console=tty1”.

In the terminal type

sudo nano /boot/cmdline.txt

It should look similar to this but only change what we have said, leave the rest as it is! Otherwise you Pi may not boot.

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

Now close the editor by pressing CTRL + X, then Y and finally Enter.

To ensure that Bluetooth does not interfere with the UART0 device, we first need to disable the service. In the terminal type.

sudo systemctl disable hciuart

We next edit the hciaurt service so that it uses the correct UART device (ttyS0)

In the terminal type

sudo nano /lib/systemd/system/hciuart.service

Then find the line starting “After=dev-serial1.device” and change it to “After=dev-ttyS0.device”

Now close the editor by pressing CTRL + X, then Y and finally Enter.

With the antenna connected and hung outside of a window for the test, in the terminal enter this command to see the raw output from the GPS unit. It may take your GPS unit a few minutes to get a signal but as long as it can see the sky, it will connect.

sudo cat /dev/ttyS0

You should see raw data stream across the screen, you may be able to see your longitude and latitude as it races across the screen. With the test completed, now we move to installing the software for the project, and for this we need to ensure the system is up to date and that we have the latest software. In a terminal window type.

sudo apt update && sudo apt upgrade -y && sudo reboot

This may take a while, but once completed the system will reboot to ensure all of the changes have been made. After a few minutes you will see the Raspbian desktop again, and you will need to open a new terminal window.

We shall stop and disable the tty service as if left running it may generate a few issues. In the terminal type

sudo systemctl stop serial-getty@ttyS0.service
sudo systemctl disable serial-getty@ttyS0.service

Reboot the Raspberry Pi and then return to the Raspbian desktop, open the terminal once more, in here we shall install the software for GPS. In the terminal type.

sudo apt-get install gpsd gpsd-clients python-gps

In order to use GPSD correctly with Raspbian we need to stop and disable a service started by installing GPSD as if left as is it will cause issues for the project. In the terminal enter the following commands to do this.

sudo systemctl stop gpsd.socket
sudo systemctl disable gpsd.socket

Now lets tell GPSD where to find our GPS unit. In the terminal type

sudo gpsd /dev/ttyS0 -F /var/run/gpsd.sock

Now we can test to see if our GPS unit is reporting the correct location. In the terminal use the cgps command to open a client that will tell us everything about our device, and hopefully our location.

cgps -s

So where am I?

In cgps we can see that our latitude and longitude have been found. But how do we check that this is correct? The easiest way is to open http://maps.google.co.uk and once loaded look in the address bar. You will see two numbers. First we have the latitude our position as an angle between north and south. The second number is our longitude, our position east to west as an angle. Replace these numbers with those from cgps and you will see the map centre on your GPS location.

Installing the Python Libraries

The Microstack baseboard on to which our Microstack GPS sits, requires a little configuration in order to be used. We need to enable I2C and SPI on our GPIO and to do this we need to go to the Raspbian menu >> Preferences >> Raspberry Pi Configuration. In there select Interfaces and Enable I2C and SPI. Click Ok and for good measure reboot the Pi.

Now back to the terminal!

We now need to install the Microstack Node Python 3 library, so in a terminal type

sudo pip3 install microstacknode

Once installed, lets check that our Python library can connect and use the Microstack GPS. In your favourite Python 3 editor (IDLE, or Thonny) enter the following code to check our GPS location every two seconds.

import microstacknode.hardware.gps.l80gps
import time
gps = microstacknode.hardware.gps.l80gps.L80GPS()
while True:
 data = gps.get_gprmc()
 lat = data.get("latitude")
 long = data.get("longitude")
 print(lat,long)
 time.sleep(2)

Save the code as GPSTest.py and then run the code and you should see your position appear in the Python shell.

Google Maps

All across my home town of Blackpool, there is treasure! Not gold or rubies, or bitcoin, rather cultural treasures such as Blackpool Tower, The Blackpool Pleasure Beach (amusement park) and Blackpool Zoo. So lets create a Treasure Tracker that will point us to those locations. But first we need to find those locations on a map.

Open Google Maps once again, and locate these places (or choose your own, as it is a long walk from Australia to Blackpool)

Tower = (53.8159877,-3.0554085)
Zoo = (53.8157874,-3.0107095)
Amusement_Park = (53.7924182,-3.0556338)

Make a note of the latitude and longitude, in the above example we have noted them as objects called tuples, which we can later use in the code.

Open up your favourite Python editor and lets start coding the project! Oh but first ensure that you save the project as “micromapper.py”

We start by using a line that will later enable our code to be run as an executable, this line tells the code where to find the Python 3 interpreter.

#!/usr/bin/env python3

We next start importing the libraries that we need and they are...

gmplot = Plotting data on a Google map
subprocess = Enables us to use Linux commands via Python
time = Used to control the time between screen updates

import gmplot, subprocess, time
import microstacknode.hardware.gps.l80gps

In order to use the Microstack GPS we need to create an object that we can reference, as “microstacknode.hardware.gps.l80gps” is rather a lot to type. So lets call it gps and store the reference in there.

gps = microstacknode.hardware.gps.l80gps.L80GPS()

Next we use the locations chosen and store their data as tuples (Python data type that separates values using a comma. Tuples are immutable, meaning they cannot be updated, so need to be destroyed and recreated as a whole new object)

Tower = (53.8159877,-3.0554085)
Zoo = (53.8157874,-3.0107095)
Amusement_Park = (53.7924182,-3.0556338)

In order for us to use the location data, we need to split the data into latitudes and longitudes. To do this we shall use two lists (comma separated data type that is mutable, so it can be updated) the first will contain the latitudes of the locations, and the other the longitudes. To extract these from the tuples we tell the list that for the latitudes we wish to extract the first item in the tuple, this is at position 0 (Python starts counting from 0). For the longitudes we tell the list that we need the data from position 1 in each tuple.

latitudes = [Tower[0],Zoo[0],Amusement_Park[0]]
longitudes = [Tower[1],Zoo[1],Amusement_Park[1]]

So now that we have our locations, lets find out where we are. We tell Python to wait for 2 seconds before moving onwards.

time.sleep(2)

Then we create an object called “data” that we use to shorten the function that will query the Microstack GPS for information.

data = gps.get_gprmc()

To extract the latitude and longitude data we need to call our new “data” object with an argument to retrieve the information. This is then stored in two variables, lat and long. For debug purposes we then print this information to the Python shell.

lat = data.get("latitude")
long = data.get("longitude")
print(lat,long)

We next create two lists, used to store the location data saved to our variables lat and long. We need to use a list as we the function used later will need an iterable object, which a list is.

loc_lat = [lat]
loc_long = [long]

Now lets get to the code that will centre a Google map on to the users current location. For this we need to create an object called “gmap” and then use that to set the latitude and longitude from the GPS, and set the map to level “20” which zooms the window to nearby street level, but feel free to change this to meet your needs.

gmap = gmplot.GoogleMapPlotter(lat, long, 20)

With the map centred, it would be prudent to locate the user. So to do this we use a heat map, normally used to identify areas of high activity, but in this case it looks like a thermal image of a person from space or it looks like the Predator (80s movie) is on the treasure hunt. When using the heat map we need to iterate over values in a list. In this case there is only one value per list, this is because we are not using the heat map for its true purpose. Really we should be using it to iterate over multiple items in lists and then plotting these hot spots on the map. But we are using it just to identify the user.

gmap.heatmap(loc_lat,loc_long)

With the user located, now we need to scatter the “treasure” across the map. And for this we scatter red makers across the map. We have all seen these markers on Google Maps before. We tell gmplot to use the data stored in the lists “latitudes” and “longitudes” as the location, then ‘r’ denotes a red marker.

gmap.scatter(latitudes, longitudes, 'r', marker=True)

With the user located and the treasure plotted it is now time to create the map. Gmplot can create the HTML needed for the map and in this case we save it as “mymap.html”

gmap.draw("mymap.html")

The last line of this section is where we use “subprocess” to call the Chromium browser in full screen mode and open a specially created HTML page (more on that later.) The syntax of the subprocess.call function is that the command and any parameters / arguments need to passed as items in a list. So we wrap the contents in square brackets “[ ]” and separate the contents using commas. Note that this assumes that you have saved your code to the directory GPS_Treasure_Hunt, so change this to match your own setup.

subprocess.call(["chromium-browser"," --start-fullscreen"," /home/pi/GPS_Treasure_Hunt/frame.html"])

Moving on we now get to the main loop that will continually show the location of the user and update the map to show the direction in which they are moving. Here we use the same “data” object to connect to the GPS unit, then we store the user location into the two variables “lat” and “long”, this is then printed to the Python shell for debug purposes.

while True:
 data = gps.get_gprmc()
 lat = data.get("latitude")
 long = data.get("longitude")
 print(lat,long)

In the next part of this code we centre the map on the user and plot their location using a heat map. Then we update the values stored inside the loc_lat and loc_long lists, printing the values to the shell for debug and then setting the values for our user location, via the heat map.

gmap = gmplot.GoogleMapPlotter(lat, long, 18)
 loc_lat = [lat]
 loc_long = [long]
 print(loc_lat, loc_long)
 gmap.heatmap(loc_lat,loc_long)

We lastly update the map data, and then instruct the code to wait for 5 seconds before repeating the process.

That is all the code for this part of the project. Save the code but don’t run it just yet as we need to create an HTML frame to store the Python generated map, and to update the contents.

The HTML

Our Treasure Tracker map is generated and updated by the Python code, but the contents are not dynamically updated in the browser. In order to do this we need to create a new web page, into which we use a http refresh, in the head of the HTML document, to reload the page.

Our Python generated map is stored in “mymap.html” and using an iframe, an HTML inline frame, we can open the map inside our web page and specify the size of the iframe to match the resolution of the screen, in this case the official Pi screen is 800 pixels wide, by 480 tall. Using a notepad editor, create this file and save it as “frame.html” inside the same directory as the Python code that we have just written.

<!DOCTYPE html>

<html>

<head>

</head>

<body>

<p>Your browser does not support iframes.</p>

</iframe>

</body>

</html>

Give the code a test!

Head back over to the Python code and save your work, then run the code (Run >> Run Module for IDLE)

You should see the code start in the Python shell, and if you are quick you will see the GPS coordinates printed to the shell. But what we really want to see is the map, and after a few seconds you will see a new browser window open, and the map will appear, a few seconds more and the map will update to show the position of the user. Walk around the streets and see the map update!

Set the code to auto run

Our code is completed, but in order to automate the process we need to ensure that it runs from boot. So we need to take two steps. The first is to make the Python code executable, and to do this we need to open the terminal and ensure that we are in the same directory as our code and then enter the following command.

chmod +x micromapper.py

We can test that the command works by typing

./micromapper.py

The second part of the process is to add a line to cron so that the code will run on boot. To do this we again need the terminal and enter the command

crontab -e

If you are asked to choose an editor, pick nano, unless you already have a favourite terminal editor.

In the editor scroll to the bottom of the document and type the following (which assumes that our code is saved to /home/pi)

@reboot /home/pi/micromapper.py

Now close the editor by pressing CTRL + X, then Y and finally Enter.

Lets test the code! Reboot the Raspberry Pi 3B + and once it has rebooted we will see the Raspbian desktop, and our Treasure Hunter application will launch!

We’ve done it!

We’ve made our own Raspberry Pi 3 B + powered treasure tracker! Now all we need to do is place it in a case, plastic boxes or a 3D printed enclosure would be perfect. We used the Smarti Pi case as it held the screen perfectly. Once you have a case, go for a walk and enjoy searching for your treasures!

Tags: raspberry pi 3 b plus, raspberry pi portable project, rpiintermediate, raspberry pi treasure hunt, 3 b plus, raspberry pi 3 b+, rpi 3b+, raspberry pi, raspberry pi projects, treasure hunt, gps, microstack, raspberry_pi_projects, raspberry pi gps project

Terms and Conditions for Raspberry Pi Halloween Build Along

plowe — Wed, 06 Oct 2021 20:40:49 GMT

Current Revision posted to Documents by plowe on 10/6/2021 8:40:49 PM

This opportunity is organized and sponsored by element14 (the “Organizer”).
The application period will be open from 31-Aug 2015 – 17 SEPT, 2015 23:59 PM BST
Applications will be reviewed and winners selected by members of the element14 team. Applicants who have been chosen will receive notification via a blog post no later than 22-SEPT, 2015.
Submissions will be selected based on originality, innovation and technical merit at the sole discretion of element14.
By submitting an application for consideration, the applicant:
1. Agrees that he/she will submit a blog featuring photos and/or videos of his/her build based on the Raspberry Pi 2 kit build and the parts provided. Failure by a selected individual to participate in accordance with the parameters of the giveaway, provided no reasonable cause for this inability to participate is given, may result in exclusion from future element14 Giveaways;
2. Authorizes the Organizer to use their personal data (as defined in the Data Protection Act 1998), application and any content created in relation to this promotion for the purposes of running and promoting element14.com, this year and/or in subsequent years
3. Agrees to positively participate in all publicity surrounding their participation in this give-away.
This promotion may be terminated at any time if there are, in the sole opinion of element14, an insufficient number of entries, or if the applications are not of an appropriate standard for this promotion. The Organizer has the right to cancel this promotion if necessary due to circumstances outside its reasonable control. The Organizer reserves the right to make changes from time to time and the latest version of these Terms from time to time will be posted to the site.
General
1. The Organizer reserves the right to delegate all or any of its powers, rights and obligations arising in relation to this promotion to any Associate and certain such rights and powers are assumed by the Organizer on behalf of itself and each Associate. Reference to “Organizer” shall be deemed to include reference to each Associate.
2. The Organizer shall have the sole discretion to disqualify (without correspondence or right of appeal) any Applicant it considers to be adversely affecting the process or the operation of this promotion or to be in breach of these Terms or to be acting in a disruptive manner or with intent to annoy, abuse, threaten or harass any other Applicant or Participant.
3. The Organizer has the right to amend or add to these Terms from time to time. Revised Terms and Conditions will be posted on the Competition Site and it is a condition of entry to this promotion that Applicants and Participants agree to comply with these Terms and, if appropriate, such Terms as amended from time to time.
4. Headings are for convenience only and do not affect the interpretation or construction of these Terms and Conditions.
5. These Terms and the operation of this promotion shall be governed by and construed in accordance with English Law and any claim or matter arising under these Terms shall be subject to the exclusive jurisdiction of the English courts.

Attachments:

community.element14.com/.../RaspberryPi2_2D00_HalloweenKit_2D00_TC_2D00_150818.pdf

RaspberryPi2-HalloweenKit-TC-150818.pdf

Tags: raspberry_pi_projects

Documents

migration.user — Fri, 01 Oct 2021 18:01:00 GMT

Current Revision posted to Documents by migration.user on 10/1/2021 6:01:00 PM

Rendering 3D with Raspberry Pi and Bitscope Blade

e14phil — Mon, 10 May 2021 18:52:47 GMT

Current Revision posted to Documents by e14phil on 5/10/2021 6:52:47 PM

Building a Render Farm with a Bitscope Blade Quatro

Andy Clark Workshopshed was sent a Bitcope Blade Quatro (for free) as part of our RoadTests & Reviews.
After completing his RoadTests & Reviews he was able to keep his BitScope Blade flexible power and mounting solution for a single Raspberry Pi and HAT Quatro, with this in hand Andy has begun building a 3D Render Farm with his Bitscope Blade and Raspberry Pi. It is not the fastest rendering farm in the world but provides an amazing demonstration of cluster computing with the Raspberry Pi.

We have combined and linked the whole series below for your reading pleasure!

If you want a bit more of a grounding about the BitScope Blade flexible power and mounting solution for a single Raspberry Pi and HAT Make sure you check out his Roadtest here:

Roadtest: Bitscope Blades - Review

Or the specifications here:

BitScope Blade QUATTRO Specification

Render Farm Overview

Element14 invited me to take a look at these blades so I started by reading the above page. One of the suggestions was for a render farm for the open source 3D modelling and animation package blender. This seemed like a great way to prove out the system in a real-world scenario.

My farm will consist of 4 Pi with one acting as a controller node. That will connect to the USB external disk and have a secondary network connection (possibly wifi) so I can copy the files to be rendered and download any packages needed.

Building a Render Farm Series:

Building a Render Farm with a Bitscope Blade Quatro - Plan of action

The Bitscope Blade is from the same people who make the Bitscope Oscilloscope & Analyzer tools. It's a host board that allows you to host one to four raspberry Pi and provides power and connectivity. You can stack a series of blades into a chassis and power these from a shared supply.

Building a Render Farm with a Bitscope Blade Quatro - Hardware

I'm building a small render farm for Blender using the Bitscope Blade. I decided to mount all the components on a sheet of wood so that I could pack the whole thing away when I was not using it.

Building a Render Farm with a Bitscope Blade Quatro - Pins

Following a discussion from DAB's review of the Bitscope Blade Uno, I thought it was worth quickly mentioning the different sockets and pins you get on the bays of the blade.

Building a Render Farm with a Bitscope Blade Quatro - Setup of the nodes

In this part of the project, I'm looking at the setting up of the nodes.

Building a Render Farm with a Bitscope Blade Quatro - Setup of the controller

Setup of the controller node

Building a Render Farm with a Bitscope Blade Quatro - Running Blender

Now we can actually get on with installing and using Blender.

The final output rendering with the Raspberry Pi, Blender and Bitscope Blade Quatro.

players.brightcove.net/.../index.html

You can follow Andy's progress and content by following his blog:

Workshopshed

Tags: quatro, rpiintermediate, bitscope blade, raspberry-pi3, bitscope, raspberry pi projects, raspberry_pi_projects

Raspberry Pi Zero Retro Gaming System

spannerspencer — Mon, 10 May 2021 18:52:45 GMT

Current Revision posted to Documents by spannerspencer on 5/10/2021 6:52:45 PM

When we heard about the Raspberry Pi Zero, we decided that we needed a build-along project to help show it off a little. Naturally our first thoughts went toward that most efficient and fun of ways to waste time, so what better than a retro gaming system?!

NOTE: Do not kill yourself with an open TV.

Not convinced? Check out our Two Minute Makers trailer below. We'll wait for you.

players.brightcove.net/.../index.html

Now we've whipped you up into the prerequisite frenzy, join cstanton and me as we turn the Raspberry Pi Zero into a Mega Drive/Genesis, SNES, Amiga, Master System, NES and a host of other classic video game platforms. Without further ado:

Classic Games, Classic TV

Flat screen LCD TVs are ten-a-penny these days, but we really didn't feel like that would fit with the theme of a retro video game. So we took to the charity shop, and found ourselves a classic CRT!

The stumbling block here is that it obviously has no HDMI input, and that's the simplest option for hooking up a display to the Pi Zero (using a mini-HDMI adapter, of course). But there's also a composite video output available on the tiny Pi, so that's where we started.

Video Drama

As we didn't want too many trailing cables or an exposed Pi Zero, everything is going inside the old telly. Initially we cracked open the case and soldered a couple of twisted-pair wires from the Pi Zero's composite RCA output to the back of the TV's video input phono socket.

But no joy.

After some tinkering, it seems the phono socket or its PCB had some issues, which turned out to be a blessing. Instead of connecting internally to the phono socket, we opted to make use of the SCART socket instead. Buried within its 21 pins, SCART has a composite video input (and output, for that matter). Pins 18 and 20, for those who want to do the same, rather than assailing the phono socket. We tested it by shoving the wires into the SCART socket, and we got a picture! Kind of...

Never Twice the Same Colour

As you can see, it wasn't quite the rainbow-tinged dream we were hoping for. We had an image, but in black and white. That's too retro, even for us.

When looking into the Pi Zero's config file it turned out that the composite RCA output defaults to NTSC (this'll be correct for some of you, of course). A quick change in the config file swaps it to a PAL signal, and we're bathed in glorious rasterised technicolour!

If you want to switch the RCA output to PAL, open the Pi Zero's config.txt file (located in /boot) and uncomment (by removing the preceding hash) the following line:

sdtv_mode=2

Just in Case

Given that the Pi Zero has just one USB, and its a micro socket, we added a modified, powered hub to the equation so it could accept joypads, keyboards and drives. We've another build coming along soon to show you how we modified a cheap USB hub into one with power for the peripherals, but also shared it with the Pi Zero, hence only needing one power supply. Bookmark this page and follow the Raspberry Pi section to be notified when the USB hub post is published.

We also took the opportunity to cut a section out of the TVs case while the back was off, and glued the USB hub in place. The power socket was fitted to the case beneath the hub, keeping things neat and the cables out of the way of the screen. A couple of slots cut into the inside of the TV's casing holds the Pi Zero nicely in place next to the hub.

Going Retro

We tried a few options for installing emulators on the Pi Zero, with RetroPie proving to be the simplest, easiest and most stable. This is likely because it has a version for the earlier models of Raspberry Pi, which the Zero is more akin to.

We're going to cover the installation of RetroPie (and maybe some other OS options) for the Pi Zero shortly, but it wasn't a chore. Download the SD card image, write it to the card and put it in the Pi Zero. Simple and classic.

So far we've tested it out with two Xbox 360 controllers (given they're USB native) and the emulator automatically detected them both without fuss. The UI is clean and readable on the old screen, and games up to 16-bit run like a velvet dream!

If you turn your Pi Zero to gaming uses, or make your own retro console like we did, remember to come on back and tell us all about it right here on element14!

And if you want more info on the Pi Zero so you can get started on your own awesome projects, here's where to begin.

Tags: emulator, retro, raspberry_pi, pi_zero, raspberrypi, retropie, retro_gaming_console, raspberry_pi_projects

Raspberry Pi Weather Station Project

jcasiello — Mon, 10 May 2021 18:52:44 GMT

Current Revision posted to Documents by jcasiello on 5/10/2021 6:52:44 PM

Using SenseHAT, InitialState Cloud Service and your Raspberry Pi, create a working Weather Station

Overview:

This kit helps to build your own local weather dashboard, capturing the weather inside and outside your house or office over time. This super-fun and easy project will leverage the Internet of Things (IoT), using the new Raspberry Pi 3 with built-in WiFi, a Sense HAT, and the Initial State cloud platform. Raspberry Pi will capture all the sensor data from SenseHAT and stream it directly to the cloud and this stream of data/information can be monitored or displayed in a professional graphical fashion which can be accessed from your smartphone or computer from anywhere in the world with just a few button clicks.

Project level: Beginner
Approximate time to complete: 20 minutes

Get the kit:

SenseHAT Weather StationSenseHAT Weather Station

(you can remove individual item(s) at the cart )

Project requires:

1. Raspberry Pi3Raspberry Pi3

2. Translucent EnclosureTranslucent Enclosure

3. 16GB MicroSD card preloaded with NOOBS16GB MicroSD card preloaded with NOOBS

4. Raspberry Pi Sense HATRaspberry Pi Sense HAT

5. Pi3 Power Supply 5V, 2Pi3 Power Supply 5V, 2A

6. 7" Pi Display7" Pi Display or HDMI monitor with HDMI cable

7. Keyboard & Mouse (for HDMI monitor)

Option 1: Follow the instruction if you have downloaded the full Raspberry Pi project images from element14 community.

Instructions:

1. Download the full Raspberry Pi image with demo code from here

2. Insert the uSD card into your computer SD card reader and write the downloaded imaged into uSD card using image writing software like “Win32DiskImager”, wait for the write to complete. Exit the imager and eject the SD card.

3. Insert the uSD card into Raspberry Pi and boot the system. Now connect your Raspberry Pi to the internet using WiFi setup utility and make sure you are connected to the internet.

4. Go to the www.InitialState.com and signup for a free account.

5. Now login to your InitialState account, click on your username in the top right, then go to “my account”. At the bottom of the page click on “Create a New Key” to generate your unique key to stream the data. Make a note of this Access Key.

6. On the Pi Desktop you will find a Python project file named “pi_weather.py” which we need to edit and update with the Initial State unique Access Key.

7. Now before we move further we need to install Initialstate ISStreamer. Open the LX terminal and execute below command:

$ cd /home/pi/

$ \curl -sSL https://get.initialstate.com/python -o - | sudo bash

While installing it ll ask your Initialstate account credential created under step 4.

8. Now we need to edit the demo file using editor of your choice, here given example using Nano editor:

sudo nano pi_weather.py

a. Replace the text “ENTER YOUR KEY” with your Access Key “XXXX”

b. Save the file with the same name by pressing Ctrl + X (to exit), y (to save the changes in the file, ENTER (to save with the same name).

9. Now run the modified Python file to start the weather station:

sudo python pi_weather.py

10. Go to the browser from your computer or mobile device and login to your initial state account and start monitoring the data.

Option 2: Please follow below instruction if you want to build this project from scratch on you existing RPi Image.

Preparations:

1. Download the Python project filehere

2. Copy the downloaded file into a USB drive

3. Go to the www.InitialState.com and signup for a free account.

4. Now login to your InitialState account, click on your username in the top right, then go to “my account”. At the bottom of the page click on “Create a New Key” to generate your unique key to stream the data. Make a note of this Access Key.

5. Connect the hardware and USB drive

Hardware & Software Setup:

1. Connect all the provided hardware and boot the Raspberry Pi 3 as a standard setup. Now connect your Raspberry Pi to the internet using WiFi setup utility and make sure you are connected to the internet.

2. Setting up SenseHAT and Initial State streamer on Raspberry Pi to stream sensor data to the cloud;

a. Installing SenseHAT. Open the LX terminal and execute below commands:

sudo apt-get update

sudo apt-get install sense-hat

b. Initial State: Open the LX terminal and execute below command:

\curl -sSL https://get.initialstate.com/python -o - | sudo bash

c. Above two steps will install SenseHAT drivers and Initialstate ISStreamer on to the Pi, it might ask for your Initialstate account credential password to proceed.

3. Now insert the USB drive and copy the downloaded Python file from the USB drive into Raspberry Pi working directly or directory of your choice.

4. Now we need to edit the Python file to enter you unique Access Key. You can use

any editor of your choice, here given example using Nano editor:

sudo nano pi_weather.py

a. replace the text “ENTER YOUR KEY” with your Access Key “XXXX”

b. Save the file with the same name by pressing Ctrl + X (to exit), y (to save the changes in the file, ENTER (to save with the same name).

5. Now run the modified Python file to start the weather station:

sudo python pi_weather.py

6. Go to the browser from your computer or mobile device and login to your initial state account and start monitoring the data.

Tags: sense hat, design_projects, rpibeginner, projects, pi weather station kit, raspberry_pi_project, raspberry pi, weather station, raspberry_pi_projects

Raspberry Pi Smart Surveillance Monitoring System

jcasiello — Mon, 10 May 2021 18:52:43 GMT

Current Revision posted to Documents by jcasiello on 5/10/2021 6:52:43 PM

Build a Raspberry Pi based smart wireless surveillance monitoring system using MotionEye.

Overview:

With this project, you can design and implement a Raspberry Pi 3 based low-cost smart surveillance monitoring system. With RPi3 on board WiFi, PiCamera and MotionEye OS you will be able to capture High Definition video and live stream video can be accessed/viewed using a web browser from anywhere by just entering the static RPi IP address. The system can automatically initiate video recording, image capturing or send notifications if any kind of motion is detected. The camera can capture wide area and motion sensitivity, brightness, contrast, angle all can be controlled by the user. If you want extra security, you can set authentication which makes the system more secure and can't be hacked.

Project level: Beginner
Approximate time to complete: 20 minutes

Get the kit:

Security Camera for Raspberry PiSecurity Camera for Raspberry Pi

(you can remove individual item(s) at the cart )

Project requires:

1. Raspberry Pi3Raspberry Pi3

2. 16GB NOOBS MICRO SD CARD16GB NOOBS MICRO SD CARD

3. Pi Camera 8MPPi Camera 8MP

4. Pi3 Power Supply 5V, 2.4APi3 Power Supply 5V, 2.4A

5. Enclouse with in-built camera slotEnclouse with in-built camera slot

Initial Hardware Setup (RPi and SenseHAT)

1. Download the latest version of MotionEyeOS for RPi3 from here.

3. Insert the uSD card into Raspberry Pi and boot the system. For initial setup we have to use Ethernet connection and once connected to the network we can setup WiFi connection.

4. Please refer to the guide how to find RPi IP address without using monitor (using the Pi headless):

https://www.raspberrypi.org/documentation/remote-access/ip-address.md

5. Now from your computer browse to the identified RPi IP address with your browser. Bingo!! you should see a live video feed from you RPi and camera over you network.

6. Now to setup your WiFi connection, motion sensing, video resolution etc click on the Key icon in the top-left corner. Login with admin as a username and leaving password field blank. From this panel you can set and control all the system functionality remotely. Once you have setup WiFi connection you can remove Ethernet cable and system will connect using WiFi on next boot automatically.

Login Screen:

WIFI Network

Camera Setup:

Motion Detection & Notification Setup:

Tags: raspberry pi security camera, pi-camera_project, raspberry pi projects, pi camera, raspberry_pi_projects

Raspberry Pi Media Center

jcasiello — Mon, 10 May 2021 18:52:42 GMT

Current Revision posted to Documents by jcasiello on 5/10/2021 6:52:42 PM

Create a Smart TV using Raspberry Pi and OSMC

Overview:

This kit will help you to build a fully functional HD-ready media center (or turn you pl;ld TV into Smart TV) for all your movies, music and TV. Turn you raspberry Pi into streaming powerhouse - thanks to OSMC, a version of Kodi (formerly XBMC) optimised for Raspberry Pi.

Project level: Beginner
Approximate time to complete: 20 minutes

Get the Kit:

Product LinkProduct Link

(you can remove individual item(s) at the cart )

Project requires:

Raspberry Pi 3Raspberry Pi 3
Translucent EnclosureTranslucent Enclosure
16GB MicroSD card preloaded with NOOBS16GB MicroSD card preloaded with NOOBS
Pi3 Power Supply 5V, 2APi3 Power Supply 5V, 2A
7" Pi Display7" Pi Display or HDMI monitor with HDMI cable

Instructions:

1. Download the full Raspberry Pi NOOBS images from HERE. Raspbmc is one of the default OS options pre-packaged with the Raspberry Pi Foundation’s NOOBS installer.

2. Insert the uSD card into RPi, connect the HDMI cable you your HDMI monitor or TV, connect keyboard & mouse and finally connect the supplied RPi power supply to power up the Raspberry Pi.

3. Now simply follow the simple RPi setup and when prompted to select a distro package to install, select Raspbmc from the list rather than Raspbian.

4. Once it’s installed and booted up, the first thing you’ll want to do is connect to your Wi-Fi network. Head over to the Programs tab using keyboard & mouse, and go into the Raspbmc Settings menu. The Network tab of this menu will allow you to edit your wireless configuration by entering your network name and password, after which you should be fully connected.

5. If your TV supports HDMI CEC, your standard TV remote will work just fine or if you have a smartphone or tablet, you can also use that to control your Pi using open source remote apps and link it to your Raspbmc by entering the MAC address and port details, which can be found in Raspbmc’s system menu.

6. With all that done, you’re ready to start streaming all your content, instantly and in HD.

Tags: media_centre, raspberry pi projects, raspberry_pi_projects, smart_tv, osmc

Raspberry Pi GPIO Explained

shabaz — Mon, 10 May 2021 18:52:36 GMT

Current Revision posted to Documents by shabaz on 5/10/2021 6:52:36 PM

Introduction

The Raspberry Pi is a computer, and from a connections point of view it doesn’t look much different to a normal desktop computer. It has USB ports for connecting a keyboard and mouse, and a video output port for connecting up a display.

Because it is more compact and lower cost than a large desktop PC, it becomes possible to use the Raspberry Pi or other small single board computers (SBCs) as they are known, for many scenarios where a desktop or laptop PC would not be feasible.

Often you may want to connect up other ‘things’ to a computer. For example you may wish to use a computer to measure the brightness level and automatically control lights, or to sound an alarm if an intruder is detected.

Broken down to more general terms, there is a desire to be able to use a computer to control (also known as to ‘output’) to electronic circuits, and to gain useful information (aka obtain ‘input’) from circuits.

This is where the Raspberry Pi and other single board computers excel because one key difference between SBCs and desktop or laptop PCs is that SBCs usually have general purpose input/output (GPIO) capability. This is lacking on larger PCs.

By making connections to those pins (they are also known as header pins) the Raspberry Pi can interface to the electronic world which consists (amongst other things) of sensors and indicators and actuators.

This blog post will provide example circuits that can be used as-is (or can be modified and extended) along with code examples in several programming languages. The information is split up into:

Connections Overview
Understanding Inputs (Use the tabs to work through this section)
Understanding Outputs (Use the tabs to work through this section)
Some Optional (advanced) topics (namely Speed and Jitter; again, use the tabs to work through this section)

To prevent too much scrolling, some of the sections are tabbed at the top, so click on the tabs to see more content. Also, click on the photos to zoom in to see wiring detail.

There is also a short video that contains some extra detail as well as demonstrations of the circuits and code. The video will be available in about a weeks time (bookmark this post if you wish to be notified).

Connections Overview

The diagram below lists the header pins available on the Raspberry Pi. Pin 1 on circuit boards can typically be identified by looking for the square-shaped pad on the underside of the board. The Raspberry Pi has digital inputs/outputs on its 40-pin connector that comply with 3.3V logic levels. The photo here shows an older Pi 2, but the same connection detail applies for the more recent Pi 3. Notice from the diagram that the pin numbering is in a zig-zag pattern, where pin 1 is lower right, pin 2 is lower left, and then the numbers increase the higher up you go in the zig-zag fashion. Another way of looking at it is to notice that the odd numbered pins are on the right side, and the even numbered pins are on the left side.

The term '3.3V logic levels' means that the Raspberry Pi will interpret anything very close to zero volts (it doesn't have to be precisely 0V) as a logic ‘0’ and anything higher than around 2V as a logic ‘1’. Inputs beyond 3.3V will damage the board. Similarly, when GPIO pins are configured to become outputs, the Raspberry Pi will set the pin to either a voltage close to 0V or a voltage close to 3.3V. Everything in electronics has a tolerance, so (say) measuring 3.21V (as an example) instead of precisely 3.30V is considered acceptable.

For this blog post's input/output exercises, the pink, white, red and orange pins on the diagram will be used. The remainder pins are for serial interfacing use which is addressed in other blog posts.

If you are not using the two 5V pins (bottom-left side, pin numbers 2 and 4) then you could prevent accidental shorts to surrounding pins by placing some plastic sleeving/insulation over them.

Understanding Raspberry Pi Outputs

Work through the three tabs below to get a full understanding of the output functions of your Raspberry Pi.

{tabbedtable} Tab Label	Tab Content
1) Digital Outputs: LEDs	Getting Started with Digital Outputs: Lighting LEDs A typical use for output pins is to control an indicator such as an LED or light bulb, or some actuator or motor. Usually an electronic circuit is needed to transform the Raspberry Pi output into something that will control the desired device. For a small LED all that is needed is a series resistor; its purpose is to reduce the current that will flow through the LED in order to protect both the LED and the Raspberry Pi. Not a lot of current can be supplied by the output pins, and LEDs will be damaged by too high current. Furthermore LEDs are non-linear and will not light at all if too low a voltage is applied across them. Small LEDs (particularly red, yellow and green ones) will work fine with the Raspberry Pi outputs provided a resistor is attached in series. The exact resistance doesn’t matter; anything between 100 ohms and 1kohm should allow for sufficient output brightness when the output is set to logic ‘1’. As a quick exercise the photo here (click on it to zoom in) shows the Raspberry Pi connected up to an LED using jumper wiresjumper wires. To prevent accidental shorts and for convenience the Raspberry Pi was bolted onto a piece of wood (2mm or 2.5mm diameter bolts; 3mm will not fit) and a bread board glued next to it. A bread board, a single resistor and an LED were connected up to the Raspberry Pi. The GND (also known as 0V) connection was taken from pin 6 on the Raspberry Pi header, and the GPIO pin used was GPIO22 (see the diagram earlier) which is pin 15. Any GPIO pin could be used; they are marked in pink on the earlier diagram. Another way of representing this is shown in the schematic below. Once you’ve connected up the LED, a program or script can be written to control it. The choice of language is up to you. One (popular) example is Python; here is some code that will light up the LED. # Connect LED to GPIO22 (pin 15) import time import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(22, GPIO.OUT) GPIO.output(22, True) time.sleep(3) GPIO.cleanup() Save the code to a file called led-test.py and then to run it, type sudo python led-test.py Here is another example in Python. It flashes the LED 10 times (Note: if you're new to Python, unlike other programming languages the line indentations in the code are important): # connect LED to GPIO22 (pin 15) import time import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) for x in range(0,10): GPIO.setup(22, GPIO.OUT) GPIO.output(22, True) time.sleep(0.05) GPIO.output(22, False) time.sleep(0.45) GPIO.cleanup() Another way to control the output pins is to use a shell script. This appears slightly more complex (unless you enjoy writing shell scripts) but is a good thing just for reference because often other programming languages allow you to run shell scripts, and therefore if needed this can be a quick approach to using GPIO with other languages. Furthermore the method described here is standard across different platforms so your code can be ported to boards other than the Raspberry Pi too. If you're a beginner to programming, stick with Python for now and move on to the next example; shell scripts can be revisited at a much later stage. #!/bin/sh GPIO_PATH=/sys/class/gpio LED_PIN=22 #GPIO 22 is pin 15 echo "$LED_PIN" > $GPIO_PATH/export echo "out" > $GPIO_PATH/gpio$LED_PIN/direction echo "1" > $GPIO_PATH/gpio$LED_PIN/value sleep 1 echo "$LED_PIN" > $GPIO_PATH/unexport The first line of the shell script looks like a comment line, but is needed to make it easy for the Linux shell to know what to do with the script upon execution, so don’t modify that. The remainder script lines are used to take control of a GPIO pin, set it to become an output, set it to a logic high value, and then wait for 1 second. Finally control of the GPIO pin is released so other programs can make use of it if desired. Another programming language that may be encountered is C or its (far) bigger brother C++. An example using C or C++ is given further below in the ‘Voltmeter’ section where the code is used for input from a circuit, and output to an LED.
2) Output Example: Tone Generator	Another Output Example: Tone Generator A more interesting example than an LED is to use a couple of GPIO pins to control a tone generator circuit. The Raspberry Pi has a headphone connector for audio but sometimes just a simple tone or alarm is needed to signal events (such as for an alarm clock project). The photo below shows a very simple single integrated circuit (IC) project that can generate various sounds. By adjusting resistor and capacitor values, different tones and sounds could be created. The circuit connects to two outputs from the Raspberry Pi. One output is used to switch the tone on or off, and the other is used to alternate between two tones. One of the capacitors in the circuit is used to create a sweeping tone transition when tones are alternated. The circuit diagram is shown below; it uses an ICM7555 timer integrated circuitICM7555 timer integrated circuit. GPIO22 was used to switch the tone on and off, and GPIO27 modifies the tone. C1, R1 and R2 can be adjusted to select the desired tones. The Python code below plays some alarm tone effects. To use the code, save the code to a file called tone-test.py and then type sudo python tone-test.py import time import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(22, GPIO.OUT) # TONE_ENABLE GPIO.setup(27, GPIO.OUT) # TONE_CHANGE GPIO.output(22, True) for x in range(0,5): GPIO.output(27, True) time.sleep(0.1) GPIO.output(27, False) time.sleep(0.2) GPIO.output(22, False) time.sleep(0.5) for x in range(0,5): GPIO.output(22, True) time.sleep(0.1) GPIO.output(22, False) time.sleep(0.2) GPIO.output(27, True) time.sleep(0.2) for x in range(0,5): GPIO.output(22, True) time.sleep(0.05) GPIO.output(22, False) time.sleep(0.05) for x in range(0,10): GPIO.output(22, True) time.sleep(0.1) GPIO.output(22, False) time.sleep(0.1) time.sleep(1) GPIO.cleanup() Note that the circuit uses the 3.3V supply (pin 1) available from the Raspberry Pi. Only use this supply if you know your circuit doesn’t consume much power. More than a few tens of milliamps of current consumption would require your own external power supply. Another approach would be to build a 5V to 3.3V regulator circuit and connect it to the 5V supply available on pin 2 from the Raspberry Pi.
3) Output Design Tips	Output Design Tips All the circuits described so far have involved low current and low voltage but sometimes higher power devices need to be controlled or monitored. There are some typical methods to achieve this, and they are described here. Connecting to 5V Logic When the Raspberry Pi is used to output a signal to 5V devices, usually (not always) no additional circuit is needed; many 5V logic device inputs will function just fine with the 3.3V logic output signals from the Raspberry Pi. You can confirm by checking the datasheet for the 5V device. Low Power, Low Voltage LEDs (red, yellow, green) A single LED can be controlled using a series resistor between around 100 ohms and 1kohm. No other considerations are required. Any Color Low Power LED Blue and white LEDs may require a voltage higher than 3.3V. The easiest way to control a single LED is to use a transistor circuit to switch the 5V supply rail. The value of R1 should be increased if using an LED of any color other than blue or white. In general consult the LED data sheet. Any NPN transistor should work for this circuit. Higher Power AC or DC Devices (but not mains!) A relay is useful for this scenario. Virtually any NPN transistor can be used. Popular devices include BC547BBC547B, 2N39042N3904 and BC549BC549. If the connected device can function from 5V DC then the Raspberry Pi's 5V connection on pin 2 of the 40-pin header could be connected to the relay switch as long as the required current is not too high (use 100mA as a very conservative guideline) otherwise the relay switch can be connected to an external supply (take care it doesn't accidentally short to the 5V supply or any other connection on the Raspberry Pi - keep it totally isolated). Check the relay datasheet to confirm that it is suitable for your needs. A small relay with pins convenient for breadboard layout is Finder 32.21.7.005.200032.21.7.005.2000 and it can switch up to 6A. Note that just because a relay is rated for (say) 250V does not mean it can be used for this. Breadboards and stripboards are designed for far lower voltages. Even with a custom PCB the project should not be used at mains voltages because there are legal requirements for conductor spacing, temperature, types of enclosure material, connection type, conductor clamping method and so on. It is easy to create a product that will fail and cause personal injury or an electrical fire or harm others at some point in time. Mains Powered Devices Treat any circuit or product that directly controls mains devices from a Raspberry Pi with extreme suspicion. Most do not meet safety standards (even though some firms self-certify that they do meet safety standards when clearly their products do not). Instead, a reasonably safe method is to find a reputable remote control product from a reputable manufacturer and a reputable supplier that uses infra-red or wireless (radio) technology to control the mains device. In the UK, the Energenie RF controlled mains socketsEnergenie RF controlled mains sockets appear suitable and they provide a small radio transmitter board that directly plugs onto the Raspberry Pi 40-pin connector and they also supply example Python code for it. For an examination of the hardware and software click to see Energenie Experiments - Remote Power Control for the Home. Some products for non-UK regions are mentioned at that link too. Multiple Relays, LEDs or Devices that require less than 200mA Current at 12V The ancient (>25 years in production!) yet useful ULN2803AULN2803A integrated circuit can be employed for this scenario. Several hundred milliamps can be supplied by each output pin (there are 8 of them). Driving small DC Motors (the most common motors, also known as ‘Brushed DC’ Motors) and Stepper Motors For small motors consider the Gertbot motor control boardGertbot motor control board. It can drive several brushed DC motors if needed, and can also be used for stepper motors. Driving Brushed DC Motors (Medium to High Power) in either Direction Use the Infineon Motor Control board Infineon Motor Control board. It can control one motor in both directions, or two motors in one direction. If more motors are needed, add more of the boards.

{tabbedtable} Tab Label

Tab Content

1) Digital Outputs: LEDs

Getting Started with Digital Outputs: Lighting LEDs

A typical use for output pins is to control an indicator such as an LED or light bulb, or some actuator or motor. Usually an electronic circuit is needed to transform the Raspberry Pi output into something that will control the desired device. For a small LED all that is needed is a series resistor; its purpose is to reduce the current that will flow through the LED in order to protect both the LED and the Raspberry Pi. Not a lot of current can be supplied by the output pins, and LEDs will be damaged by too high current. Furthermore LEDs are non-linear and will not light at all if too low a voltage is applied across them. Small LEDs (particularly red, yellow and green ones) will work fine with the Raspberry Pi outputs provided a resistor is attached in series. The exact resistance doesn’t matter; anything between 100 ohms and 1kohm should allow for sufficient output brightness when the output is set to logic ‘1’.

As a quick exercise the photo here (click on it to zoom in) shows the Raspberry Pi connected up to an LED using jumper wiresjumper wires. To prevent accidental shorts and for convenience the Raspberry Pi was bolted onto a piece of wood (2mm or 2.5mm diameter bolts; 3mm will not fit) and a bread board glued next to it.

A bread board, a single resistor and an LED were connected up to the Raspberry Pi. The GND (also known as 0V) connection was taken from pin 6 on the Raspberry Pi header, and the GPIO pin used was GPIO22 (see the diagram earlier) which is pin 15. Any GPIO pin could be used; they are marked in pink on the earlier diagram. Another way of representing this is shown in the schematic below.

Once you’ve connected up the LED, a program or script can be written to control it. The choice of language is up to you. One (popular) example is Python; here is some code that will light up the LED.

# Connect LED to GPIO22 (pin 15)
import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(22, GPIO.OUT)
GPIO.output(22, True)
time.sleep(3)
GPIO.cleanup()

Save the code to a file called led-test.py and then to run it, type

sudo python led-test.py

Here is another example in Python. It flashes the LED 10 times (Note: if you're new to Python, unlike other programming languages the line indentations in the code are important):

# connect LED to GPIO22 (pin 15)
import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
for x in range(0,10):
  GPIO.setup(22, GPIO.OUT)
  GPIO.output(22, True)
  time.sleep(0.05)
  GPIO.output(22, False)
  time.sleep(0.45)

GPIO.cleanup()

Another way to control the output pins is to use a shell script. This appears slightly more complex (unless you enjoy writing shell scripts) but is a good thing just for reference because often other programming languages allow you to run shell scripts, and therefore if needed this can be a quick approach to using GPIO with other languages. Furthermore the method described here is standard across different platforms so your code can be ported to boards other than the Raspberry Pi too. If you're a beginner to programming, stick with Python for now and move on to the next example; shell scripts can be revisited at a much later stage.

#!/bin/sh
GPIO_PATH=/sys/class/gpio
LED_PIN=22 #GPIO 22 is pin 15
echo "$LED_PIN" > $GPIO_PATH/export
echo "out" > $GPIO_PATH/gpio$LED_PIN/direction
echo "1" > $GPIO_PATH/gpio$LED_PIN/value
sleep 1
echo "$LED_PIN" > $GPIO_PATH/unexport

The first line of the shell script looks like a comment line, but is needed to make it easy for the Linux shell to know what to do with the script upon execution, so don’t modify that. The remainder script lines are used to take control of a GPIO pin, set it to become an output, set it to a logic high value, and then wait for 1 second. Finally control of the GPIO pin is released so other programs can make use of it if desired.

Another programming language that may be encountered is C or its (far) bigger brother C++. An example using C or C++ is given further below in the ‘Voltmeter’ section where the code is used for input from a circuit, and output to an LED.

2) Output Example: Tone Generator

Another Output Example: Tone Generator

A more interesting example than an LED is to use a couple of GPIO pins to control a tone generator circuit. The Raspberry Pi has a headphone connector for audio but sometimes just a simple tone or alarm is needed to signal events (such as for an alarm clock project).

The photo below shows a very simple single integrated circuit (IC) project that can generate various sounds. By adjusting resistor and capacitor values, different tones and sounds could be created.

The circuit connects to two outputs from the Raspberry Pi. One output is used to switch the tone on or off, and the other is used to alternate between two tones. One of the capacitors in the circuit is used to create a sweeping tone transition when tones are alternated. The circuit diagram is shown below; it uses an ICM7555 timer integrated circuitICM7555 timer integrated circuit. GPIO22 was used to switch the tone on and off, and GPIO27 modifies the tone. C1, R1 and R2 can be adjusted to select the desired tones.

The Python code below plays some alarm tone effects. To use the code, save the code to a file called tone-test.py and then type

sudo python tone-test.py

import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(22, GPIO.OUT)  # TONE_ENABLE
GPIO.setup(27, GPIO.OUT)  # TONE_CHANGE


GPIO.output(22, True)
for x in range(0,5):
  GPIO.output(27, True)
  time.sleep(0.1)
  GPIO.output(27, False)
  time.sleep(0.2)
GPIO.output(22, False)
time.sleep(0.5)


for x in range(0,5):
  GPIO.output(22, True)
  time.sleep(0.1)
  GPIO.output(22, False)
  time.sleep(0.2)
GPIO.output(27, True)
time.sleep(0.2)


for x in range(0,5):
  GPIO.output(22, True)
  time.sleep(0.05)
  GPIO.output(22, False)
  time.sleep(0.05)


for x in range(0,10):
  GPIO.output(22, True)
  time.sleep(0.1)
  GPIO.output(22, False)
  time.sleep(0.1)
time.sleep(1)


GPIO.cleanup()

Note that the circuit uses the 3.3V supply (pin 1) available from the Raspberry Pi. Only use this supply if you know your circuit doesn’t consume much power. More than a few tens of milliamps of current consumption would require your own external power supply. Another approach would be to build a 5V to 3.3V regulator circuit and connect it to the 5V supply available on pin 2 from the Raspberry Pi.

3) Output Design Tips

Output Design Tips

All the circuits described so far have involved low current and low voltage but sometimes higher power devices need to be controlled or monitored. There are some typical methods to achieve this, and they are described here.

Connecting to 5V Logic

When the Raspberry Pi is used to output a signal to 5V devices, usually (not always) no additional circuit is needed; many 5V logic device inputs will function just fine with the 3.3V logic output signals from the Raspberry Pi. You can confirm by checking the datasheet for the 5V device.

Low Power, Low Voltage LEDs (red, yellow, green)

A single LED can be controlled using a series resistor between around 100 ohms and 1kohm. No other considerations are required.

Any Color Low Power LED

Blue and white LEDs may require a voltage higher than 3.3V. The easiest way to control a single LED is to use a transistor circuit to switch the 5V supply rail. The value of R1 should be increased if using an LED of any color other than blue or white. In general consult the LED data sheet. Any NPN transistor should work for this circuit.

Higher Power AC or DC Devices (but not mains!)

A relay is useful for this scenario. Virtually any NPN transistor can be used. Popular devices include BC547BBC547B, 2N39042N3904 and BC549BC549. If the connected device can function from 5V DC then the Raspberry Pi's 5V connection on pin 2 of the 40-pin header could be connected to the relay switch as long as the required current is not too high (use 100mA as a very conservative guideline) otherwise the relay switch can be connected to an external supply (take care it doesn't accidentally short to the 5V supply or any other connection on the Raspberry Pi - keep it totally isolated). Check the relay datasheet to confirm that it is suitable for your needs.

A small relay with pins convenient for breadboard layout is Finder 32.21.7.005.200032.21.7.005.2000 and it can switch up to 6A. Note that just because a relay is rated for (say) 250V does not mean it can be used for this. Breadboards and stripboards are designed for far lower voltages. Even with a custom PCB the project should not be used at mains voltages because there are legal requirements for conductor spacing, temperature, types of enclosure material, connection type, conductor clamping method and so on. It is easy to create a product that will fail and cause personal injury or an electrical fire or harm others at some point in time.

Mains Powered Devices

Treat any circuit or product that directly controls mains devices from a Raspberry Pi with extreme suspicion. Most do not meet safety standards (even though some firms self-certify that they do meet safety standards when clearly their products do not). Instead, a reasonably safe method is to find a reputable remote control product from a reputable manufacturer and a reputable supplier that uses infra-red or wireless (radio) technology to control the mains device. In the UK, the Energenie RF controlled mains socketsEnergenie RF controlled mains sockets appear suitable and they provide a small radio transmitter board that directly plugs onto the Raspberry Pi 40-pin connector and they also supply example Python code for it. For an examination of the hardware and software click to see Energenie Experiments - Remote Power Control for the Home.

Some products for non-UK regions are mentioned at that link too.

Multiple Relays, LEDs or Devices that require less than 200mA Current at 12V

The ancient (>25 years in production!) yet useful ULN2803AULN2803A integrated circuit can be employed for this scenario. Several hundred milliamps can be supplied by each output pin (there are 8 of them).

Driving small DC Motors (the most common motors, also known as ‘Brushed DC’ Motors) and Stepper Motors

For small motors consider the Gertbot motor control boardGertbot motor control board. It can drive several brushed DC motors if needed, and can also be used for stepper motors.

Driving Brushed DC Motors (Medium to High Power) in either Direction

Use the Infineon Motor Control board Infineon Motor Control board. It can control one motor in both directions, or two motors in one direction. If more motors are needed, add more of the boards.

Understanding Raspberry Pi Inputs

Work through the three tabs below to get a full understanding of the input functions of your Raspberry Pi.

{tabbedtable} Tab Label	Tab Content
1) Push Button Switch Input	Push Button Switch Input The connections on the Raspberry Pi can be converted into inputs under software control. The example here is about the simplest; a push button switch is wired up to the 40-pin connector: The circuit diagram is shown below. Note that the LED circuit from the exercises before is still left wired up but is not shown in the diagram below. As can be seen from the circuit diagram, when the switch is not pressed the input pin is connected to +3.3V through a resistor. The input pin has a high resistance inside the Raspberry Pi, and so the voltage at the input pin is close to the 3.3V that the resistor is connected to. This means that the Raspberry Pi will detect a logic ‘1’ condition when the switch is not pressed. When the switch is pressed, there is a direct path between the input pin and 0V and so the voltage at the input pin becomes 0V which is a logic ‘0’ condition. For this simple switch circuit, the value of resistor R1 is not critical and can be any resistance from around 1k to 47k, but avoid low values since that increases current consumption when the switch is pressed. Here is some example Python code that can detect the push button switch status. To use the code, save the code in a file called button-test.py and then to run it type: sudo python button-test.py # Connections: # GPIO5 (pin 29) is button input # GPIO22 (pin 15) is LED import time import curses import sys import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(5, GPIO.IN) GPIO.setup(22, GPIO.OUT) tc=curses.initscr() tc.nodelay(1) old_button_status=GPIO.input(5) count=0 tc.addstr(1, 0, "Press SPACE to quit:\n") tc.addstr(2, 0, str(count)) while 1: button_status=GPIO.input(5) kbval=tc.getch() GPIO.output(22, button_status) if old_button_status != button_status: if button_status == True: tc.addstr(2, 10, "-") # pin is high, button unpressed count=count+1 else: tc.addstr(2, 10, "_") # pin is low, button pressed old_button_status=button_status tc.addstr(2, 0, str(count)) if kbval==0x20: break time.sleep(1) GPIO.cleanup() curses.endwin() print "Goodbye" The code displays the button status on the screen, along with a count of how many times the button was pressed. You’ll notice that occasionally the count increases more than the number of times the button was thought to be pressed and this happens because of ‘contact bounce’; as the switch is pressed, the contacts connect together and release many times rapidly before finally making contact. A similar thing happens when the switch is released. The solution is to have ‘debouncing’ functionality. It can be implemented in hardware or in software (the software method is very common). The code below implements debouncing and will more accurately register the correct number of button presses. The only difference with the earlier code is that this time the input status is checked a second time delayed by about 20msec – this provides time for contact bounce to have completed. # Connections: # GPIO5 (pin 29) is button input # GPIO22 (pin 15) is LED import time import curses import sys import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(5, GPIO.IN) GPIO.setup(22, GPIO.OUT) tc=curses.initscr() tc.nodelay(1) old_button_status=GPIO.input(5) count=0 tc.addstr(1, 0, "Press SPACE to quit:\n") tc.addstr(2, 0, str(count)) while 1: button_status=GPIO.input(5) kbval=tc.getch() GPIO.output(22, button_status) if old_button_status != button_status: time.sleep(0.02) # debounce period button_status=GPIO.input(5) # re-read the input if old_button_status != button_status: if button_status == True: tc.addstr(2, 10, "-") # pin is high, button unpressed count=count+1 else: tc.addstr(2, 10, "_") # pin is low, button pressed old_button_status=button_status tc.addstr(2, 0, str(count)) if kbval==0x20: break time.sleep(1) GPIO.cleanup() curses.endwin() print "Goodbye"
2) Input Example: Voltmeter	Another Input Example: A Voltmeter The Raspberry Pi has digital inputs and outputs but the real world has analog quantities that may need to be measured or controlled. The example here converts analog values into a digital signal that can be read using a Raspberry Pi input connection. The example is an extremely simple voltmeter; it can measure voltages between 0 and 1V with good precision. Note that this won’t replace a handheld multimeter! It doesn’t have the requisite safety protection and could damage itself or persons or property if used for anything beyond the scope of the examples described here. This is the circuit diagram: The circuit uses an AD654 integrated circuitAD654 integrated circuit which generates a square wave with frequency dependant on an input voltage. The square wave output is connected to a Raspberry Pi input (GPIO5 in this example). The square wave has a frequency of up to 10kHz and so some accurate timing is needed to determine the voltmeter input. The code here uses the C programming language and a library called wiringpi written by Gordon Henderson. First off, install the wiringpi library: mkdir development cd development git clone git://git.drogon.net/wiringPi cd wiringPi ./build Next, save the following code into a file called voltmeter.c // AD654 Voltmeter // Ver 1.0 Shabaz August 2015 // GPIO5 (pin 29) connects to AD654 // GPIO22 (pin 15) connects to LED #include <stdio.h> #include <stdlib.h> #include <time.h> #include <wiringPi.h> #define INREF 5 #define LEDREF 22 #define INVAL (digitalRead(INREF)) #define INVAL_IS_HIGH (digitalRead(INREF)==1) #define INVAL_IS_LOW (digitalRead(INREF)==0) #define LED_ON digitalWrite(LEDREF, 1) #define LED_OFF digitalWrite(LEDREF, 0) struct timespec ts_zero; void get_tzero(void) { clock_gettime(CLOCK_MONOTONIC, &ts_zero); } long get_time(void) { long nsec, sec; struct timespec tts; clock_gettime(CLOCK_MONOTONIC, &tts); sec=tts.tv_sec-ts_zero.tv_sec; nsec=tts.tv_nsec-ts_zero.tv_nsec; if (sec>0) { nsec=nsec+1E9; // we don't expect times greater than 1 sec } ts_zero=tts; return(nsec); } int main(int argc, char argv[]) { int i; long avg; double mv, v; long nsec[65]; wiringPiSetupGpio(); pinMode(INREF, INPUT); pinMode(LEDREF, OUTPUT); while(1) { LED_ON; while(INVAL_IS_LOW); get_tzero(); for (i=0; i<64; i++) { while(INVAL_IS_HIGH); nsec[i]=get_time(); while(INVAL_IS_LOW); } avg=0; for(i=1; i<65; i++) { avg=avg+nsec[i]; } avg=avg/64; v=1.0E5/((double)avg); mv=v1000; printf("Voltage is %fV\n", v); LED_OFF; sleep(1); } return(0); } The code can be compiled by typing: gcc -o voltmeter -lrt -lwiringPi voltmeter.c To run the code, type: sudo ./voltmeter The code uses an averaging method to get high precision. It rapidly measures the width of the incoming square wave 64 times, and then sums the values and divides by 64 to get the average value. Then it sleeps for a second to allow other processes to do their thing, and then repeats. The circuit also needs a few things for high precision. The 10nF timing capacitor10nF timing capacitor for the AD564 is selected to be a polypropylene part for better accuracy. The 1k timing resistor1k timing resistor can be a 1% part or alternatively a variable trimming resistor can be used. The circuit runs from the 5V supply from the Raspberry Pi 40-pin connector but this is only approximately 5V and so the circuit would benefit from a dedicated and more accurate 5V supply circuit. As a quick check, the circuit shown above had the voltmeter input subjected to a potential divider circuit consisting of two resistors. The calculated voltage (if the resistors were precisely the correct values and the supply was exactly 5V) out of the potential divider is 0.04950V. When the software was run, it reported measurements of 0.04991V in the short test. Not bad for such a simple project! Diodes D1 and D2 in the circuit above are optional but highly recommended because they will provide some protection to the integrated circuit if the input is accidentally subjected to a voltage outside the 0-1V range.
3) Input Design Tips	Input Design Tips Protected Inputs The Raspberry Pi can be protected from accidental connections to higher than expected voltages by adding an additional circuit to the inputs in use. A very good option in some situations is to use an optocoupler alternatively a low-cost method such as the circuit below will tolerate voltages as high as 60V without damaging the Raspberry Pi, and will cope with reversed connections too. The BC547BBC547B transistor in the circuit can be replaced with another type such as 2N39042N3904 or BC549BC549 if more convenient to obtain. R1 can be a (normal) 0.25W resistor for inputs up to around 50V, and will need to be a 0.5W part otherwise. The output of this circuit is inverted, and an input voltage higher than about 2V will pull the output low. Connecting to 5V Logic A direct connection of a 5V logic output to a Raspberry Pi input could cause damage. Different approaches can be taken depending on the specific need. If the 5V logic output changes slowly then you could consider using a potential divider circuit (i.e. two resistors) but it is not a great method (it doesn’t work for fast circuits). A far better method is to use a 5V tolerant buffer integrated circuit. A mid-way approach adequate for up to 100kHz switching speed is shown below, using a ZVN2110AZVN2110A N-channel MOSFET. The output is inverted. Alternative MOSFETs that are suitable include ZVNL120AZVNL120A and VN10LPVN10LP. MOSFETs are easy to damage when unsoldered in a circuit due to a very delicate gate structure (it is made of a thin layer internally that can be destroyed with high voltage). Take electrostatic precautions and another good practice is to first connect R3 into your circuit (either on a circuit board or breadboard) and then remove the MOSFET from its safe packaging and connect it into the circuit. The resistor R3 will provide some protection.

{tabbedtable} Tab Label

Tab Content

1) Push Button Switch Input

Push Button Switch Input

The connections on the Raspberry Pi can be converted into inputs under software control. The example here is about the simplest; a push button switch is wired up to the 40-pin connector:

The circuit diagram is shown below. Note that the LED circuit from the exercises before is still left wired up but is not shown in the diagram below.

As can be seen from the circuit diagram, when the switch is not pressed the input pin is connected to +3.3V through a resistor. The input pin has a high resistance inside the Raspberry Pi, and so the voltage at the input pin is close to the 3.3V that the resistor is connected to. This means that the Raspberry Pi will detect a logic ‘1’ condition when the switch is not pressed.

When the switch is pressed, there is a direct path between the input pin and 0V and so the voltage at the input pin becomes 0V which is a logic ‘0’ condition.

For this simple switch circuit, the value of resistor R1 is not critical and can be any resistance from around 1k to 47k, but avoid low values since that increases current consumption when the switch is pressed.

Here is some example Python code that can detect the push button switch status. To use the code, save the code in a file called button-test.py and then to run it type:

sudo python button-test.py

# Connections:
# GPIO5 (pin 29) is button input
# GPIO22 (pin 15) is LED


import time
import curses
import sys
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(5, GPIO.IN)
GPIO.setup(22, GPIO.OUT)
tc=curses.initscr()
tc.nodelay(1)
old_button_status=GPIO.input(5)
count=0


tc.addstr(1, 0, "Press SPACE to quit:\n")
tc.addstr(2, 0, str(count))


while 1:
  button_status=GPIO.input(5)
  kbval=tc.getch()
  GPIO.output(22, button_status)
  if old_button_status != button_status:
    if button_status == True:
      tc.addstr(2, 10, "-") # pin is high, button unpressed
      count=count+1
    else:
      tc.addstr(2, 10, "_") # pin is low, button pressed
    old_button_status=button_status
    tc.addstr(2, 0, str(count))
  if kbval==0x20:
    break


time.sleep(1)
GPIO.cleanup()
curses.endwin()
print "Goodbye"

The code displays the button status on the screen, along with a count of how many times the button was pressed. You’ll notice that occasionally the count increases more than the number of times the button was thought to be pressed and this happens because of ‘contact bounce’; as the switch is pressed, the contacts connect together and release many times rapidly before finally making contact. A similar thing happens when the switch is released. The solution is to have ‘debouncing’ functionality. It can be implemented in hardware or in software (the software method is very common). The code below implements debouncing and will more accurately register the correct number of button presses. The only difference with the earlier code is that this time the input status is checked a second time delayed by about 20msec – this provides time for contact bounce to have completed.

# Connections:
# GPIO5 (pin 29) is button input
# GPIO22 (pin 15) is LED


import time
import curses
import sys
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(5, GPIO.IN)
GPIO.setup(22, GPIO.OUT)
tc=curses.initscr()
tc.nodelay(1)
old_button_status=GPIO.input(5)
count=0


tc.addstr(1, 0, "Press SPACE to quit:\n")
tc.addstr(2, 0, str(count))


while 1:
  button_status=GPIO.input(5)
  kbval=tc.getch()
  GPIO.output(22, button_status)
  if old_button_status != button_status:
    time.sleep(0.02) # debounce period
    button_status=GPIO.input(5) # re-read the input
    if old_button_status != button_status:


      if button_status == True:
        tc.addstr(2, 10, "-") # pin is high, button unpressed
        count=count+1
      else:
        tc.addstr(2, 10, "_") # pin is low, button pressed
      old_button_status=button_status
      tc.addstr(2, 0, str(count))


  if kbval==0x20:
    break


time.sleep(1)
GPIO.cleanup()
curses.endwin()
print "Goodbye"

2) Input Example: Voltmeter

Another Input Example: A Voltmeter

The Raspberry Pi has digital inputs and outputs but the real world has analog quantities that may need to be measured or controlled. The example here converts analog values into a digital signal that can be read using a Raspberry Pi input connection.

The example is an extremely simple voltmeter; it can measure voltages between 0 and 1V with good precision. Note that this won’t replace a handheld multimeter! It doesn’t have the requisite safety protection and could damage itself or persons or property if used for anything beyond the scope of the examples described here.

This is the circuit diagram:

The circuit uses an AD654 integrated circuitAD654 integrated circuit which generates a square wave with frequency dependant on an input voltage. The square wave output is connected to a Raspberry Pi input (GPIO5 in this example). The square wave has a frequency of up to 10kHz and so some accurate timing is needed to determine the voltmeter input. The code here uses the C programming language and a library called wiringpi written by Gordon Henderson. First off, install the wiringpi library:

mkdir development
cd development
git clone git://git.drogon.net/wiringPi
cd wiringPi
./build

Next, save the following code into a file called voltmeter.c

// AD654 Voltmeter
// Ver 1.0 Shabaz August 2015
// GPIO5 (pin 29) connects to AD654
// GPIO22 (pin 15) connects to LED


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <wiringPi.h>

#define INREF 5
#define LEDREF 22
#define INVAL (digitalRead(INREF))
#define INVAL_IS_HIGH (digitalRead(INREF)==1)
#define INVAL_IS_LOW (digitalRead(INREF)==0)
#define LED_ON digitalWrite(LEDREF, 1)
#define LED_OFF digitalWrite(LEDREF, 0)


struct timespec ts_zero;


void
get_tzero(void)
{
  clock_gettime(CLOCK_MONOTONIC, &ts_zero);
}


long
get_time(void)
{
  long nsec, sec;
  struct timespec tts;
  clock_gettime(CLOCK_MONOTONIC, &tts);
  sec=tts.tv_sec-ts_zero.tv_sec;
  nsec=tts.tv_nsec-ts_zero.tv_nsec;
  if (sec>0)
  {
    nsec=nsec+1E9; // we don't expect times greater than 1 sec
  }
  ts_zero=tts;
  return(nsec);
}


int
main(int argc, char *argv[])
{
  int i;
  long avg;
  double mv, v;
  long nsec[65];
  wiringPiSetupGpio();
  pinMode(INREF, INPUT);
  pinMode(LEDREF, OUTPUT);


  while(1)
  {
    LED_ON;
    while(INVAL_IS_LOW);
    get_tzero();
    for (i=0; i<64; i++)
    {
      while(INVAL_IS_HIGH);
      nsec[i]=get_time();
      while(INVAL_IS_LOW);
    }
    avg=0;
    for(i=1; i<65; i++)
    {
      avg=avg+nsec[i];
    }
    avg=avg/64;
    v=1.0E5/((double)avg);
    mv=v*1000;
    printf("Voltage is %fV\n", v);
    LED_OFF;
    sleep(1);
  }


  return(0);
}

The code can be compiled by typing:

gcc -o voltmeter -lrt -lwiringPi voltmeter.c

To run the code, type:

sudo ./voltmeter

The code uses an averaging method to get high precision. It rapidly measures the width of the incoming square wave 64 times, and then sums the values and divides by 64 to get the average value. Then it sleeps for a second to allow other processes to do their thing, and then repeats.

The circuit also needs a few things for high precision. The 10nF timing capacitor10nF timing capacitor for the AD564 is selected to be a polypropylene part for better accuracy. The 1k timing resistor1k timing resistor can be a 1% part or alternatively a variable trimming resistor can be used. The circuit runs from the 5V supply from the Raspberry Pi 40-pin connector but this is only approximately 5V and so the circuit would benefit from a dedicated and more accurate 5V supply circuit.

As a quick check, the circuit shown above had the voltmeter input subjected to a potential divider circuit consisting of two resistors. The calculated voltage (if the resistors were precisely the correct values and the supply was exactly 5V) out of the potential divider is 0.04950V. When the software was run, it reported measurements of 0.04991V in the short test. Not bad for such a simple project!

Diodes D1 and D2 in the circuit above are optional but highly recommended because they will provide some protection to the integrated circuit if the input is accidentally subjected to a voltage outside the 0-1V range.

3) Input Design Tips

Input Design Tips

Protected Inputs

The Raspberry Pi can be protected from accidental connections to higher than expected voltages by adding an additional circuit to the inputs in use. A very good option in some situations is to use an optocoupler alternatively a low-cost method such as the circuit below will tolerate voltages as high as 60V without damaging the Raspberry Pi, and will cope with reversed connections too. The BC547BBC547B transistor in the circuit can be replaced with another type such as 2N39042N3904 or BC549BC549 if more convenient to obtain. R1 can be a (normal) 0.25W resistor for inputs up to around 50V, and will need to be a 0.5W part otherwise.

The output of this circuit is inverted, and an input voltage higher than about 2V will pull the output low.

Connecting to 5V Logic

A direct connection of a 5V logic output to a Raspberry Pi input could cause damage. Different approaches can be taken depending on the specific need.

If the 5V logic output changes slowly then you could consider using a potential divider circuit (i.e. two resistors) but it is not a great method (it doesn’t work for fast circuits). A far better method is to use a 5V tolerant buffer integrated circuit. A mid-way approach adequate for up to 100kHz switching speed is shown below, using a ZVN2110AZVN2110A N-channel MOSFET. The output is inverted.

Alternative MOSFETs that are suitable include ZVNL120AZVNL120A and VN10LPVN10LP.

MOSFETs are easy to damage when unsoldered in a circuit due to a very delicate gate structure (it is made of a thin layer internally that can be destroyed with high voltage). Take electrostatic precautions and another good practice is to first connect R3 into your circuit (either on a circuit board or breadboard) and then remove the MOSFET from its safe packaging and connect it into the circuit. The resistor R3 will provide some protection.

Additional Raspberry Pi Input & Output Info

Check out the three tabs below for a more advanced exercise using the input and output functions, and to see where you can go next with your Raspberry Pi.

{tabbedtable} Tab Label	Tab Content
Advanced: Speed and Jitter	Advanced Topic: Speed and Jitter Beginners: Skip to the next section! Advanced users, read on. Button-presses and LED outputs are slow events measured in tens or hundreds of milliseconds. Sometimes much higher speed signals are encountered. For example, a TV remote emits infra-red light pulses around 40k times per second. Although the core CPU in the Raspberry Pi runs at speeds approaching 1GHz, input and output signals at that rate are not supported for several reasons that are hardware, electrical and software related. We will consider some of the software factors for the scope of this blog post. The Raspberry Pi runs Linux which is a multi-tasking OS. It can (at any time) pre-emptively take control away from your software program in order to service other tasks. It all happens relatively quickly, so it looks like the mouse still works while your program is running, but really the Linux OS is providing short time-slices to your program and to the mouse driver code. Ordinarily this doesn’t matter, but when you need short or high precision events this can become an issue revealed (for example) as jitter. Furthermore choice of programming language has an effect too, because some libraries are more suitable than others. Interpreted code may run at a different speed compared to compiled code. In short if very precise timing is needed then either a Linux driver needs to be written or external hardware (such as another microcontroller, or logic circuits and clock) may be needed. One good question for more advanced use of the Raspberry Pi capabilities is approximately how fast can output signals be toggled using the Python and C libraries and the script method described earlier? To find out, code was written to repeatedly toggle an output pin and an oscilloscope was connected up. The results are shown below. However, it is always important to remember there is jitter that will be present due to the use of the Linux OS. This is not an issue for general LED toggling of course. The oscilloscope capture below shows part of the nature of the jitter by overlaying multiple traces triggered at the same time. Notice that the jitter can take on many values, although they are all discretely spaced 4nsec apart (250MHz) which is due to internal hardware inside the Raspberry Pi.
Summary	Summary If you've read this far then by now it should be clear that the 40-pin connector on the Raspberry Pi can be used for many diverse projects from driving LEDs and relays to creating voltmeters or generating alarms. With little circuitry the 3.3V logic compatible Raspberry Pi connections can interface to circuits. Using Python it is very easy to control outputs, and reading inputs is not too difficult either. For C programmers the wiringpi library makes control easy.
Next Steps	Next Steps If you have a few basic components (an LED, some resistors and a breadboard and jumper wires) you can begin exploring. Rather than just buy a single resistor or capacitor as you need it, consider purchasing a small pack of resistors, capacitors and a few transistors (bipolar and MOSFET), diodes, and a multimeter. As you dive into deeper projects you'll also be interested in learning about the serial interface connections available on the 40-pin connector. The serial interfaces are used to send and receive multiple bits of data in a standard method between the Raspberry Pi and other integrated circuits. However there are also many integrated circuits that are very easy to connect to the GPIO connections and several were covered in this blog post. Consider obtaining a few ICM7555 devices - there are a lot of fun and interesting experiments possible with them.

{tabbedtable} Tab Label

Tab Content

Advanced: Speed and Jitter

Advanced Topic: Speed and Jitter

Beginners: Skip to the next section! Advanced users, read on.

Button-presses and LED outputs are slow events measured in tens or hundreds of milliseconds. Sometimes much higher speed signals are encountered. For example, a TV remote emits infra-red light pulses around 40k times per second. Although the core CPU in the Raspberry Pi runs at speeds approaching 1GHz, input and output signals at that rate are not supported for several reasons that are hardware, electrical and software related. We will consider some of the software factors for the scope of this blog post.

The Raspberry Pi runs Linux which is a multi-tasking OS. It can (at any time) pre-emptively take control away from your software program in order to service other tasks. It all happens relatively quickly, so it looks like the mouse still works while your program is running, but really the Linux OS is providing short time-slices to your program and to the mouse driver code.

Ordinarily this doesn’t matter, but when you need short or high precision events this can become an issue revealed (for example) as jitter.

Furthermore choice of programming language has an effect too, because some libraries are more suitable than others. Interpreted code may run at a different speed compared to compiled code. In short if very precise timing is needed then either a Linux driver needs to be written or external hardware (such as another microcontroller, or logic circuits and clock) may be needed.

One good question for more advanced use of the Raspberry Pi capabilities is approximately how fast can output signals be toggled using the Python and C libraries and the script method described earlier?

To find out, code was written to repeatedly toggle an output pin and an oscilloscope was connected up. The results are shown below.

However, it is always important to remember there is jitter that will be present due to the use of the Linux OS. This is not an issue for general LED toggling of course. The oscilloscope capture below shows part of the nature of the jitter by overlaying multiple traces triggered at the same time. Notice that the jitter can take on many values, although they are all discretely spaced 4nsec apart (250MHz) which is due to internal hardware inside the Raspberry Pi.

Summary

If you've read this far then by now it should be clear that the 40-pin connector on the Raspberry Pi can be used for many diverse projects from driving LEDs and relays to creating voltmeters or generating alarms. With little circuitry the 3.3V logic compatible Raspberry Pi connections can interface to circuits. Using Python it is very easy to control outputs, and reading inputs is not too difficult either. For C programmers the wiringpi library makes control easy.

Next Steps

If you have a few basic components (an LED, some resistors and a breadboard and jumper wires) you can begin exploring.

Rather than just buy a single resistor or capacitor as you need it, consider purchasing a small pack of resistors, capacitors and a few transistors (bipolar and MOSFET), diodes, and a multimeter.

As you dive into deeper projects you'll also be interested in learning about the serial interface connections available on the 40-pin connector. The serial interfaces are used to send and receive multiple bits of data in a standard method between the Raspberry Pi and other integrated circuits. However there are also many integrated circuits that are very easy to connect to the GPIO connections and several were covered in this blog post. Consider obtaining a few ICM7555 devices - there are a lot of fun and interesting experiments possible with them.

Tags: gpio, rpibeginner, raspberry_pi, raspberry_pi_2, raspberry_pi_projects, guide, rpi_2

PIK3A: The Raspberry Pi 3 IKEA Retro Gaming Table

spannerspencer — Mon, 10 May 2021 18:52:32 GMT

Revision 1 posted to Documents by spannerspencer on 5/10/2021 6:52:32 PM

NEW! Raspberry Pi 3 Model B
Frequently Asked Questions	Comparison Chart	Technical Specifications
Unboxing Video	40 Pin Out

Meet the PIK3A Gaming Table!

Parts, Bits and Pieces

So here's the gist of this simple, but super-stylish project.

It's an IKEA Lack coffee table with an LCD monitor cut into the top, arcade controls next to the monitor, and a Raspberry Pi 3 and accessories buried inside the table.

Let's begin with an overview of the parts you'll need:

The Cabinet: IKEA Lack coffee table.
The Brains: Raspberry Pi
The Controls: Arduino Leonardo
The Joystick: A classic, four-way ball-top joystick.
The Buttons: From CPC - From MCM
The Display: An old 17" LCD monitor (4:3 ratio is better given the square shape of the table).
The Sound: This pair of USB-powered computer speakers.
The Power: A Raspberry Pi 2.5A USB power supply, and a mains extension.
The Stuff: Cables, connectors, screws.

Table Top Gaming

Dismantle Your Monitor

And by removing the bezel around the LCD, the screen will sit flush with the top of the table, and give you that essential minimalist finish.

{gallery:autoplay=false} Removing the LCD from the Monitor Housing
Remove the stand, and any screws in the back of the monitor's housing.
It's probably all clipped together, so carefully pry the back of the housing away from the silver bezel around the screen.
You don't need to remove any of the shielding inside once the housing is apart. This is better left in place, to protect the back of the LCD. Note that you might need to relocate (and protect/insulate) the small PCB with the monitor's buttons on.
Remove any small screws that fix the bezel to the LCD's shielding.
Leaving you with an LCD panel that'll sit nice and flush to the table top.

{gallery:autoplay=false} Removing the LCD from the Monitor Housing

Remove the stand, and any screws in the back of the monitor's housing.

It's probably all clipped together, so carefully pry the back of the housing away from the silver bezel around the screen.

Remove any small screws that fix the bezel to the LCD's shielding.

Leaving you with an LCD panel that'll sit nice and flush to the table top.

Screen Mounting

Below you can see how we drew around the screen to get the sizing for the hole, and then drilled 13mm holes in each corner to give the cut-out some nice, radius corners.

{gallery:autoplay=false} Mounting the Screen in the Table
Lay the dismantled monitor on the table and draw around it. I also put the joystick and buttons roughly in place, to help locate the monitor in its ideal position.
Use the drill bit for the corners to mark where to drill. This'll give you nice, rounded corners on the cut out.
Drill the four corner holes for the cut out.
Mask off the area around the hold, to protect the surface of the table when you clamp a straight edge to it.
Clamp a straight edge to the outside of the cut out (so if you slip, the damage will be on the piece you're removing), and make lots of gentler cuts from one hole along the straight edge, stopping short of the second hole. Cut from the second hole, back along the same line to prevent the knife from slipping and damaging the radius of the second hole.
When you've cut right through the table top on all four sides, carefully pry the cut out up. It'll be stuck to the innards of the table, but will come free with a little effort. Save the cut out for later on.
Run a knife around the honeycomb and rip it out.
You've a nice, neat, monitor-shaped hole in the table!
If it's all gone well, take a moment to feel a little smug about yourself.

{gallery:autoplay=false} Mounting the Screen in the Table

Lay the dismantled monitor on the table and draw around it. I also put the joystick and buttons roughly in place, to help locate the monitor in its ideal position.

Use the drill bit for the corners to mark where to drill. This'll give you nice, rounded corners on the cut out.

Drill the four corner holes for the cut out.

Mask off the area around the hold, to protect the surface of the table when you clamp a straight edge to it.

Run a knife around the honeycomb and rip it out.

You've a nice, neat, monitor-shaped hole in the table!

If it's all gone well, take a moment to feel a little smug about yourself.

Control Mounting

{gallery:autoplay=false} Mounting the Controls
I was a bit rougher cutting the access panel in the back, as it's not as visible as the table top. So mark it up, and cut out the minimum that you need (to help maintain the table's already waning stability).
The access panel cut out.
Mark where you want your buttons and joystick (including those on the edge for coin and start), and drill 28mm holes for each one.
Remove the mounting plate from the joystick. These are the mounting holes you'll use to hold the joystick in place.
Use the mounting plate to mark the four holes just around the centre. You'll also need to countersink these holes so the screw heads sit flush.
Remove the ball top from the joystick, hold the mounting plate in place underneath and screw the joystick in place from above.
Put the round cover over the joystick and screw the ball top back in place. And you can now fix all the buttons in place, too.

{gallery:autoplay=false} Mounting the Controls

The access panel cut out.

Mark where you want your buttons and joystick (including those on the edge for coin and start), and drill 28mm holes for each one.

Remove the mounting plate from the joystick. These are the mounting holes you'll use to hold the joystick in place.

Use the mounting plate to mark the four holes just around the centre. You'll also need to countersink these holes so the screw heads sit flush.

Remove the ball top from the joystick, hold the mounting plate in place underneath and screw the joystick in place from above.

Put the round cover over the joystick and screw the ball top back in place. And you can now fix all the buttons in place, too.

Control Interface

Before that, here's what to do if you've never played with Arduino before (skip ahead if you know how to upload the sketch to your Leonardo).

- A "sketch" is a program that your Leonardo will run after it's been uploaded. You can copy and paste the code below into the Arduino IDE window, or download the attached sketch file and open it using the IDE window. It's the same code, but take your pick of how to get onto the Arduino.
- Take a read through, and you'll see how each input relates to a specific keyboard key press. You can make any desired changes here before uploading to the Leonardo.
- Click the "Tools" menu and select "Arduino Leonardo" from the "Board" option.
- Click "Tools" again, and select your Leonardo from the list in the "Ports" option. It's now ready for uploading your sketch.
- Click the "Upload" button (a circular button with a right-facing arrow in it) to upload the sketch, and the Leonardo is ready to rock.

Sketch Code:

//element14 PIK3A Gaming Table Controls, using an Arduino Leonardo//

void setup() {
  Keyboard.begin();


  //Joystick and buttons pin allocations
  pinMode(0, INPUT_PULLUP); //Joystick Up
  pinMode(1, INPUT_PULLUP); //Joystick Down
  pinMode(2, INPUT_PULLUP); //Joystick Left
  pinMode(3, INPUT_PULLUP); //Joystick Right
  pinMode(4, INPUT_PULLUP); //Button 1
  pinMode(5, INPUT_PULLUP); //Button 2
  pinMode(6, INPUT_PULLUP); //Button 3
  pinMode(7, INPUT_PULLUP); //Button 4
  pinMode(8, INPUT_PULLUP); //Coin
  pinMode(9, INPUT_PULLUP); //Start
}


void loop() {


  // Button labels:
  int joystickUp = digitalRead(0);
  int joystickDown = digitalRead(1);
  int joystickLeft = digitalRead(2);
  int joystickRight = digitalRead(3);
  int button1 = digitalRead(4);
  int button2 = digitalRead(5);
  int button3 = digitalRead(6);
  int button4 = digitalRead(7);
  int coin = digitalRead(8);
  int start = digitalRead(9);


  // Joystick Up - Arrow Up Key
  if (joystickUp == LOW) {
    Keyboard.press(218);
  }
  else {
    Keyboard.release(218);
  }


  // Joystick Down - Arrow Down Key
  if (joystickDown == LOW) {
    Keyboard.press(217);
  }
  else {
    Keyboard.release(217);
  }


  // Joystick Left - Arrow Left Key
  if (joystickLeft == LOW) {
    Keyboard.press(216);
  }
  else {
    Keyboard.release(216);
  }


  // Joystick Right - Arrow Right Key
  if (joystickRight == LOW) {
    Keyboard.press(215);
  }
  else {
    Keyboard.release(215);
  }


  // Button 1 - Left CTRL
  if (button1 == LOW) {
    Keyboard.press(128);
  }
  else {
    Keyboard.release(128);
  }


  // Button 2 - Left ALT
  if (button2 == LOW) {
    Keyboard.press(130);
  }
  else {
    Keyboard.release(130);
  }


  // Button 3 - Left CTRL
  if (button3 == LOW) {
    Keyboard.press(32);
  }
  else {
    Keyboard.release(32);
  }


  // Button 4 - Left CTRL
  if (button4 == LOW) {
    Keyboard.press(129);
  }
  else {
    Keyboard.release(129);
  }


  // Coin - 5
  if (coin == LOW) {
    Keyboard.press(53);
  }
  else {
    Keyboard.release(53);
  }


  // Start - 1
  if (start == LOW) {
    Keyboard.press(49); delay(100);
  }
  else {
    Keyboard.release(49);
  }
  
}

Audio

These cube-shaped USB speakers from CPC were perfect for this job. Admittedly, you're about to void the warranty, but they're not expensive

{gallery:autoplay=false} Dismantling and Installing the Speakers
Unscrew the front of the speakers and remove the volume control. You'll need to pry the dial off the back and unscrew the nut holding it in place.
Desolder and reattach the various cables (one at a time, ideally) from the volume control board so you can remove the cube-shaped housings. Extend the wires for the right speaker, too.
Drill a mounting hole in the edge of the table to relocate the volume control.
Mark the mounting holes for the speakers on either side of the rear access panel.
Drill a few holes for the sound to get out, and then you can fix the speakers in place and the volume control in place. It's probably easier to do it before the joystick and buttons are in place.

{gallery:autoplay=false} Dismantling and Installing the Speakers

Unscrew the front of the speakers and remove the volume control. You'll need to pry the dial off the back and unscrew the nut holding it in place.

Desolder and reattach the various cables (one at a time, ideally) from the volume control board so you can remove the cube-shaped housings. Extend the wires for the right speaker, too.

Drill a mounting hole in the edge of the table to relocate the volume control.

Mark the mounting holes for the speakers on either side of the rear access panel.

Drill a few holes for the sound to get out, and then you can fix the speakers in place and the volume control in place. It's probably easier to do it before the joystick and buttons are in place.

Power

We've powered the speakers and Pi separately, just to spread the load out a bit, but to be honest the Pi3 could handle the speakers from its USB ports. The choice is yours, here.

The monitor, Pi3 and speakers are all connected into the mains extension, powering everything up while hiding the connections beneath the table.

{gallery:autoplay=false} Powering all the Parts
Mark a square in the back corner underneath the table and cut a hole for the power connector. The mains extension is going to connect to the rear of this IEC connector.
Remove the plug from the back of the mains extensions, feed the cable through the inside of the table and bring it out of the hole for the IEC connector. You can now solder the wires to the reverse of the IEC connector, and fit it in place.
It doesn't hurt to screw the mains extension to the bottom of the table, too. In my experience, they tend to fall off the eyelet holes if there's a light breeze, so this one is screwed in place from inside. You can plug the monitor and a couple of USB adapters into this, to power the screen, Raspberry Pi and speakers, while only requiring one power cable.

{gallery:autoplay=false} Powering all the Parts

Mark a square in the back corner underneath the table and cut a hole for the power connector. The mains extension is going to connect to the rear of this IEC connector.

You can plug the monitor and a couple of USB adapters into this, to power the screen, Raspberry Pi and speakers, while only requiring one power cable.

Finishing Touches

I also added a panel mount USB port next to the access panel underneath, just in case I ever need to plug a USB keyboard (or other peripheral -- it could be a joypad if you wanted) into the Pi3.

{gallery:autoplay=false} Finishing Touches
An external USB port that goes into the Pi. This is a good one, as it also has a dust cap, since this probably isn't going to get a lot of use.
If you decide to put an acrylic or polycarbonate sheet on top to protect the monitor, remember to put it in place before you insert the buttons, as they'll need to pass through the sheet. Here we've screwed it in place in each corner, and covered the screw heads with caps.
Remember how you saved the cut out from the monitor hole? Trim it down to make a cover for the access panel on the back, after notching the bottom of the table as an exit for the power cables.
The finished PIK3A table is strong enough to hold Baxter here, but given how much we've hollowed it out, be careful about how much weight you put on it. Definitely don't stand on it to change a light bulb (mind you, I wouldn't trust these enough do that with a new Ikea table).

{gallery:autoplay=false} Finishing Touches

An external USB port that goes into the Pi. This is a good one, as it also has a dust cap, since this probably isn't going to get a lot of use.

If you decide to put an acrylic or polycarbonate sheet on top to protect the monitor, remember to put it in place before you insert the buttons, as they'll need to pass through the sheet.

Here we've screwed it in place in each corner, and covered the screw heads with caps.

Remember how you saved the cut out from the monitor hole? Trim it down to make a cover for the access panel on the back, after notching the bottom of the table as an exit for the power cables.

UPDATE: The RetroPie guys have already released an updated image, so you don't have to jump through any hoops to get RetroPie working on your Raspberry Pi 3! Great work, guys!

http://blog.petrockblock.com/2016/03/02/retropie-3-6-is-released/

If you want to see them in action right away, join us as we head out and about on the Raspberry Pi 3's launch day in Leeds and Chicago!

And if you're looking to delve a little deeper into the Raspberry Pi 3, why not sign up for our RoadTest right now and review the unit for the world to see?

Attachments:

community.element14.com/.../PIK3A_5F00_Leonardo_5F00_Arcade_5F00_Controller_5F002D005F00_1_5F00_Player.zip

Tags: fruitful_three, retro gaming, pi3, gaming, raspberry pi 3, raspberry_pi_projects, pikea, video games

Getting Started with the Pi-Camera Instructions

smythec — Mon, 10 May 2021 18:52:17 GMT

Current Revision posted to Documents by smythec on 5/10/2021 6:52:17 PM

Getting Started with the Pi-Camera: Instructions

Overview
System Configuration
Bill of Materials
Set of Instructions
More Details
Using the Camera
Trouble Shooting
Appendix A - The Software
Appendix B - Python Pi-Camera API
Terminology
About this Document

top

Overview

This Project is about the use of the Pi-Camera with the Raspberry Pi (R-Pi) and enabling a user to quickly, within a couple of hours of effort, and easily obtain, and store, still images and video. This project is aimed at people who have limited experience of using the R-Pi and programming. The key learning objectives of this project are for a novice developer to:

Learn how the R-Pi and Pi-Camera can be connected and configured using the standard Raspbian drivers and applications;
Learn how to access and control the Pi-Camera from a Python program. A user will be able to take still images and video clips and to store them on the SD Card of the R-Pi.

The associated Bill of Materials describes the set of components, hardware and software, required to complete this project.

top

1. System Configuration

The system configuration is shown in Figure 1.1. The basic configuration is:

R-Pi (Model A/B) - this project can make use of either Model. In the case of Model A, it is recommended that a WiPi is used to provide network connectivity (wireless, IEEE 802.11, via the USB2 port on the R-Pi). Network connectivity makes it easier to download and install the necessary software updates required by the Pi-Camera. A USB2 hub is recommended to enable more than two USB devices to be linked to the R-Pi (the R-Pi has two USB ports). It is assumed that the keyboard and mouse are linked via the USB Hub and, if required, the WiPi. The monitor can be linked either via the HDMI interface or the yellow RCA phono connector for composite video output. In this project a PiView connector is used to enable a monitor with a VGA connector to be connected to the R-Pi via the HDMI interface;
Pi-Camera - the PiCamera is attached to the R-Pi via the CSI bus (see later for instructions on how to make the connection). The camera sensor has a native resolution of 5 megapixel, and has a fixed focus lens onboard. In terms of still images, the camera is capable of 2592 x 1944 pixel static images, and also supports 1080p30, 720p60 and 640x480p60/90 video.

Figure 1.1 System Configuration.

When the complete system is built it will look as shown in Figure 1.2.

Figure 1.2 The completed system.

top

2. Bill of Materials

2.1 System Configuration

The architecture is based upon the use of an R-Pi to drive a Pi-Camera. The configuration is shown in Figure 2.1 and the key to the alphanumeric labels is provided in Tables 2.1 and 2.2.

Figure 2.1 - System configuration for the 'Bill of Materials'

The associated bill of materials for the system shown in Figure 2.1 is listed in Table 2.1.

Table 2.1 - the Bill of Materials.

ID	Part	Comment	Qty	Order Code
1 (a)	R-Pi Model A	Either Model can be used (includes 4GB SD Card). Use a Multicomp enclosure to protect the R-Pi base.	1	Raspberry Pi (Model A)Raspberry Pi (Model A)
1 (b)	R-Pi Model B	Include a Cat 5 Ethernet cable. Use a Multicomp enclosure to protect the R-Pi base.	1	Raspberry Pi (Model B)Raspberry Pi (Model B)
1 (c)	R-Pi Enclosure	Multicomp enclosure to protect the R-Pi base.	1	MC-RP001-CLRMC-RP001-CLR
1 (d)	SD Card	Storage medium (8GB) for the R-Pi (with NOOBS pre-installed).	1	RASPBERRY-PI / PROG-8GB-USDRASPBERRY-PI / PROG-8GB-USD
2	Pi-Camera	This includes the 15-way flat-flex cable for connection to the R-Pi via the CSI bus.	1	Pi-CameraPi-Camera
3	Keyboard	Include a USB cable. Get as part of an Accessory Bundle (see 4 below).	1	RPI-CABLE+ACC/DVIRPI-CABLE+ACC/DVI
4	Mouse	Include a USB cable. Get as part of an Accessory Bundle (see 3 above).	1	RPI-CABLE+ACC/DVIRPI-CABLE+ACC/DVI
5	WiPi	Wireless access via USB. Required to provide network access if a R-Pi Model A is used.	1	WiPiWiPi
6	PiView	HDMI/VGA adapter to provide connection to a non-HDMI enabled monitor.	1	PiViewPiView
7	Monitor	A suitable colour monitor (VGA or HDMI connectivity recommended).	1	N/A
8	USB2 Hub	Includes the power supply and USB2 cables.	1	USB-H70-1A2.0USB-H70-1A2.0
9	Power Supply	R-Pi power supply with 5V/1A output. Micro USB connector.	1	RPI-PSU-UK-MK1RPI-PSU-UK-MK1
10	Power Supply	USB2 power supply (5V/1A with 2.1mm x 5.5mm Barrel Plug connector). Included with the USB2 Hub (see 8 above).	1	N/A
11	Ethernet Cable (Cat5/6 - twisted pair)	To provide network access when using a R-Pi Model B. Should be connected to the appropriate network access box e.g. broadband router. Get as part of an Accessory Bundle (see 3 above).	1	See 3/4 above.

2.2 Hardware Configuration

The hardware connectivity is detailed in Table 2.2.

Table 2.2 - Hardware connectivity.

ID	Connector	Connection	Comment
A	VGA (PiView)	Monitor/R-Pi	Part of the Monitor cable to the R-Pi.
B	HDMI (PiView)	R-Pi/Monitor	Part of the Monitor cable to the R-Pi.
C	Power Cable	R-Pi Micro USB/Mains	Power supply for the R-Pi.
D	Ethernet (Cat5/6)	R-Pi/Switch or Router	Cable-based network access. Wireless access via the WiPi is an alternative.
E	15-way Flat-Flex Cable	R-Pi/PiCamera	Camera Serial Interface (CSI) bus between the R-Pi and PiCamera. Supplied as part of the PiCamera.
F	Power Cable	USB2 Hub/Mouse + Keyboard USB2 Hub/WiPi	Power for the USB2 hub - the hub supports seven ports.
G	USB Cable	USB2 Hub/Mouse + Keyboard USB2 Hub/WiPi	USB cable connection for the Mouse and Keyboard. The WiPi will be plugged directly into the USB2 hub.
H	USB Cable	USB2 Hub/R-Pi	USB cable to connect the USB hub to the R-Pi. The R-Pi can also draw power using this cable.

2.3 Software Configuration

The software required to support this project that must be installed on the R-Pi is:

R-Pi Operating System (Raspbian) - this is installed using the NOOBS that comes pre-installed on the R-Pi SD cards. If NOOBS is not preinstalled it is available at Downloads;
Integrated Development Environment - IDLE with Python 3.x support with the 'tkinter' modules installed (normally installed as part of Raspbian);
Raspistill and Raspivid applications - these are still image and video capture operating system applications (normally installed as part of Raspbian);
Omxplayer - an application to enable the H.264 encoded video to be played back on the monitor from the R-Pi (normally installed as part of Raspbian);
Pure Python interface to the R-Pi PiCamera (Python 2.7 and above and Python 3.2 and above) by Dave Hughes - the documentation is available at: http://picamera.readthedocs.org/en/release-0.8/index.html.

NOTE: This project has been tested using v0.7 and v0.8 of the Python Pi-Camera interface. There MAY be problems with other versions. Please inform us if you have problems with other versions of the Python Pi-Camera API.

top

3. Set of Instructions

The set of instructions for using the Pi-Camera are:

Configure the R-Pi system in preparation for the connection of the Pi-Camera and usage of the software i.e. the monitor, USB2 Hub, keyboard and mouse and the network connection (using either a WiPi for wireless access or using the wired Ethernet port) - see More Detail;
The Pi-Camera must now be connected to the R-Pi. The Pi-Camera is connected to the R-Pi using the CSI bus located between the Ethernet and HDMI connectors. The 15-way flat-flex connector cable, supplied with the Pi-Camera, is inserted into the CSI connector with the metallic connectors facing the HDMI connector. The system software must now be installed - see More Detail;
The connection and configuration of the Pi-Camera is tested using the 'raspistill and 'raspivid' applications. These two applications are supplied as part of the Raspbian operating system. The 'raspistill' image is used to capture one or more still images (the default format is JPEG but other formats can be used) and the 'raspivid' application is used to capture and store a video (it is saved in H.264 format) - see More Detail;
The Pure Python Pi-Camera API must now be installed. This API is used to enable the Pi-Camera to be controlled using a Python program i.e. a developer can write a program that can control the Pi-Camera to take still images and video clips - see More Detail;
Download and run the Python Pi-Camera software. Download the LED chooser software file 'CamInterfacev1p*.py', written in Python 3, to control the Pi-Camera. This software provides a GUI that allows a user to take a single still image, a sequence of still images and a video clip - see More Detail.

top

4. More Details

4.1 Configure the R-Pi System

The layout of the R-Pi (Model B) is shown in Figure 4.1. Once the various cables have been connected to the R-Pi, the configuration is as shown in Figure 4.2 (the alphanumeric annotations refer to the identifier entries in Tables 2.1 and 2.2).

Figure 4.1 - R-Pi Model B board layout.	Figure 4.2 - The R-Pi with the set of connected cables.

4.2 Connect and Configure the Pi-Camera

The front and rear views of the Pi-Camera are shown in Figure 4.3. The Pi-Camera should be handled carefully as it is susceptible to electrostatic damage. Before handling the Pi-Camera discharge yourself by touching an earthed object e.g. a radiator. When handling the camera unit itself grip the PCB surround and not the electronics or the camera lens.

Figure 4.3 - The Pi-Camera.
(a) Front View
(b) Rear View

Figure 4.3 - The Pi-Camera.

(a) Front View

(b) Rear View

The Pi-Camera must now be connected to the R-Pi (this is shown in Video 1 in Section 5). Another good video for the connection of the Pi-Camara is available at: Camera | Raspberry Pi.

Figure 4.4a Close-up of the CSI cable connection for the Pi-Camera	Figure 4.4b Pi-Camera connected to the R-Pi.

As shown in Figure 4.4a, the Pi-Camera cable is placed into the CSI Bus Connector (E). The top plate of the connector must be raised to allow the cable to be inserted. The cable is inserted with the metallic connections pointing to the left i.e. towards the HDMI connector. Make sure the cable is pushed well down. Now push the connector plate down (note in Figure 4.4a the plate has not been pushed fully down yet). When connected the system now looks as shown in Figure 4.4b.

The next step is to update the Raspian operating system and to make sure that the Pi-Camera is configured correctly. An excellent set of detailed instructions on the software configuration is available at: Camera | Raspberry Pi. The steps to be taken to configure the Pi-Camera software require the use of the LX Terminal application on the R-Pi. Start the LX Terminal and then type:-

sudo apt-get update

sudo apt-get upgrade

These update the R-Pi firmware and ensure the latest versions of the Raspbian operating system is installed. The next step is to make sure that the Pi-Camera is enabled. Type:-

sudo raspi-config

Use the cursor key to move to the camera option and select enable. On exiting raspi-config it will ask to reboot. The enable option will ensure that on reboot the correct GPU firmware will be running for the use of the Pi-Camera. Use the instructions at: Camera | Raspberry Pi for more details on how enable the Camera. Make sure you reboot the R-Pi once the P-Camera has been enabled.

4.3 Use the Raspbian Image and Video Capture Applications

The correct installation of the PiCamera can be checked by using the 'raspistill' and raspivid' applications that are supplied as part of the Raspbian O/S. An extensive set of documentation about these two applications is available at: https://github.com/raspberrypi/userland/blob/master/host_applications/linux/apps/raspicam/RaspiCamDocs.odt. Still images can be taken by launching the LX Terminal and typing:

raspistill -o image.jpg

A JPEG image will now be taken and stored in the file 'image.jpg' in the directory from which the terminal emulator was run. The image is captured after a 5s preview period and the image about to be taken is displayed on the desk-top. The 5s period can be altered by using the '-timeout' instruction on the command line. The image can be viewed by clicking on the file under the Raspbian file manager. A video (in format H.264) can be captured by typing:

raspivid -o video.h264

This will capture a 5s duration video (again the duration can be changed using the '-timeout' instruction). The video can be viewed by using the 'omxplayer' application (see bullet 3 in Section 5).

4.4 Install the Python Pi-Camera API

Now that it has been confirmed that the Pi-Camera is correctly installed and configured, the next step is to install the Python Pi-Camera API. Download the documentation at: http://picamera.readthedocs.org/en/release-0.8/index.html. It is recommended that the Python API is installed so that it is available to ALL users i.e. a System Installation. The 'CamInterfacev1p0p0.py' software that has been written for this project uses Python 3 so the Python 3 version of the Pi-Camera API is required. The relevant set of instructions are given in Section 1.2.2 (page 5) of the API documentation. Thefollowing instruction are entered into the LX Terminal:-

sudo apt-get install python3-setuptools

sudo easy_install3 picamera

Upgrades should be installed using the instruction:

sudo easy_install3 -U picamera

The next and final stage is to download the user GUI i.e. the 'CamInterfacev1p0p0.py' software (see Section 5).

top

5. Using the Camera

The user camera software is started by running the Python 3 file 'CamInterfacev1p0p0.py' (it should be possible to start the file by just clicking on it otherwise open the file using the IDLE 3 application). When the software starts the window shown in Figure 5.1 is displayed. The user can now:

Take a Single Photo - click on the left most radio button labelled 'Take a Single Photo'. Now enter the name of the file, in which the image is to be stored, in the text box labelled 'Photo Filename'. Now press the button 'Camera, Lights, ACTION'. The image that the Pi-Camera will take is now shown in a window in the bottom left of the screen. The image is taken after a one second delay and stored in the named file (this user software always creates a JPEG version - this can be changed by altering line 307 in the CamInterface file i.e. in the method 'action_single'). The image is stored in the same directory as that in which the CamInterfacev1p0p0.py file is stored. If this file is now clicked then it will be displayed on the desk-top. All of the user actions are reported in the message window (below the 'Camera, Lights, ACTION' and 'QUIT' buttons) and if an attempt is made to take the image without providing the file name then an error message is displayed;
Take a Sequence of Multiple Photos - click on the right most radio button labelled 'Take multiple Photos'. Now enter the name of the directory, in which the set of images is to be stored, in the text box labelled 'Directory name'. Next enter the number of images to be taken and the delay between each image in the text boxes 'Number of images' and 'Seconds between images' respectively. Now press the button 'Camera, Lights, ACTION'. Each image that the Pi-Camera will take is now shown in a window in the bottom left of the screen. The set of images are now taken sequentially and stored in the named directory (this directory is in the same directory as that in which the CamInterfacev1p0p0.py file is stored). These images can now be viewed by clicking on them. Again, all of the user actions are reported in the message window (below the 'Camera, Lights, ACTION' and 'QUIT' buttons) and if an attempt is made to take the images without providing the full set of information then an error message is displayed;
Shoot a Video - enter the name of the file, in which the video is to be stored, in the text box labelled 'Video Filename'. Now press the button 'Start Video'. The video that the Pi-Camera will take is now shown in a window in the bottom left of the screen. To stop the video capture press the 'Stop Video' button. The video is stored in the same directory as that in which the CamInterfacev1p0p0.py file is stored. The video is stored as a H.264 format and this cannot be easily viewed on a Raspbian desktop. Viewing this video requires the use of an application such as 'omxplayer'. The instructions to view the new video are to use the LX Terminal set for the directory containing the video and to type (shown in bold):

omxplayer <filename>.h264 - used if the display is connected to the composite output (the yellow connector)

omxplayer -o hdmi <filename>.h264 - used if the display is connected to the HDMI output

The video will now be played on the display. Again, all of the user actions are reported in the message window (below the 'Camera, Lights, ACTION' and 'QUIT' buttons) and if an attempt is made to take the video without providing the file name then an error message is displayed.

When the 'QUIT' button is pressed, the Pi-Camera is stopped and the program must be restarted before further images and/or videos can be captured.

Figure 5.1 - The startup display for the software.

A video, 7 minutes long, demonstrating the use of the Python camera software is shown in Video 1. This video is available in low resolution (a) and high resolution (b) - the high resolution will require at least a 3.5Mbps broadband data rate to view.

Video 1 - The Python Pi-Camera GUI software.
players.brightcove.net/.../index.html (a)	players.brightcove.net/.../index.html (b)

Video 1 - The Python Pi-Camera GUI software.

players.brightcove.net/.../index.html

(a)

players.brightcove.net/.../index.html

(b)

top

6. Trouble Shooting

Problem 1	Once the video has been captured and stored, the video cannot be replayed on the display. When the video file, produced by the camera, is 'clicked' the operating system asks which application should be used to open the file.
Solution	The CamInterface program stores the video in H.264 format. Viewing this video requires the use of an application such as 'omxplayer'. See bullet 3 in Section 5, Using the Camera, for instructions on how to use the 'omxplayer'.
Problem 2	The software quits prematurely with the statement that the 'picamera' library is not available.
Solution	The Python Pi-Camera API has not been installed or is not available. To install the API follow the instructions in sub-section 4.4 (Install the Python Pi-Camera API). If the API Documentation has been used as the source of the installation then make sure that the 'System Installation' instructions have been used as opposed to the 'User Installation' and that the Python 3 version instructions are followed. A 'User Installation' will require all of the software to be in the same user directory.
Problem 3	The software quits prematurely with the statement that the 'tkinter' library is not available.
Solution	Make sure that you are using the Python 3 shell. While the Python Pi-Camera API supports both Python 2.* and 3.* the GUI-based software uses the 'tkinter' library and so the program must be run using the Python 3 shell.
Problem 4	The raspistill and raspivid applications do not work.
Solution	Check that the Pi-Camera has been enabled and that the latest version of the Raspbian operating system has been installed. Follow the instructions in Section 4.2.

top

Appendix A - The Software

The 'CamInterfacev1p0p0.py' software written for this project is available in the Element14 GitHub at: https://github.com/element14/pi_project/tree/master/Pi_Camera. A clone of this software should be established using an appropriate software versioning application. The clone can be established at: https://github.com/element14/pi_project.git.

The CamInterface software consist of one class (Application). The design of the Application class is shown in Figure A1. The software design is based upon four classes:

Tk - this is core class for the Tkinter GUI library. The list of operations are those that are used by the Application class. This class is contained in the library 'tkinter' (this is only available to Python 3 programs);
PiCamera - this is the pure Python Pi-Camera API and is used to provide the control over the Pi-Camera. The list of operations are those that are used by the Application class. The class is contained in the library 'picamera' (see Appendix B for more details on this class);
Frame - the parent class for the Application. The Frame class provides the GUI framework, from the 'tkinter' library, on which the Application GUI is based;
Application - the class that provides the user with the features to control the Pi-Camera directly from the Python program. It is this class that has been written for this project and which is downloaded from the GitHub.

Figure A1 - The class structure of the CamInterface software.

This class has no attributes and eleven methods. The functionality of the eleven methods is:

__init__ () - defines all the initialisation states for the GUI (this function is called when the 'app' object is instantiated using the statement app = Application (root));
action_camera () - controls whether or not a single or set of still images are taken by the Pi-Camera;
action_multiple () - controls the Pi-Camera to take a sequence of still images;
action_single () - controls the Pi-Camera to take a single still image;
choose_multiple_photos () - directs the input of the information required to take a sequence of still images;
choose_single_photo () - directs the input of the information required to take a single still image;
create_widgets () - creates the set of instructions, buttons and the text area as shown in Figure 5.1. Defines the actions to be invoked when the state of the GUI is changed;
exit_camera () - provides the controlled close-down of the Pi-Camera;
setup_camera () - instantiates the Pi-Camera object and defines the operational configuration for the Pi-Camera;
start_video () - starts the video capture using the Pi-Camera;
stop_video () - stops the video capture using the Pi-Camera.

The relationships between the class Application and the other libraries is defined by the header instructions of:

from tkinter import * # Load the full set tkinter library

from tkinter import messagebox

from time import sleep

import picamera # The Python Pi-Camera API

import os # Raspian Operating system functions

The main program instructions are:

root = Tk () # Create the GUI root object

root.title ("Image Capture V1.0") # Give the application window a title

app = Application (root) # Create the root application object frame

root.mainloop () # Establish the operational loop

top

Appendix B - Python Pi-Camera API

The pure Python interface to the R-Pi Pi-Camera (Python 2.7 and above and Python 3.2 and above) was created by Dave Hughes and the excellent documentation is available at: http://picamera.readthedocs.org/en/release-0.8/index.html. This provides an extensive amount of information about how to use the API to control the Pi-Camera. As shown in Figure A1, the set of PiCamera API methods that are used by the 'CamInterface software' is (the page references are with respect to the v0.8 release of the Python Pi-Camera API documentation):

capture () - to capture an image from the Pi-Camera and to store it in the defined output stream (page 24);
capture_continuous () - capture images continuously from the Pi-Camera as an infinite iterator (page 25);
close () - finalises the state of the Pi-Camera (page 27);
preview_fullscreen () - retrieves or sets full-screen for the preview window (page 32);
preview_window () - retrieves or sets the size of the preview window (page 32);
recording () - returns 'True' if the 'start_recording()' method has been called and no 'stop_recording()' call has been made yet (page 33);
resolution () - retrieves or sets the resolution at which image captures, video recordings and previews will be captured (page 33);
start-preview () - displays the preview window (page 27);
start-recording () - start recording video from the Pi-Camera and store in the defined output stream (page 27);
stop _preview () - close the preview window display (page 28);
stop_recording () - stop recording from the Pi-Camera (page 28).

In the CamInterface program the Python Pi-Camera API is instantiated in the method 'setup_camera ()' using the code (line 408):

self.camera = picamera.PiCamera ()

top

Terminology

CSI Bus	The Camera Serial Interface (CSI) Bus is used to enable the R-Pi processor to use an external digital camera. Connection to the CSI bus is via a 15-way 'flat-flex' connector on the R-Pi that provides a MIPI CSI-2 hardware interface for a digital camera (used for stills or video).
HDMI	High Definition Multimedia Interface. This is one of the interfaces to the monitor. The PiView is connected to this interface.
IDLE	Integrated Development Environment for Python. It is completely written in Python and the Tkinter Graphical User Interface (GUI) toolkit (wrapper functions for Tcl/Tk). This is the development environment used for producing the software in this project.
NOOBS	New Out Of Box Software. NOOBS is used to install the appropriate version of Operating System (O/S) onto the R-Pi SD card. The Raspbian O/S is used for this project. In many cases, NOOBS is now pre-installed on SD cards that are sold for use with the R-Pi. The latest version of NOOBS is available from the Raspberry Pi Foundation downloads.
Omxplayer	An application that converts the H.264 video format into a format that can be displayed using a display connected using the composite or HDMI interfaces to the R-Pi.
Pi-Camera	The Raspberry Pi Camera Module is a custom designed add-on for R-Pi. It attaches to R-Pi by way of one of the two small sockets on the board upper surface. This interface uses the dedicated CSI bus, which was designed especially for interfacing to cameras. The CSI bus is capable of extremely high data rates, and it exclusively carries pixel data. The board itself is tiny, at around 25mm x 20mm x 9mm. It also weighs just over 3g, making it perfect for mobile or other applications where size and weight are important. It connects to R-Pi by way of a short ribbon cable. The camera is connected to the BCM2835 processor on the R-Pi via the CSI bus, a higher bandwidth link that carries pixel data from the camera back to the processor. This bus travels along the ribbon cable that attaches the camera board to the R-Pi. The sensor itself has a native resolution of 5 megapixel, and has a fixed focus lens onboard. In terms of still images, the camera is capable of 2592 x 1944 pixel static images, and also supports 1080p30, 720p60 and 640x480p60/90 video.
Python	The software in this project is written using Python 3. IDLE is used to support the development of the Python code. Note that the game playing software will not work using a Python 2 shell because Python 2 does not support the Tkinter GUI libraries.
Raspberry Pi	The R-Pi is the single board computer at the heart of this project. This project will work on both Model A and B versions.
Raspistill	The R-Pi application, available as part of the latest Raspbian O/S, that can be used to obtain still images from a Pi-Camera connected to the R-Pi via the CSI bus.
Raspivid	The R-Pi application, available as part of the latest Raspbian O/S, that can be used to obtain videos from an external Pi-Camera connected to the R-Pi via the CSI bus..
SD	Secure Digital (SD) is a non-volatile memory card format for use in portable devices. This is the storage medium for the R-Pi.
USB	Universal Serial Bus.
VGA	A Video Graphics Array (VGA) connector is a three-row 15-pin DE-15 connector. The 15-pin VGA connector is found on many video cards, computer monitors, and high definition television sets. In this project a PiView was used to connect the VGA monitor to the HDMI on the R-Pi.

top

About this Document

	Authors	Colin Smythe (Dunelm Services Limited) Christine Smythe (Dunelm Services Limited)
	Date	13th January, 2014
	Version	1.0
	Copyright	Premier Farnell
	License	GPLv3+

top

Tags: pi-camera, rpibeginner, pi-camera_project, raspberry_pi_projects