loading
Picture of The Raspberry Pi - Arduino Connection
The Pi is a fine little computer board, though not nearly as good as
the Arduino when it comes to I/O capabilities. The beautifully-engineered
Gertboard is a plug-in add-on that neatly overcomes this deficiency
by giving the Pi access to an ATMega328, but it's a very complex and
expensive solution. An alternative would be to interface an Arduino
running at 3.3 volts to the Pi, though this is easier said than done.
But, we won't let that stop us, will we?

You can buy a prebuilt  commercial version
of something similar to this project.
It's called an AlaMode, and it goes for something like $50.
Our version will cost about a third of that to build.

As a first step, we will build an Arduino plug-in board for the Pi.
It is customary to call Pi boards "plates," but indulge me and permit
me to name this particular board a hoody. Thank you.

We will be using generic stripboard to build our project. Small (3-3/4"
x 2-1/16") boards can be obtained on eBay for a bit over a dollar apiece.
It is also possible to use something like a Radio Shack 276-168 protoboard
($3.49). The main component, though, is an 3.3-volt Arduino Pro Mini.
This will permit connecting directly to the Raspberry Pi ports and other
3.3-volt devices without having to do level shifting.


Quite a number of Pi projects involve connecting sensors and devices
directly to the GPIO pins. This is not a good idea. Use buffer chips,
such as the 74HC4050 hex buffer, between the devices and the GPIO.
This protects the Pi from overvoltages, current surges, and your mistakes.
Far better to blow out a fifty-cent buffer chip than a $35 Pi.

This particular project connects directly to the GPIO Rx and Tx pins.
However, we are connecting to a 3.3 volt device, which limits the risk.
Still, a buffer chip would not be a bad thing here.


This is a moderately complex project, and beginners need not apply.
It requires skill at soldering and in the use of hand tools. Experience
with a continuity tester and a steady hand with a knife blade are also
helpful.

Ready? Well, then, let's get on with it!


 
Remove these adsRemove these ads by Signing Up

Step 1: Parts needed

  1. Arduino 3.3-volt Pro Mini clone
  2. 1 - stripboard (protoboard), 3-3/4" x 2" or larger
  3. 1 - 24-pin wire-wrap socket ***
  4. 1 - 26-pin, stacking header
  5. 2 - 40 pin female header strip (as for Arduino projects)
  6. 4 - female-to-male jumper cables / patchcords
  7. Nokia 5110 display (optional, but recommended) 
  8. Raspberry Pi, model A preferred (lower power drain)
  9. Video display for the Pi, Atrix lapdock recommended
  10. Hookup wire
Nothing terribly exotic, folks, and fairly cheap to get, too.


Cost:
  • stripboard              $1.25
  • wire-wrap socket   $1.50
  • stacking header     $2.00
  • jumper cables        $4.00 (for set of 40)
  • female header strips                     $1.00
  • Nokia display         $6.00
  • Arduino pro mini  (or clone of same),  3.3 volt model   $7.00


Total is under $25, if you don't already have any of the components laying
around.


Tools:
  • Soldering iron
  • wire cutters (Plato 170 or similar)
  • sharp knife (or optionally a Dremel-type rotary tool)
  • continuity tester (preferred) or a multitester



Notes:

*** Do not use a regular 24-pin socket. The legs of the Arduino pro mini
      will not fit into the holes. But, you can substitute two 14-pin strips of female headers.
    

Yes, it is possible to use a "normal" mini-Arduino powered at 3.3 volts for this project.
Some examples of such are the Boarduino and Ardweeny.
Be aware, however, that the ATMega328 chip is not rated to run at 16 MHz powered
at 3.3 volts. So, you would be running it out of spec, or essentially overclocking it.
I've done some experimenting with this, and at least some, maybe most ATMega328s
can be programmed and run at 3.3 v. But, of course, your mileage may vary.

Step 2: Building the board [1]: Installing the GPIO header

I used a stripboard to build the Raspberry Pi interface
board/hoody. Stripboard has the advantage of design flexibility --
it does not constrain the component layout to any particular configuration.
It's also much cheaper than equivalent-sized solderable protoboards.
The chief disadvantage of stripboard is the necessity of extensive cutting
of copper traces on the solder side.

It's advisable to have a preliminary idea of the layout before beginning.
A rough diagram on a sheet of paper helps.

I mounted the 26-pin stacking (long-pin) GPIO header near one edge
of the board, with the female (plug-in) part of the header on the
copper-trace side. The trick is for the header not to mount flush
against the board, but to stand off about 1/4" high in order to permit
soldering the pins to the copper traces. But, first we need to cut
thirteen rows of traces where the GPIO header will mount, so that adjacent
header pins will not be shorted to each other (see 2nd and 3rd illustrations).
Cutting the traces requires going back and forth with a sharp knife blade
with a fair amount of pressure (caution!), then follow-up checking with
a continuity tester. It's a fair amount of work, and next time I try
something like this I'll probably use a Dremel tool with cutting disk,
rather than a knife.

With the thirteen traces cut, carefully mount the GPIO header
approximately 1/4" in elevation. This will give enough room to maneuver
the tip of the soldering iron between the pins to solder them. A couple
of dabs of poster-mounting putty hold the header in position prior to
soldering. Solder one end pin, then carefully straighten out the header
so it sits perpendicular to the board. Solder the remaining pins, then
use the continuity tester to look for shorts beween pins, both sideways
and across. A good continuity tester with audible indicator is especially
helpful here.


After soldering, the header pins will protrude 1/4" or a bit more on the perfboard
(non-solder) side. This is convenient, as these will function as posts to attach
patch-cords and jumpers. Each post will be an electrical connection to the
corresponding GPIO pin underneath when the board is mounted on the Pi.

Step 3: Building the board [2]: Installing the Arduino socket

The interface board needs a means of plugging in an Arduino, and
specifically a 3.3-volt mini Arduino Pro. This is where the 24-pin
wire-wrap socket comes in. For some reason, the Arduino Pro module neatly
plugs into a wire-wrap socket, but the pins are too fat for a regular
24-pin socket
. Fortunately, wire-wrap sockets are widely-available and
not too expensive. I happened to have a couple laying around from a 2716
EPROM project I was working on several decades back.

Position the socket about an inch down from where the two rows of posts
stick up from the GPIO header on the perfboard side (see pics). Solder
the socket flush onto the board. After soldering, clip the protruding
pins flush on the copper-trace side of the board. Then, cut the rows
of copper traces between the two rows of soldered pins on the socket,
so that adjacent pins do not short together.

From the 40-pin female header strip, clip off two 12-pin strips.
On the perfboard side, position a 12-pin female header strip on each side
of the IC socket. This will provide plug-in points for jumper-wires to
access the Arduino pins. Secure the header strips so they are vertically
positioned relative to the board. Now, turn over the board and solder
each row.

There is a sort of art to clipping off sections of female header strip.
There are no notches, as with male header strip, so the clipped-off
strips will usually come out a bit ragged, but this hardly matters. The
trick is to clip in the middle of a hole, and this will either leave
a metal prong hanging, or the prong will just fall out. It wastes one
hole of the strip each time you clip, but there is no avoiding this.

There is a piece of female header strip left over. Clip off an 8-pin
strip from it. You will have to get the second 40-pin strip in order to
be able to clip the second 8-pin strip because one pin always gets wasted
in the clipping process. These two strips will make up a socket for an
optional Nokia 5110 monochrome display for our project. The two rows will
short together on the solder side, so jumper wires can be electrically
connected to the pins of the Nokia display. Position the strips, then
turn over the board and solder them. Finally, cut rows of copper traces,
so that the Nokia socket is electrically isolated from everything else.

I installed two dual-row "utility" socket strips on the periphery of
the board. The installation and soldering procedure is the same as that
for the Nokia socket. The actual number of pins in these socket rows is
arbitrary, but they are useful for power and ground busses, among other
things. After soldering, cut appropriate rows of copper traces to isolate
these strips electrically from the rest of the board.

Step 4: Wiring it up: Part 1

Picture of Wiring it up: Part 1
arduino.plugged-in.02.jpg
arduino.plugged-in.03.jpg
pluggin-in.nokia5110-display.jpg
running-wires.01.jpg
running-wires.02.jpg
Now that the interface hoody is built, where do we go from here?
We must still plug in the Arduino Pro and the Nokia display into the
sockets we've prepared. Then, we'll run jumper wires and patch-cords --
from the Arduino to the display, and, in the following step, from the
Arduino to the GPIO posts.

If you have just purchased a Nokia 5110 display, then you will need
to solder a row of male headers to the 8 solder holes for the power
and date lines. Take note of how the holes are labeled.

Nokia 5110 displays, unfortunately, do not have a standard pinout
configuration. They do all have the same complement of pins, but they
are not necessarily in the same position on the display board's
connector. Even the labeling of the pins varies, though they still
have the standard functions.

  • Arduino     Nokia display pin name          Nokia display pin number
  • (Digital)
  •  
  • pin 7 -     Serial clock out (SCLK)             varies
  • pin 6 -     Serial data out (DIN)                 (see pin labels on display)
  • pin 5 -     Data/Command select (D/C)
  • pin 4 -     LCD chip select (CS)
  • pin 3 -     LCD reset (RST)
  •  
  • Vcc           --> Nokia Vcc (3.3 v.)
  • Ground     --> Nokia Ground
  • Vcc           --> Nokia backlight

If possible, use different colored jumper wires for each function,
say red for Vcc, black for ground, and appropriate colors for the
data lines. This will make it easier to trace the connections and to
double-check your work. Work slowly and meticulously, and be especially
careful not to make any errors with the Vcc and ground connections.

Note that in the illustration the two end pins in each strip of the Nokia socket
have wire jumpers. This is because I used 10-pin strips, and the Nokia display
uses only 8 pins. The jumpered holes are blocked from use.


We're almost done with the hardware part of the project, so you can stop
and have a cup of coffee.


Step 5: Wiring it up: Part 2

Picture of Wiring it up: Part 2
2.gpio-connector.diagram.png
3.gpio-pins.board.labeled.jpg
Time to connect up the GPIO header posts with the Arduino pins.
We will use female-to-male jumper patch-cords.

There are only four, count 'em, four connections to make.
Here is where the two rows of female headers alongside the Arduino socket come
in handy.

  1. Vcc (3.3v) on the Arduino connects to the GPIO Vcc (3.3v) pin:    Pin #1.
  2. Ground on the Arduino connects to the GPIO Ground pin:           Pin #6.
  3. TxD on the Arduino connects to the GPIO RxD pin:                        Pin #10.
  4. RxD on the Arduino connects to the GPIO TxD pin:                        Pin #8.

Note that TxD connects to RxD, and vice-versa. The reason for this is that
signal-out on one device goes to signal-in on the other. It's a bit confusing
at first, but quite logical when you think about it.

To facilitate tracing and troubleshooting, use a red jumper for Vcc and a
black one for ground, and two other colors for TxD/RxD and RxD/TxD.

Check your work, and be especially careful with Vcc and ground. A mistake
here could be costly.


Whew! All done with the hardware! Now, on to the software.

Step 6: Software, Part 1: Arduino sends data to Pi

Picture of Software, Part 1: Arduino sends data to Pi
minicom.listening-to-arduino.rxtx.png
A preliminary note:
This, and the following two steps work on a Pi running Fedora Remix 18
(Pidora). I had only partial success with Arch Linux, and no joy at
all with Raspian or Occidentalis, possibly because these distros tie
up /dev/ttyAMA0.


We're not quite ready to plug the interface hoody into the Pi.
First, let's load a program into the Arduino Pro that will tell
it to broadcast data on its serial port. Hook up an appropriate
serial/tty-to-USB cable or an FTDI breakout board to the 6-pin right-angle
programming header. Plug the USB end into your laptop computer
running the Arduino IDE, and upload the following sketch into the Arduino.
So, this would give the Pi access to analog ports and devices that connect
to same.

This is a simple sketch that increments a variable and sends it to
serial-out as part of a "Line Number #" string. It will display in the
console or on an xterm on the Pi running minicom
(sudo yum install minicom if it's not already installed).


* ArduinoTalks.ino
   Arduino sends message to the Pi */

//#include <stdlib.h>
#define DELA 1200  // Time between message sends.
int cnt=0;


void setup() {
  Serial.begin(9600);

}

void loop() {
  Serial.print("Line Number # [");
  Serial.print(cnt);
  Serial.println("]");
  delay(DELA);
  cnt++;
 
}



You can also download it:
http://bash.deta.in/ArduinoTalks.ino


Now, we're finally ready to plug our interface hoody into the Pi's GPIO
connector. Carefully orient the pins so that female header Pin 1 plugs
into GPIO Pin1, etc. Gently press down, and ...

   Note: This step does not need the Nokia 5110 display. You can leave
   it plugged in if you like, or remove it.

All right, hook up the Pi to power and a video display. Make sure an
SD card with Pidora is in the card slot underneath. Now boot it up and
invoke minicom (sudo minicom -s) in the console or in an xterm. You'll
have to set minicom to the /dev/ttyAMA0 serial port, because this is
what rx and tx are hooked to. The default setting of minicom is
/dev/modem, so you can cd /dev and sudo ln -s ttyAMA0 modem.
And set the baud rate to 9600, because that's what the sketch has
set the Arduino serial transmission speed to.

Cross your fingers. Can you see the data that the Arduino is sending?

This might seem trivial and of little practical value, but consider this.
Suppose the Arduino is receiving data from a sensor connected to
an analog pin. Then the Arduino could communicate this data directly
to the Pi through minicom. And note that minicom can save the data sent
to it in a logfile.



Step 7: Software, Part 2: Pi sending data to the Arduino (Blinking an LED)

Picture of Software, Part 2: Pi sending data to the Arduino (Blinking an LED)
And now for something a bit more difficult. Let's have the Pi tell the
Arduino how many time to blink an LED. We'll use the Arduino's on-board
LED at D13 for simplicity, though it's certainly possibly to change the
LedPin variable in the sketch, and hook up an outboard LED-plus-resistor
between the appropriate digital pin and ground.


The "driver" is a short shell script. That's right, a lowly Bash script.
In fact, it's even possible to do it right from the command line in
the console or in an xterm: echo 3 > /dev/ttyAMA0 for three blinks, for
example, or echo 7 > /dev/ttyAMA0 for seven blinks. No Python programming
and no libraries to install! Well, I don't much care for pythons or nasty
sorts of snakes that wrap around and the crush you. If I run into one,
I'm liable to Bash it over the head.

=== Recall that /dev/ttyAMA0 is the Pi's serial port. ===

It's necessary to run a minicom session in order to initialize the
/dev/ttyAMA0 serial port. Then, Control-A Q to exit minicom without
resetting the serial port. Note that it's also possible to send blink
commands directly from within minicom -- typing a 5 in the minicom
window blinks the Arduino's LED 5 times, and it's not even necessary
to set local echo. The Arduino receives anything sent to /dev/ttyAMA0
on its hardware serial port (Rx and Tx), and it it can interpret what comes its way
if programmed by an appropriate sketch. You see, folks, if you use the
Arduino as a go-between, you don't need to mess with Python or libraries.
 

Summarizing: Run a minicom session to initialize /dev/ttyAMA0, and then
Control-A Q to exit. And note that the Arduino has to have the following
sketch loaded. Then finally, run the Bash script below from the console
or an xterm.


Here is the Arduino sketch:

/*
  ArduinoListens.ino
 
  Pi sends a digit (1 - 9) to Arduino,
  and Arduino blinks LED at D13 that many times.
*/

#define DELA 500   // Long delay.
#define DSHORT 250 // Short delay.
const int ledPin = 13;

void setup() {               
  pinMode(ledPin, OUTPUT); // Initialize pin as output.
  // Pin 13 has an LED hooked to it.
  Serial.begin(9600); 
}

void loop() {
   if ( Serial.available() )
   { light(Serial.read() - '0'); } // How many positions past ASCII 0?
   delay (DELA);
}


void light(int n) {
  for (int i = 0; i < n; i++)
  {
  digitalWrite(ledPin, HIGH);   // Turn the LED on.
  delay(DSHORT);       
  digitalWrite(ledPin, LOW);   // Turn the LED off.
  delay(DSHORT);               // Wait.
  }
}


You can download it here:
http://bash.deta.in/ArduinoListens.ino



And here is the Bash script:

#!/bin/bash
# Accepts command-line arg telling Arduino how many times to blink
#+ (0 - 9).

DEFAULT=1          # One blink if no command-line arg.

if [ -z "$1" ]     # If no command-line arg ...
then
  blinks=$DEFAULT
else
  blinks=$1
fi

port=/dev/ttyAMA0  # Direct connection to Pi rx and dx pins.

echo $blinks > $port

exit $?

# TODO:
# ----
# 1) Error checking on command-line input.
# 2) More than 9 blinks by parsing multi-character command-line arg.


You can download it here:
http://bash.deta.in/blink-ard.sh


Not a very complex sketch, and think of how easy it would be to modify it to
run a servo or stepper motor.


Blink! Blink! Blink!



Step 8: Software, Part 3: Pi IP address on Nokia display

Picture of Software, Part 3: Pi IP address on Nokia display
1.final.jpg
display.ip-address.jpg
As a grand finale, the Pi will send its IP address to a Nokia 5110
display. We will need to have the display plugged into its wired-up
socket. Additionally, the Pi will require a wireless adapter plugged into
a USB port and the appropriate procedures taken so that the Pi logs on to
the local network. And, of course, the Arduino needs to have the sketch
below loaded.

Boot up the Pi with the required equipment plugged in. After boot-up,
run a minicom session just as in the previous step, to initialize the
Pi's serial port. Finally, run the Bash script further down in this step.


Here is the Arduino sketch:

/* Nokia PCD8544 display, Serial port data in. */
/* In this particular case, the IP address. */
/* Run shell script that parses and sends IP addr. to /dev/ttyUSB0. */

#include <stdio.h>


#include "PCD8544.h"
/* Digital pins. */
// pin 7 - Serial clock out (SCLK)
// pin 6 - Serial data out (DIN)
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
PCD8544 nokia = PCD8544(7, 6, 5, 4, 3);

#define INTERVAL 500
#define BUFFSIZE 80 // Serial buffer.

char line1[40]="IP Address:"; // Header.
int DELAY=4000; // Interval between updates of display.


void setup(void) {

  nokia.init();
  nokia.command(PCD8544_DISPLAYCONTROL | PCD8544_DISPLAYNORMAL);
  Serial.begin(9600);   // Start The Serial UART at 9600 Baud.
  
  nokia.clear();
  nokia.drawstring(0, 0, line1);
  nokia.display();
}

void loop(void)
{
 
  char serialdata[BUFFSIZE+3];
  int lf = 10;
 
 
  Serial.readBytesUntil(lf, serialdata, BUFFSIZE);
 
 
  nokia.drawstring(0, 1, serialdata);
 
  nokia.display();
 
// delay(INTERVAL);
}

You can download it here:
http://bash.deta.in/NokiaSerial.ino



Here is the Bash script:

#!/bin/bash
# inet.addr.sh
#  Echo the Pi's IP address to a serial port . . .
#+ . . . to which we happen to have attached an Arduino.
#  Run this script after Aduino is powered up with appropriate sketch
#+ (NokiaSerial.ino).

command=ifconfig
addr_hdr="addr:"
addr_prefix="inet 192"      # For Pidora. May change for other distro!
serial_port=/dev/ttyAMA0    # Direct connection to Pi rx and dx.

# ifconfig | grep "inet 192" | awk '{print $2}' | sed s/addr://
ipaddr=$(${command}| grep "$addr_prefix" |
awk '{print $2}' | sed s/$addr_hdr//)

echo $ipaddr > "$serial_port"   # Not necessary to put in loop or repeat.
# echo $ipaddr   # Debug.

exit $?


You can download the script here:
http://bash.deta.in/inet.addr.sh


Do you see the Pi's IP address on that little Nokia display?
Amazing, isn't it?

This particular application is handy if you set the Pi up as a headless server.
After the Pi boots up, it displays its IP address on the network,
and this indicates that everything is working okay. It also makes it easier
to do a remote log-on from another computer. As an exercise,
you might modify the Bash script to additionally display something about the
Pi's state on the other available lines of the Nokia display, such as
free space on the SD card (df command).

Step 9: Where do we go from here?

Picture of Where do we go from here?
Now that we know how to interface the Pi with an Arduino, it opens up
a number of possibilities.

  • Hook up a GPS module to the Arduino, and use the Pi as a front end to
  • parse and display the data, and maybe show the location on Google maps.
  •  
  • Hook up a geiger counter to the Arduino, and use the Pi as a front end
  • to graph the data.
  •  
  • Hook up the Arduino to control a remote IP-enabled security camera,
  • and have the Pi display and save what the camera sees.
  •  
  • Control a servo or stepper motor.

macpe1 year ago

To get it working on Raspbian you need to stop /dev/ttyAMA0 from working as a serial console since that will screw things up. See the following link for how to do this:

http://www.raspberry-projects.com/pi/pi-operating-systems/raspbian/io-pins-raspbian/uart-pins

Thank you so much. I'm trying to send data from Arduino to OpenHAB and my heart sunk when I saw this Instructable wasn't for Raspbian. Thanks!

thegrendel (author)  macpe1 year ago

Yes, and thank you for the fix.

Most Pi users do install Raspian, so this info is very helpful.

thegrendel (author) 1 year ago
Rather than a stacking header that plugs the board directly
on top of the Pi, some of you might prefer to use a shrouded
box-type header and connect to the Pi with a 26-pin standard cable.
This takes up more workspace, but gives extra flexibility.

And hey, folks, how about some ideas and suggested improvements?
Or maybe someone would like to produce an etched PC board.
thegrendel (author)  thegrendel1 year ago
Another alternative:

Use a stacking header as described in the Instructable,
and get a female-to-male 26-pin cable to give the option
of using the interface board off the Pi.
Orngrimm1 year ago
Cool!
since i love Arduino's and also have a Pi which i kinda hate since i dont have the loved I/O-o-rama i know from Arduino, thats the perfect 'ible for me!

2x voted! :)
thegrendel (author)  Orngrimm1 year ago
Thank you for the praise, Orn.

As you've noted, the Pi lacks analog IO, which an attached
Arduino can provide. The other great shortcoming of the PI
is the fragile non-replaceable SOC/CPU, which requires much
care when directly connecting to the GPIO pins. A cheap Arduino
board, or even an ATMega 328 jig, running at 3.3 v makes a perfect
buss buffer.
KronoNaut1 month ago

Thank you for this. I have been thinking about reading the analog data from my 1973 Super Beetle and displaying it, this may allow me to start on a project to do so.

BrianM154 months ago

What if I need to send more than a single byte? I have coordinates x,y with values ranging from 0 to 255 in the raspberry pi. For example: 178, 243.

How would I send this to the arduino and how would the arduino receive it so that it can be stored in two different variables (x and y)?

thegrendel (author)  BrianM154 months ago
Send them as consecutive bytes, and let your software handle concatenating the values.
Kamilon11 months ago

If you want to use a 5v Arduino to do the same thing (or any other microcontroller) take a look at my logic level converter solutions here:

http://blog.kamilon.com/?page_id=263

one question please. My arduino pro mini is externally sourced by a 12v font in order to drive a rgb led strip. In this case,can i only connect the raspberry and arduino rx tx pins? So I can control led strip from a Java programa running on pi.

thegrendel (author)  Jose Inacio1 year ago
Make absolutely certain that the Arduino's rx and tx signals are at 3.3 volts. More than that will damage the Pi.
Robo-T1 year ago

At first I was very interested in the Raspberry Pi, but found what I was really looking for was the Arduino. I have both and like getting them to work together. Recently, Intel has come out with the Galileo. It seems that the Galileo is similar to what you did combining the Pi with Arduino. Would you see it that way? Or is there a big difference. With a Galileo, due, and every other board coming out which way will it all go?

Thx for the write up. We will be doing some integration with your article as a basis.

thegrendel (author)  Robo-T1 year ago
Yes, the Intel Galileo is interesting, but it is a bit more expensive than the Pi, has less community support, and lacks documentation at present. Note that I don't possess one, and base this judgment solely on what I've read about it.

Hooking an Arduino or Hackduino to the Pi has the one big advantage that the Pi itself is not exposed to overvoltages or excess current. If you blow up a '328 chip, you can replace it for $3 or so, not a big deal, whereas if you blow up the Pi it's a bit more serious.

Thank you for your perceptive comments.
xXYEIROXx1 year ago
I have a question. If I just get a usb board like an UNO or Mega, can I just plug the Arduino in the RPi's usb port?
thegrendel (author)  xXYEIROXx1 year ago
Yes, if . . .

1) You're using a USB hub with the Pi and have a spare port on it.

2) You've installed the Arduino IDE software package on the Pi.

With both of the above in place, you can program sketches for the Arduino and upload them to it. But, other communication between
the PI and Arduino over the USB buss is quite another matter.
Much easier is using the serial ports.
nerd74731 year ago
do you have the arduino IDE on the raspberry pi? If not enter the following

sudo apt-get install arduino

it will be typed into the terminal and then download after you hit enter. I may make an instructable on how to install it and some other stuff about it too!
thegrendel (author)  nerd74731 year ago
Yes, thank you, I have that installed.

I think your idea about an instructable is interesting,
but you may want to consider expanding the scope of it.
How about doing an instructable on installing software
packages on the Pi? And maybe also about installing
different Linux distros? You'll do an excellent job at
this, I'm sure, and many Pi users will benefit.

Thanks for your comment.
I may do a separate one for Linux distros or maybe even xbmc
hey thegrendel I published it you can feel free to take a look!
so I should make an instructable about how to install arduino IDE on wheezy
Ok I will make one over that it is a very good idea
diy_bloke1 year ago
as a socket you can also use 2 14-pin dil sockets
thegrendel (author)  diy_bloke1 year ago
"There are nine and sixty ways of constructing tribal lays,
And every single one of them is right!"

-- Ruddy Kipling