Have you seen those dynamo torches, the ones that you repeatedly squeeze to light three white LEDs? Well, this month we are going to take a pair of these and turn them into a unique games controller. A new type of controller offers the possibility of new types of games, or a better way to control some existing types of games.

This tutorial was written by Mike Cook and first appeared in The MagPi issue #83. Subscribe in print for 12-months and get a free Raspberry Pi.

Hack a dynamo torch

The torch, or flashlight for our American cousins, can come in many forms. These days there are lots of self-powering devices which involve actually generating the power needed to drive them by the efforts of the user. With a dynamo torch, the user repeatedly squeezes a lever to spin a magnet in a coil and generate electricity. We took one apart and measured the voltage the generator produced. As you can see in Figure 1, the output is AC with a peak-to-peak voltage of almost 80 V; when squeezed, the frequency rapidly rises to about 170Hz.

You'll need

• Two dynamo torches
• A/D converter (ADC), e.g. MCP3008
• Assorted electronic components

Warning! High voltage

The dynamo torches in this project can produce high voltage, so be careful. This voltage is very high, but is loaded down by putting a white LED across it; this shorts the negative voltage and limits the positive voltage to about 3 V, which is the forward voltage drop across the LED. This is a cheap and nasty design. You can pump the leaver to sustain a voltage or just squeeze once for a pulse, as shown in Figure 2. This shows 24 rapid squeezes followed by a single squeeze and release; it is measured over five seconds. Note how the trace is changing so rapidly that we can’t see the individual waveform, only the envelope.

Conditioning the signal

The idea is that we can condition this signal to make a games controller. Basically, we need to make it into a DC signal by adding a series diode and then getting just the peaks of this signal with an envelope follower, which is sometimes called a peak detector. This uses a capacitor to hold the peak voltage and a discharging resistor which controls the release of the peak. The schematic for this is shown in Figure 3. When the signal is passed through this circuit, you get the waveform shown in Figure 4. You will need two of these circuits.

Building the circuit

We used a piece of 14 hole, by 10 row, stripboard and a single pin header row. This plugs into our ADC (see issue 68, page 42), component side down. The components were wired up as in Figure 5. Note that the track side shows where to cut the tracks and is flipped over right to left, just like you would see it. Figure 6 shows a photograph of the conditioning circuit. The band on the diode marks the cathode, and the strip down the capacitor marks the negative wire. Make sure you get them the right way round.

Hacking the torch

First off, drill a 2 mm hole in the body of the torch, close to the front, as shown in Figure 7. Then flip off the front cover and pull out the LED and battery assembly (Figure 8). Be careful, because some of the wires are very thin and you don’t want to snap them. Undo the two tiny screws holding the battery cover and remove the batteries. Now insert a length of 1.5 mm screened cable through the hole you previously drilled and strip off a 20 mm length at the end. Gather up the screen, twist it, and tin it.

Finishing off the torch

Use the cable’s sleeving (that you cut off) to insulate the twisted screening and solder this to the sleeved side of the LEDs (Figure 9). Then solder the core to the other side of the LED. Cut off the wire that used to go to the top of the battery housing and give all those long wires from the LED a bit of a trim. Glue the plastic lenses to the inside of the cover and slowly pull the cable back out of the torch. Fix the cable with a dab of hot-melt glue on the inside, before clipping the cover back in place.

Tug of War

What better way to show off a new interface than with a new game? So in the TugOfWar.py listing you will find our new, two-player, ‘Tug of War’ game especially designed for this interface. Figure 10 shows the game in progress. The central meter shows the target, which is the reading you are aiming for. If your player’s input is the closest to the target and is also within ten of the target, the rope is nudged in your direction. The first player to pull the rope over the finishing point is the winner. Pressing the SPACE bar starts another game.

A look at the code

The code follows the normal Pygame structure, and requires three images: rope, knot, and meter. It also requires a start sound and end sound. To smooth the input, a running average of the voltage readings is used. The scale variable is a sort of fiddle factor that allows you to adjust the output, so that you can get maximum meter deflection at the peak value from the torch. The checkTarget function will change the target you are aiming for at random intervals, to make the game a bit more challenging, so you need to look at the target and your input.

Tip! Glue up the switch

The switch on the torch that was used to change over to battery operation, once it has been modified, disconnects the torch output. We found that this got knocked occasionally, leaving us to believe that the interface had stopped working. So we used polystyrene cement to make sure the output was always switched on.

Tip! Removing the torch front

This can be tricky, but with a flat-blade screwdriver and some determination it can be removed. Mind that you don’t stab yourself with the screwdriver – always push away from your body.

In conclusion

We hope you have fun with this. Another good game to implement using this interface would be a SpaceX rocket landing game similar to the classic Lunar Lander. However, in our next tutorial we will show you how to use this interface to make a rather large LED Racer game.

#!/usr/bin/env python3
#Tug of war using squeeze controller
# By Mike Cook June 2019

import math, spidev, time
import os, pygame, sys, random

pygame.init()
pygame.mixer.quit()
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)   
os.environ['SDL_VIDEO_WINDOW_POS'] = 'center'
pygame.display.set_caption("Tug of War")
pygame.event.set_allowed(None)
pygame.event.set_allowed([pygame.KEYDOWN,pygame.QUIT])
screenWidth = 960 ; screenHight = 280 ; cp = screenWidth // 2
screen = pygame.display.set_mode([screenWidth,screenHight],0,32)
textHeight=22 ; font = pygame.font.Font(None, textHeight)
backCol = (160,160,160)
lastValue = [-10, -10, -10] # so you show on the first reading
screenUpdate = True ; random.seed()
nAv = 10 # number of samples to average
avPoint = [0,0,0] ; p1 = [0] * nAv ; p2 = [0] * nAv
runningAv = [p1,p2,[0]] ; average = [0.] * 3
target = 0.5 ; timeChange = 0 ; scale = 700

def main():
  global tugState, gameOver, winner
  print("Tug of War")
  init()
  while(1): # do forever
    timeChange = 0
    tugState = -cp # middle of screen   
    checkTarget()
    gameOver = False
    winner = -1 # no winer yet
    whistle.play() # start sound
    time.sleep(2.0)
    while not gameOver:
       checkForEvent()
       readVoltage()
       checkTug()
       checkTarget()
       if screenUpdate :
          drawScreen() 
          updateMeters()
    if winner == 0:      
       print("Blue Player is the winner")
       drawWords("Winner        ",123,159,(0,0,0),(20,178,155))
    else:   
       print("Yellow Player is the winner")
       drawWords("Winner            ",742,159,(0,0,0),
(20,178,155))
    pygame.display.update()
    end.play() # end sound
    print("Press space for another game")
    time.sleep(3.0)
    while gameOver:
      checkForEvent()
    
def checkTug():
  global tugState,screenUpdate,gameOver,winner
  #check to see if anyone has won
  if tugState <= -869:
    gameOver = True
    winner = 0
    return
  if tugState >= -37:
    gameOver = True
    winner = 1
    return
  #check to see if anyone has scored
  p1 = abs(average[0] - average[2])
  p2 = abs(average[1] - average[2])
  if p1 < p2 : #player 1 closest
    if p1 < 40:
      tugState -= 1
      screenUpdate = True
  else:
    if p2 < 40:
      tugState += 1
      screenUpdate = True       

def checkTarget():
   global target, timeChange
   if time.time() < timeChange:
      return
   temp = random.uniform(0.2,0.8) 
   target = int(temp*scale) 
   average[2] = target
   timeChange = time.time() + random.uniform(3.2,6.8)
   drawScreen()
   updateMeters()
   
def drawScreen():
   screen.fill(backCol)
   for i in range(0,3):
      screen.blit(meter, (meterPositionX[i],
meterPositionY[i]) )
   screen.blit(rope, (tugState,190) )
   drawWords("Target",447,159,(0,0,0),(20,178,155))
   drawWords("Blue Player",123,159,(0,0,0),
(20,178,155))
   drawWords("Yellow Player",742,159,(0,0,0),
(20,178,155))
   pygame.draw.line(screen,(0,0,0),(64,188),
(64,272),4)
   pygame.draw.line(screen,(0,0,0),(896,188),
(896,272),4)
   pygame.display.update()

def drawWords(words,x,y,col,backCol) :
    textSurface = font.render(
words, True, col, backCol)
    textRect = textSurface.get_rect()
    textRect.left = x # right for align right
    textRect.top = y    
    screen.blit(textSurface, textRect)
    return textRect
   
def init():
    global meter, rope, meterPositionX, meterPositionY, spi,whistle, end
    whistle = pygame.mixer.Sound("sounds/whistle.ogg")
    end = pygame.mixer.Sound("sounds/end.ogg")
    meter = pygame.image.load(
"images/MeterPC.png").convert_alpha()
    rope = pygame.image.load(
"images/rope.png").convert_alpha()
    meterPositionX=[10,638,324]
    meterPositionY=[10,10,10]
    spi = spidev.SpiDev()
    spi.open(0,0)
    spi.max_speed_hz=1000000     
    
def readVoltage():
   global screenUpdate, average, avPoint,lastValue, runningAv
   for i in range(0,2):
      adc = spi.xfer2([1,(8+i)<<4,0]) # request channel
      reading = (adc[1] & 3)<<8 | adc[2] # join two bytes together
      runningAv[i][avPoint[i]] = reading
      avPoint[i]+=1
      if avPoint[i] >= nAv:
        avPoint[i] = 0
      average[i] =  0 
      for j in range(0,nAv): # calculate new running average
         average[i] += runningAv[i][j]
      average[i] = average[i] / nAv      
      if abs(lastValue[i] - average[i]) > 8 or (
average[i] == 0 and lastValue[i] !=0):
         lastValue[i] = average[i]
         screenUpdate = True      

def updateMeters():
    global screenUpdate, average
    for i in range(0,3):
       plot = constrain(average[i]/scale,0.0,1.0)
       angle = (math.pi * ((-plot))) + 
(1.0 * math.pi)
       mpX = 146 + meterPositionX[i]
       mpY = 146 + meterPositionY[i]
       dx = mpX + 140 * math.cos(angle) 
       dy = mpY - 140 * math.sin(angle) 
       pygame.draw.line(screen,(50,50,50),(mpX,mpY),
(dx,dy),2)
       screenUpdate = False
    pygame.display.update()
    
def constrain(val, min_val, max_val):
    return min(max_val, max(min_val, val))
  
def terminate(): # close down the program
    print ("Closing down")
    pygame.mixer.quit()
    pygame.quit() # close pygame
    os._exit(1)
    
def checkForEvent(): # see if we need to quit
    global reading, screenUpdate, average, gameOver
    event = pygame.event.poll()
    if event.type == pygame.QUIT :
         terminate()
    if event.type == pygame.KEYDOWN :
       if event.key == pygame.K_ESCAPE :
          terminate()
       if event.key == pygame.K_SPACE :
          gameOver = False

if __name__ == '__main__':
    main()