Instead of rewiring the remote control, you can replicate the remote's RF signals using a transmitter that uses the same frequency as your sockets (these particular units use 433.94 MHz). This will depend on the particular sockets and sometimes your location—some countries prohibit the use of certain frequencies—as you may require certification before making your own transmissions:

The 433.94 MHz RF transmitter (left) and receiver (right)

The signals sent by the RF remote control can be recreated using 433Utils created by http://ninjablocks.com. The 433Utils uses WiringPi and are written in C++, allowing high speed capture and replication of the RF signals.

Obtain the code using the following command:

cd ~
wget https://github.com/ninjablocks/433Utils/archive/master.zip
unzip master.zip

Next, we need to wire up our RF transmitter (so we can control the switches) and RF receiver (so we can determine the control codes) to the Raspberry Pi.

The transmitter (the smaller square module) has three pins, which are power (VCC), ground (GND), and data out (ATAD). The voltage supplied on the power pin will govern the transmission range (we will use 5V supply from the Raspberry Pi, but you could replace this with 12V, as long as you ensure you connect the ground pin to both your 12V supply and the Raspberry Pi).

Although the receiver has four pins, there is a power pin (VCC), ground pin (GND), and two data out pins (DATA), which are wired together, so we only need to connect three wires to the Raspberry Pi.

Before we use the programs within the RPi_Utils, we will make a few adjustments to ensure our RX and TX pins are set correctly.

Locate codesend.cpp in 433Utils-master/RPi_utils/ to make the required changes:

cd ~/433Utils-master/RPi_utils
nano codesend.cpp -c

Change int PIN = 0; (located at around line 24) to int PIN = 11; (RPi physical pin number).

Change wiringPi to use physical pin numbering (located around line 27) by replacing wiringPiSetup() with wiringPiSetupPhy(). Otherwise, the default is WiringPi GPIO numbers; for more details, see http://wiringpi.com/reference/setup/. Find the following line:

if (wiringPiSetup () == -1) return 1;

Change it to this:

if (wiringPiSetupPhys () == -1) return 1;

Save and exit nano using Ctrl + X, Y.

Make similar adjustments to RFSniffer.cpp:

nano RFSniffer.cpp -c

Find the following line (located at around line 25):

     int PIN = 2;

Change it to this:

     int PIN = 13; //RPi physical pin number

Find the following line (located at around line 27:

     if(wiringPiSetup() == -1) {

Change it to this:

     if(wiringPiSetupPhys() == -1) {

Save and exit nano using Ctrl + X, Y.

Build the code using the following command:

make all

This should build without errors, as shown here:

g++    -c -o codesend.o codesend.cpp
g++   RCSwitch.o codesend.o -o codesend -lwiringPi
g++    -c -o RFSniffer.o RFSniffer.cpp
g++   RCSwitch.o RFSniffer.o -o RFSniffer -lwiringPi

Now that we have our RF modules connected to the Raspberry Pi and our code ready, we can capture the control signals from our remote. Run the following command and take note of the reported output:

sudo ./RFSniffer

Get the output by pressing Button 1 OFF with the remote set to channel A (note we may get a few that pick up random noise):

Received 1381716
Received 1381716
Received 1381716
Received 1381717
Received 1398103

We can now send out the signals using the sendcode command to switch the sockets OFF (1381716) and ON (1381719):

sendcode 1381716
sendcode 1381719

You could even set up the Raspberry Pi to use the receiver module to detect signals from the remote (on an unused channel) and act upon them to start processes, control other hardware, or perhaps trigger a software shutdown/reboot.

The range of the transmitter is very limited when it is powered by 5V and without an additional antenna. However, it is worth testing everything before you make any modifications.

Simple wire antenna can be made from 25 cm of single core wire, 17 mm side connected to the antenna solder point, then 16 turns (made using a thin screwdriver shaft or similar) and the remaining wire on top (approximately 53 mm). This is described in more detail at .

The transmitter range is vastly improved with a simple antenna

Recording the codes this for each of the buttons, we can determine the codes for each (and break down the structure):

To select channel A, B, C, or D, set the two bits to 00. Similarly, for button 1, 2, or 3, set the two bits to 00 to select that button. Finally, set the last two bits to 11 for ON or 00 for OFF.

See https://arduinodiy.wordpress.com/2014/08/12/433-mhz-system-foryour-arduino/, which analyses these and other similar RF remote controls.

The wiringPi library that we used previously for I²C also supports SPI. Ensure that wiringPi is installed (see Chapter 7, Sense and Display Real-World Data, for details) so that we can use it here.

Next, we need to enable SPI if we didn't do so when we enabled I²C previously:

sudo nano /boot/config.txt

Remove the # before #dtparam=spi=on to enable it, so it reads, and save (Ctrl + X, Y, Enter):

dtparam=spi=on

You can confirm that the SPI is active by listing all the running modules using the following command and locating spi_bcm2835:

lsmod

You can test the SPI with the following spiTest.py script:

#!/usr/bin/python3
# spiTest.py
import wiringpi

print("Add SPI Loopback - connect GPIO Pin19 and Pin21")
print("[Press Enter to continue]")
input()
wiringpi.wiringPiSPISetup(1,500000)
buffer=str.encode("HELLO")
print("Buffer sent %s" % buffer)
wiringpi.wiringPiSPIDataRW(1,buffer)
print("Buffer received %s" % buffer)
print("Remove the SPI Loopback")
print("[Press Enter to continue]")
input()
buffer=str.encode("HELLO")
print("Buffer sent %s" % buffer)
wiringpi.wiringPiSPIDataRW(1,buffer)
print("Buffer received %s" % buffer)
#End

Connect inputs 19 and 21 to create an SPI loopback for testing.

The SPI loopback test

You should get the following result:

Buffer sent b'HELLO'
Buffer received b'HELLO'
Remove the SPI Loopback
[Press Enter to continue]
Buffer sent b'HELLO'
Buffer received b'x00x00x00x00x00'

The example that follows uses an LED 8 x 8 matrix display that is being driven by an SPI-controlled MAX7219 LED driver:

An LED Controller MAX7219 pin-out, LED matrix pin-out, and LED matrix internal wiring (left to right)

Although the device has been designed to control eight separate 7-segment LED digits, we can use it for our LED matrix display. When used for digits, each of the seven segments (plus a decimal place) is wired to one of the SEG pins, and the COM connection of each of the digits is wired to the DIG pins. The controller then switches each of the segments on as required, while setting the relevant digit COM low to enable it. The controller can quickly cycle through each of the digits using the DIG pin fast enough that all eight appear to be lit at the same time:

A 7-segment LED digit uses segments A to G, plus DP (decimal place)

We use the controller in a similar way, except each SEG pin will connect to a column in the matrix and the DIG pins will enable/disable a row.

We use an 8 x 8 module connected to the MAX7219 chip as follows:

The MAX7219 LED controller driving an 8 x 8 LED matrix display

To control an LED matrix connected to an SPI MAX7219 chip, create the following matrixControl.py script:

#!/usr/bin/python3
# matrixControl.py
import wiringpi
import time

MAX7219_NOOP        = 0x00
DIG0=0x01; DIG1=0x02; DIG2=0x03; DIG3=0x04
DIG4=0x05; DIG5=0x06; DIG6=0x07; DIG7=0x08
MAX7219_DIGIT=[DIG0,DIG1,DIG2,DIG3,DIG4,DIG5,DIG6,DIG7]
MAX7219_DECODEMODE  = 0x09
MAX7219_INTENSITY   = 0x0A
MAX7219_SCANLIMIT   = 0x0B
MAX7219_SHUTDOWN    = 0x0C
MAX7219_DISPLAYTEST = 0x0F
SPI_CS=1
SPI_SPEED=100000

class matrix():
  def __init__(self,DEBUG=False):
    self.DEBUG=DEBUG
    wiringpi.wiringPiSPISetup(SPI_CS,SPI_SPEED)
    self.sendCmd(MAX7219_SCANLIMIT, 8)   # enable outputs
    self.sendCmd(MAX7219_DECODEMODE, 0)  # no digit decode
    self.sendCmd(MAX7219_DISPLAYTEST, 0) # display test off
    self.clear()
    self.brightness(7)                   # brightness 0-15
    self.sendCmd(MAX7219_SHUTDOWN, 1)    # start display
  def sendCmd(self, register, data):
    buffer=(register<<8)+data
    buffer=buffer.to_bytes(2, byteorder='big')
    if self.DEBUG:print("Send byte: 0x%04x"%
                        int.from_bytes(buffer,'big'))
    wiringpi.wiringPiSPIDataRW(SPI_CS,buffer)
    if self.DEBUG:print("Response:  0x%04x"%
                        int.from_bytes(buffer,'big'))
    return buffer
  def clear(self):
    if self.DEBUG:print("Clear")
    for row in MAX7219_DIGIT:
      self.sendCmd(row + 1, 0)
  def brightness(self,intensity):
    self.sendCmd(MAX7219_INTENSITY, intensity % 16)

def letterK(matrix):
    print("K")
    K=(0x0066763e1e366646).to_bytes(8, byteorder='big')
    for idx,value in enumerate(K):
        matrix.sendCmd(idx+1,value)

def main():
    myMatrix=matrix(DEBUG=True)
    letterK(myMatrix)
    while(1):
      time.sleep(5)
      myMatrix.clear()
      time.sleep(5)
      letterK(myMatrix)

if __name__ == '__main__':
    main()
#End

Running the script (python3 matrixControl.py) displays the letter K.

We can use a GUI to control the output of the LED matrix using matrixMenu.py:

#!/usr/bin/python3
#matrixMenu.py
import tkinter as TK
import time
import matrixControl as MC

#Enable/Disable DEBUG
DEBUG = True
#Set display sizes
BUTTON_SIZE = 10
NUM_BUTTON = 8
NUM_LIGHTS=NUM_BUTTON*NUM_BUTTON
MAX_VALUE=0xFFFFFFFFFFFFFFFF
MARGIN = 2
WINDOW_H = MARGIN+((BUTTON_SIZE+MARGIN)*NUM_BUTTON)
WINDOW_W = WINDOW_H
TEXT_WIDTH=int(2+((NUM_BUTTON*NUM_BUTTON)/4))
LIGHTOFFON=["red4","red"]
OFF = 0; ON = 1
colBg = "black"

def isBitSet(value,bit):
  return (value>>bit & 1)

def setBit(value,bit,state=1):
  mask=1<<bit
  if state==1:
    value|=mask
  else:
    value&=~mask
  return value

def toggleBit(value,bit):
  state=isBitSet(value,bit)
  value=setBit(value,bit,not state)
  return value

class matrixGUI(TK.Frame):
  def __init__(self,parent,matrix):
    self.parent = parent
    self.matrix=matrix
    #Light Status
    self.lightStatus=0
    #Add a canvas area ready for drawing on
    self.canvas = TK.Canvas(parent, width=WINDOW_W,
                        height=WINDOW_H, background=colBg)
    self.canvas.pack()
    #Add some "lights" to the canvas
    self.light = []
    for iy in range(NUM_BUTTON):
      for ix in range(NUM_BUTTON):
        x = MARGIN+MARGIN+((MARGIN+BUTTON_SIZE)*ix)
        y = MARGIN+MARGIN+((MARGIN+BUTTON_SIZE)*iy)
        self.light.append(self.canvas.create_rectangle(x,y,
                              x+BUTTON_SIZE,y+BUTTON_SIZE,
                              fill=LIGHTOFFON[OFF]))
    #Add other items
    self.codeText=TK.StringVar()
    self.codeText.trace("w", self.changedCode)
    self.generateCode()
    code=TK.Entry(parent,textvariable=self.codeText,
                  justify=TK.CENTER,width=TEXT_WIDTH)
    code.pack()
    #Bind to canvas not tk (only respond to lights)
    self.canvas.bind('<Button-1>', self.mouseClick)
  
  def mouseClick(self,event):
    itemsClicked=self.canvas.find_overlapping(event.x,
                             event.y,event.x+1,event.y+1)
    for item in itemsClicked:
      self.toggleLight(item)

  def setLight(self,num):
    state=isBitSet(self.lightStatus,num)
    self.canvas.itemconfig(self.light[num],
                           fill=LIGHTOFFON[state])
    
  def toggleLight(self,num):
    if num != 0:
      self.lightStatus=toggleBit(self.lightStatus,num-1)
      self.setLight(num-1)
      self.generateCode()

  def generateCode(self):
    self.codeText.set("0x%016x"%self.lightStatus)

  def changedCode(self,*args):
    updated=False
    try:
      codeValue=int(self.codeText.get(),16)
      if(codeValue>MAX_VALUE):
        codeValue=codeValue>>4
      self.updateLight(codeValue)
      updated=True
    except:
      self.generateCode()
      updated=False
    return updated

  def updateLight(self,lightsetting):
    self.lightStatus=lightsetting
    for num in range(NUM_LIGHTS):
      self.setLight(num)
    self.generateCode()
    self.updateHardware()

  def updateHardware(self):
    sendBytes=self.lightStatus.to_bytes(NUM_BUTTON,
                                        byteorder='big')
    print(sendBytes)
    for idx,row in enumerate(MC.MAX7219_DIGIT):
      response = self.matrix.sendCmd(row,sendBytes[idx])
      print(response)

def main():
  global root
  root=TK.Tk()
  root.title("Matrix GUI")
  myMatrixHW=MC.matrix(DEBUG)
  myMatrixGUI=matrixGUI(root,myMatrixHW)
  TK.mainloop()
    
if __name__ == '__main__':
    main()
#End

The Matrix GUI allows us to switch each of the LEDs on/off by clicking on each of the squares (or by directly entering the hexadecimal value) to create the required pattern.

The Matrix GUI to control the 8 x 8 LED matrix

Initially, we defined addresses for each of the control registers used by the MAX7219 device. View the datasheet at for more information.

We created a class called matrix that will allow us to control the module. The __init__() function sets up the SPI of the Raspberry Pi (using SPI_CS as pin 26 CS1 and SPI_SPEED as 100 kHz).

The key function in our matrix class is the sendCmd() function; it uses wiringpi.wiringPiSPIDataRW(SPI_CS,buff) to send buffer (which is the raw byte data that we want to send) over the SPI bus (while also setting the SPI_CS pin low when the transfer occurs). Each command consists of two bytes: the first specifies the address of the register, and the second sets the data that needs to be put into it. To display a row of lights, we send the address of one of the ROW registers (MC.MAX7219_DIGIT) and the bit-pattern we want to display (as a byte).

To initialize the MAX7219, we need to ensure that it is configured in the correct mode. First, we set the Scan Limit field to 7 (which enables all the DIG0 - DIG7 outputs). Next, we disable the built-in digit decoding since we are using the raw output for the display (and don't want it to try to display digits). We also want to ensure that the MAX7219_DISPLAYTEST register is disabled (if enabled, it would turn on all the LEDs).

We ensure the display is cleared by calling our own clear() function, which sends 0 to each of the MAX7219_DIGIT registers to clear each of the rows. Finally, we use the MAX7219_INTENSITY register to set the brightness of the LEDs. The brightness is controlled using a PWM output to make the LEDs appear brighter or darker according to the brightness that is required.

Within the main() function, we perform a quick test to display the letter K on the grid by sending a set of 8 bytes (0x0066763e1e366646).

Each 8 x 8 pattern consists of 8 bits in 8 bytes (one bit for each column, making each byte a row in the display)

The matrixGUI class creates a canvas object that is populated with a grid of rectangle objects to represent the 8 x 8 grid of LEDs we want to control (these are kept in self.light). We also add a text entry box to display the resulting bytes that we will send to the LED matrix module. We then bind the <Button-1> mouse event to the canvas so that mouseClick is called whenever a mouse click occurs within the area of the canvas.

We attach a function called changedCode() to the codeText variable using trace, a special Python function, which allows us to monitor specific variables or functions. If we use the 'w' value with the trace function, the Python system will call the callback function whenever the value is written to.

When the mouseClick() function is called, we use the event.x and event.y coordinates to identify the object that is located there. If an item is detected, then the ID of the item is used (via toggleLight()) to toggle the corresponding bit in the self.lightStatus value, and the color of the light in the display changes accordingly (via setLight()). The codeText variable is also updated with the new hexadecimal representation of the lightStatus value.

The changeCode() function allows us to use the codeText variable and translate it into an integer. This allows us to check whether it is a valid value. Since it is possible to enter text here freely, we must validate it. If we are unable to convert it to an integer, the codeValue text is refreshed using the lightStatus value. Otherwise, we check if it is too large, in which case we perform a bit-shift by four to divide it by 16 until it is within a valid range. We update the lightStatus value, the GUI lights, the codeText variable, and also the hardware (by calling updateHardware()).

The updateHardware() function makes use of the myMatrixHW object that was created using the MC.matrix class. We send the bytes that we want to display to the matrix hardware one byte at a time (along with the corresponding MAX7219_DIGIT value to specify the row).

The SPI bus allows us to control multiple devices on the same bus by using the Chip Enable signal. Some devices, such as the MAX7219, also allow what is known as a daisy-chain SPI configuration.

Daisy-chain SPI configuration

You may have noticed that the matrix class also returns a byte when we send the data on the MOSI line. This is the data output from the MAX7219 controller on the DOUT connection. The MAX7219 controller actually passes all the DIN data through to DOUT, which is one set of instructions behind the DIN data. In this way, the MAX7219 can be daisy-chained (with each DOUT feeding into the next DIN). By keeping the CE signal low, multiple controllers can be loaded with data by being passed though one another. The data is ignored while CE is set to low, the outputs will only be changed when we set it high again. In this way, you can clock in all the data for each of the modules in the chain and then set CE to high to update them:

The daisy-chain SPI configuration

We need to do this for each row that we wish to update (or use MAX7219_NOOP if we want to keep the current row the same). This is known as a daisy-chain SPI configuration, supported by some SPI devices, where data is passed through each device on the SPI bus to the next one, which allows the use of three bus control signals for multiple devices.

The easiest way to connect to the Raspberry Pi via a serial protocol will depend on whether your computer has a built-in serial port or not. The serial connection, software, and test setup are described in the following three steps:

Create the following serialControl.py script:

#!/usr/bin/python3
#serialControl.py
import serial
import time

#Serial Port settings
SERNAME="/dev/ttyUSB0"
#default setting is 9600,8,N,1
IDLE=0; SEND=1; RECEIVE=1

def b2s(message):
  '''Byte to String'''
  return bytes.decode(message)
def s2b(message):
  '''String to Byte'''
  return bytearray(message,"ascii")

class serPort():
  def __init__(self,serName="/dev/ttyAMA0"):
    self.ser = serial.Serial(serName)
    print (self.ser.name)
    print (self.ser)
    self.state=IDLE
  def __enter__(self):
    return self
  def send(self,message):
    if self.state==IDLE and self.ser.isOpen():
      self.state=SEND
      self.ser.write(s2b(message))
      self.state=IDLE

  def receive(self, chars=1, timeout=5, echo=True,
              terminate="
"):
    message=""
    if self.state==IDLE and self.ser.isOpen():
      self.state=RECEIVE
      self.ser.timeout=timeout
      while self.state==RECEIVE:
        echovalue=""
        while self.ser.inWaiting() > 0:
          echovalue += b2s(self.ser.read(chars))
        if echo==True:
          self.ser.write(s2b(echovalue))
        message+=echovalue
        if terminate in message:
          self.state=IDLE
    return message
  def __exit__(self,type,value,traceback):
    self.ser.close()      

def main():
  try:
    with serPort(serName=SERNAME) as mySerialPort:
      mySerialPort.send("Send some data to me!
")
      while True:
        print ("Waiting for input:")
        print (mySerialPort.receive())
  except OSError:
    print ("Check selected port is valid: %s" %serName)
  except KeyboardInterrupt:
    print ("Finished")

if __name__=="__main__":
  main()
#End    

Ensure that the serName element is correct for the serial port we want to use (such as /dev/ttyAMA0 for the GPIO pins or /dev/ttyUSB0 for a USB RS232 adaptor).

Connect the other end to a serial port on your laptop or computer (the serial port can be another USB to RS232 adaptor).

Monitor the serial port on your computer using a serial program such as HyperTerminal or RealTerm () for Windows or Serial Tools for OS X. You will need to ensure that you have the correct COM port set and a baud rate of 9600 bps (Parity=None, Data Bits=8, Stop Bits=1, and Hardware Flow Control=None).

The script will send a request for data from the user and wait for a response.

To send data to the Raspberry Pi, write some text on the other computer and press Enter to send it over to the Raspberry Pi.

You will see output similar to the following on the Raspberry Pi terminal:

The text "Switch on LED 1" has been sent via a USB to RS232 cable from a connected computer

You will also see output similar to the following on the serial monitoring program:

RealTerm displaying typical output from the connected serial port

Press Ctrl + C on the Raspberry Pi to stop the script.

Now, create a GPIO control menu. Create serialMenu.py:

#!/usr/bin/python3
#serialMenu.py
import time
import RPi.GPIO as GPIO
import serialControl as SC
SERNAME = "/dev/ttyUSB0"
running=True

CMD=0;PIN=1;STATE=2;OFF=0;ON=1
GPIO_PINS=[7,11,12,13,15,16,18,22]
GPIO_STATE=["OFF","ON"]
EXIT="EXIT"

def gpioSetup():
  GPIO.setmode(GPIO.BOARD)
  for pin in GPIO_PINS:
    GPIO.setup(pin,GPIO.OUT)

def handleCmd(cmd):
  global running
  commands=cmd.upper()
  commands=commands.split()
  valid=False
  print ("Received: "+ str(commands))
  if len(commands)==3:
    if commands[CMD]=="GPIO":
      for pin in GPIO_PINS:
        if str(pin)==commands[PIN]:
          print ("GPIO pin is valid")
          if GPIO_STATE[OFF]==commands[STATE]:
            print ("Switch GPIO %s %s"% (commands[PIN],
                                         commands[STATE]))
            GPIO.output(pin,OFF)
            valid=True
          elif GPIO_STATE[ON]==commands[STATE]:
            print ("Switch GPIO %s %s"% (commands[PIN],
                                         commands[STATE]))
            GPIO.output(pin,ON)
            valid=True
  elif commands[CMD]==EXIT:
    print("Exit")
    valid=True
    running=False
  if valid==False:
    print ("Received command is invalid")
    response="  Invalid:GPIO Pin#(%s) %s
"% (
                      str(GPIO_PINS), str(GPIO_STATE))
  else:
    response="  OK
"
  return (response)

def main():
  try:
    gpioSetup()
    with SC.serPort(serName=SERNAME) as mySerialPort:
      mySerialPort.send("
")
      mySerialPort.send("  GPIO Serial Control
")
      mySerialPort.send("  -------------------
")
      mySerialPort.send("  CMD PIN STATE "+
                        "[GPIO Pin# ON]
")
      while running==True:
        print ("Waiting for command...")
        mySerialPort.send(">>")
        cmd = mySerialPort.receive(terminate="
")
        response=handleCmd(cmd)
        mySerialPort.send(response)
      mySerialPort.send("  Finished!
")
  except OSError:
    print ("Check selected port is valid: %s" %serName)
  except KeyboardInterrupt:
    print ("Finished")
  finally:
    GPIO.cleanup()

main()
#End

When you run the script (sudo python3 serialMenu.py), type the control messages within the serial monitoring program:

The GPIO Serial Control menu

The terminal output on the Raspberry Pi will be similar to the following screenshot, and the LEDs should respond accordingly:

The GPIO Serial Control menu

The Raspberry Pi validates the commands received from the serial connection and switches the LEDs connected to the GPIO pins 7 and 11 on and then off.

The first script, serialControl.py, provides us with a serPort class. We define the class with the following functions:

The main() function in the script performs a quick test of the class by sending a prompt for data through the serial port to a connected computer and then waiting for input that will be followed by the terminate character(s).

The next script, serialMenu.py, allows us to make use of the serPort class.

The main() function sets up the GPIO pins as outputs (via gpioSetup()), creates a new serPort object, and finally, waits for commands through the serial port. Whenever a new command is received, the handleCmd() function is used to parse the message to ensure that it is correct before acting on it.

The script will switch a particular GPIO pin on or off as commanded through the serial port using the GPIO command keyword. We could add any number of command keywords and control (or read) whatever device (or devices) we attached to the Raspberry Pi. We now have a very effective way to control the Raspberry Pi using any devices connected via a serial link.

In addition to the serial transmit and receive, the RS232 serial standard includes several other control signals. To test it, you can use a serial loopback to confirm if the serial ports are set up correctly.

dmesg | grep tty

[ 2409.195407] usb 1-1.2: pl2303 converter now attached to ttyUSB0

RS232 signals and connections

The RS232 serial standard has lots of variants and includes six additional control signals.

The Raspberry Pi GPIO serial drivers (and the Bluetooth TTL module used in the following example) only support RX and TX signals. If you require support for other signals, such as DTR that is often used for a reset prior to the programming of AVR/Arduino devices, then alternative GPIO serial drivers may be needed to set these signals via other GPIO pins. Most RS232 to USB adaptors should support the standard signals; however, ensure that anything you connect is able to handle standard RS232 voltages:

The RS232 9-Way D Connector pin-out and signals

For more details on the RS232 serial protocol and to know how these signals are used, visit the following link http://en.wikipedia.org/wiki/Serial_port:

Using the GPIO built-in serial pins

Standard RS232 signals can range from -15V to +15V, so you must never directly connect any RS232 device to the GPIO serial pins. You must use an RS232 to TTL voltage-level converter (such as a MAX232 chip) or a device that uses TTL-level signals (such as another microcontroller or a TTL serial console cable):

A USB to TTL serial console cable

The Raspberry Pi has TTL-level serial pins on the GPIO header that allow the connection of a TTL serial USB cable. The wires will connect to the Raspberry Pi GPIO pins, and the USB will plug in to your computer and be detected like a standard RS232 to USB cable.

Connection of a USB to TTL serial console cable to the Raspberry Pi GPIO

It is possible to provide power from the USB port to the 5V pin; however, this will bypass the built-in polyfuse, so it is not recommended for general use (just leave the 5V wire disconnected and power as normal through the micro-USB).

By default, these pins are set up to allow remote terminal access, allowing you to connect to the COM port via PuTTY and create a serial SSH session.

Note

A serial SSH session can be helpful if you want to use the Raspberry Pi without a display attached to it.

However, a serial SSH session is limited to text-only terminal access since it does not support X10 Forwarding, as used in the Connecting remotely to Raspberry Pi over the network using SSH (and X11 Forwarding) section of Chapter 1, Getting Started with a Raspberry Pi Computer.

In order to use it as a standard serial connection, we have to disable the serial console so it is available for us to use.

First, we need to edit /boot/cmdline.txt to remove the first console and kgboc options (do not remove the other console=tty1 option, which is the default terminal when you switch on):

sudo nano /boot/cmdline.txt
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

The previous command line becomes the following (ensure that this is still a single command line):

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

We also have to remove the task that runs the getty command (the program that handles the text terminal for the serial connection) by commenting it out with #. This is set in /etc/inittab as follows:

sudo nano /etc/inittab
T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

The previous command line becomes the following:

#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

To reference the GPIO serial port in our script, we use its name, /dev/ttyAMA0.

The RS232 loopback

You can check whether the serial port connections are working correctly using a serial loopback.

A simple loopback consists of connecting RXD and TXD together. These are pins 8 and 10 on the Raspberry Pi GPIO header, or pins 2 and 3 on the standard RS232 D9 connector on the USB-RS232 adaptor:

Serial loopback connections to test the Raspberry Pi GPIO (left) and RS232 9-Way D Connector (right)

An RS232 full loopback cable also connects pin 4 (DTR) and pin 6 (DSR) as well as pin 7 (RTS) and pin 8 (CTS) on the RS232 adaptor. However, this is not required for most situations, unless these signals are used. By default, no pins are allocated on the Raspberry Pi specifically for these additional signals.

RS232 full loopback

Create the following serialTest.py script:

#!/usr/bin/python3
#serialTest.py
import serial
import time

WAITTIME=1
serName="/dev/ttyAMA0"
ser = serial.Serial(serName)
print (ser.name)
print (ser)
if ser.isOpen():
  try:
    print("For Serial Loopback - connect GPIO Pin8 and Pin10")
    print("[Type Message and Press Enter to continue]")
    print("#:")
    command=input()
    ser.write(bytearray(command+"
","ascii"))
    time.sleep(WAITTIME)
    out=""
    while ser.inWaiting() > 0:
      out += bytes.decode(ser.read(1))
    if out != "":
      print (">>" + out)
    else:
      print ("No data Received")
  except KeyboardInterrupt:
    ser.close()
#End

When a loopback is connected, you will observe that the message is echoed back to the screen (when removed, No data Received will be displayed):

An RS232 loopback test on GPIO serial pins

If we require non-default settings, they can be defined when the serial port is initialized (the pySerial documentation at https://pyserial.readthedocs.io/en/latest/ provides full details of all the options), as shown in the following code:

ser = serial.Serial(port=serName, baudrate= 115200, 
    timeout=1, parity=serial.PARITY_ODD,
    stopbits=serial.STOPBITS_TWO,
    bytesize=serial.SEVENBITS)

Ensure that the serial console has been disabled (see the previous There's more… section).

The module should be connected using the following pins:

Connection to a Bluetooth module for the TLL serial

With the Bluetooth module configured and connected, we can pair the module with a laptop or smartphone to send and receive commands wirelessly. Bluetooth SPP Pro provides an easy way to use a serial connection over Bluetooth to control or monitor the Raspberry Pi for Android devices.

Alternatively, you may be able to set up a Bluetooth COM port on your PC/laptop and use it in the same way as the previous wired example:

We can see from the output in the following screenshot that the commands have been received and the LED connected to pin 12 has been switched on and off as required.

The Raspberry Pi receiving GPIO control over Bluetooth

By default, the Bluetooth module is set up to act like a TTL serial slave device, so we can simply plug it in to the GPIO RX and TX pins. Once the module is paired with a device, it will transfer the serial communication over the Bluetooth connection. This allows us to send commands and receive data via Bluetooth and control the Raspberry Pi using a smart phone or PC.

This means you can attach a second module to another device (such as an Arduino) that has TTL serial pins and control it using the Raspberry Pi (either by pairing it with another TTL Bluetooth module or suitably configuring a USB Bluetooth dongle). If the module is set up as a master device, then you will need to reconfigure it to act as a slave (see the There's more… section).

Now, let's understand how to configure the Bluetooth settings.

python3 -m serial.tools.miniterm

Enter port name: /dev/ttyAMA0

We will need to install PyUSB for Python 3 using pip-3.2 as follows:

sudo pip-3.2 install pyusb

You can test whether PyUSB has installed correctly by running the following:

python3
> import usb
> help (usb)
> exit()

This should allow you to view the package information if it was installed correctly.

We will create the following missileControl.py script, which will include two classes and a default main() function to test it:

When the script is run using the following command, you should see the missile launcher move downwards and then up again:

sudo python3 missileControl.py

To provide easy control of the device, create the following GUI:

The Missile Command GUI

Although simple commands have been used here, you could use a series of preset commands if desired.

Create the GUI for the missileMenu.py missile command:

#!/usr/bin/python3
#missileMenu.py
import tkinter as TK
import missileControl as MC

BTN_SIZE=10

def menuInit():
  btnLeft = TK.Button(root, text="Left",
                      command=sendLeft, width=BTN_SIZE)   
  btnRight = TK.Button(root, text="Right",
                       command=sendRight, width=BTN_SIZE)   
  btnUp = TK.Button(root, text="Up",
                    command=sendUp, width=BTN_SIZE)   
  btnDown = TK.Button(root, text="Down",
                      command=sendDown, width=BTN_SIZE)
  btnFire = TK.Button(root, text="Fire",command=sendFire,
                      width=BTN_SIZE, bg="red")
  btnLeft.grid(row=2,column=0)
  btnRight.grid(row=2,column=2)
  btnUp.grid(row=1,column=1)
  btnDown.grid(row=3,column=1)
  btnFire.grid(row=2,column=1)

def sendLeft():
  print("Left")
  myMissile.left()
       
def sendRight():
  print("Right")    
  myMissile.right()
       
def sendUp():
  print("Up")
  myMissile.up()
       
def sendDown():
  print("Down")
  myMissile.down()
       
def sendFire():
  print("Fire")
  myMissile.fire()
       

root = TK.Tk()
root.title("Missile Command")
prompt = "Select action"
label1 = TK.Label(root, text=prompt, width=len(prompt),
                  justify=TK.CENTER, bg='lightblue')
label1.grid(row=0,column=0,columnspan=3)
menuInit()
with MC.Missile() as myMissile:
  root.mainloop()
#End

The control script consists of two classes: one called Missile that provides a common interface for the control, and another called SamMissile that provides all the specific details of the particular USB device being used.

In order to drive a USB device, we need a lot of information about the device, such as its USB identification, its protocol, and the control messages it requires to be controlled.

The USB ID for the Tenx Technology SAM missile device is determined by the vendor ID (0x1130) and the product ID (0x0202). This is the same identification information you would see within Device Manager in Windows. These IDs are usually registered with www.usb.org; therefore, each device should be unique. Again, you can use the dmesg | grep usb command to discover these.

We use the device IDs to find the USB device using usb.core.find; then, we can send messages using ctrl_transfer().

The USB message has five parts:

The SamMissile device requires the following commands to move:

You will see that the other missile devices and the robot arm (see the following There's more… section) have similar message structures.

For each device, we created the __init__() and move() functions and defined values for each of the valid commands, which the missile class will use whenever the left(), right(), up(), down(), fire(), and stop() functions are called.

For the control GUI for our missile launcher, we create a small Tkinter window with five buttons, each of which will send a command to the missile device.

We import missileControl and create a missile object called myMissile that will be controlled by each of the buttons.

The example only shows how to control one particular USB device; however, it is possible to extend this to support several types of missile devices and even other USB devices in general.

class ChesenMissile():
  idVendor=0x0a81
  idProduct=0x0701
  idName="Chesen Electronics/Dream Link"
  # Protocol control bytes
  bmRequestType=0x21
  bmRequest=0x09
  wValue=0x0200
  wIndex=0x00
  # Protocol command bytes
  DOWN    = [0x01]
  UP      = [0x02]
  LEFT    = [0x04]
  RIGHT   = [0x08]
  FIRE    = [0x10]
  STOP    = [0x20]
  def __init__(self):
    self.dev = usb.core.find(idVendor=self.idVendor,
                             idProduct=self.idProduct)
  def move(self,cmd,duration):
    print("Move:%s"%cmd)
    self.dev.ctrl_transfer(self.bmRequestType,
                           self.bmRequest,
                           self.wValue, self.wIndex, cmd)
    time.sleep(duration)
    self.dev.ctrl_transfer(self.bmRequestType,
                           self.bmRequest, self.wValue,
                           self.wIndex, self.STOP)

class ThunderMissile():
  idVendor=0x2123
  idProduct=0x1010
  idName="Dream Cheeky Thunder"
  # Protocol control bytes
  bmRequestType=0x21
  bmRequest=0x09
  wValue=0x00
  wIndex=0x00
  # Protocol command bytes
  CMDFILL = [0,0,0,0,0,0]
  DOWN    = [0x02,0x01]
  UP      = [0x02,0x02]
  LEFT    = [0x02,0x04]
  RIGHT   = [0x02,0x08]
  FIRE    = [0x02,0x10]
  STOP    = [0x02,0x20]
  def __init__(self):
    self.dev = usb.core.find(idVendor=self.idVendor,
                             idProduct=self.idProduct)
  def move(self,cmd,duration):
    print("Move:%s"%cmd)
    self.dev.ctrl_transfer(self.bmRequestType,
                           self.bmRequest, self.wValue,
                           self.wIndex, cmd+self.CMDFILL)
    time.sleep(duration)
    self.dev.ctrl_transfer(self.bmRequestType,
                      self.bmRequest, self.wValue,
                      self.wIndex, self.STOP+self.CMDFILL)

class Missile():
  def __init__(self):
    print("Initialize Missiles")
    self.usbDevice = ThunderMissile()

Robot arm

Another device that can be controlled in a similar manner is the OWI Robotic Arm with a USB interface.

The OWI Robotic Arm with a USB interface (image courtesy of Chris Stagg)

This has featured in The MagPi magazine several times, thanks to Stephen Richards' articles on Skutter; the USB control has been explained in detail in issue 3 (page 14) at https://issuu.com/themagpi/docs/the_magpi_issue_3_final/14. It can also be found at https://www.raspberrypi.org/magpi/issues/3/.

The robotic arm can be controlled using the following class. Remember that you will also need to adjust the commands from UP, DOWN, and so on when calling the move() function, as shown in the following code:

class OwiArm():
  idVendor=0x1267
  idProduct=0x0000
  idName="Owi Robot Arm"
  # Protocol control bytes
  bmRequestType=0x40
  bmRequest=0x06
  wValue=0x0100
  wIndex=0x00
  # Protocol command bytes
  BASE_CCW    = [0x00,0x01,0x00]
  BASE_CW     = [0x00,0x02,0x00]
  SHOLDER_UP  = [0x40,0x00,0x00]
  SHOLDER_DWN = [0x80,0x00,0x00]
  ELBOW_UP    = [0x10,0x00,0x00]
  ELBOW_DWN   = [0x20,0x00,0x00]
  WRIST_UP    = [0x04,0x00,0x00]
  WRIST_DOWN  = [0x08,0x00,0x00]
  GRIP_OPEN   = [0x02,0x00,0x00]
  GRIP_CLOSE  = [0x01,0x00,0x00]
  LIGHT_ON    = [0x00,0x00,0x01]
  LIGHT_OFF   = [0x00,0x00,0x00]
  STOP        = [0x00,0x00,0x00]