arduino – TILT!Audio

Using a Arduino mini pro as extension to a TILT!Audio board, you can easily control a shaker motor via pwm (pulse width modulation).

First we need a motor driver module that is capable of driving the high current motor power. e.g. something like this:

The picture is more or less self-explaining the only thing that need to be connected to the Arduino mini pro is the GND / PWM input.

Now looking at the Arduino mini pro we use pin 5 as pwm output and to connect to the TILT!Audio board we use the i2c bus the is controlled by the SCL / SDC pins (together with GND / Vcc of course):

Be sure to choose a 5v type for Arduino mini pro as there are also available in 3.3v but the TILT!Audio connector for the i2c bus provides 5v. Also the 5v type runs on 16Mhz instead of only 8Mhz for 3.3v with is also good.

So connections are:

From	To
TA-Board: GND	GND (right side)
TA-Board: Vcc	VCC (right side)
TA-Board: SDA	SDA (green)
TA-Board: SCL	SCL (green)
Arduino: GND	Power Driver: GND (right)
Arduino: Pin5 (PWM)	Power Driver: PWM (right)

Now we create a script for the Arduino mini pro like this (see https://github.com/sker65/tiltaudio-extensions). We start with initial setup stuff:

#include <Wire.h>

#define I2C_MSG_IN_SIZE    2
#define I2C_MSG_OUT_SIZE   4
#define I2C_ADDRESS 0x61
#define PWM_PIN 5

void setup() {
  // init i2c bus
  Wire.begin(I2C_ADDRESS);
  Wire.onReceive(receiveEvent);
  // not used Wire.onRequest(requestEvent);
  // init PWN output
  pinMode(PWM_PIN, OUTPUT);
}

#include <Wire.h>

#define I2C_MSG_IN_SIZE 2

#define I2C_MSG_OUT_SIZE 4

#define I2C_ADDRESS 0x61

#define PWM_PIN 5

void setup() {

// init i2c bus

Wire.begin(I2C_ADDRESS);

Wire.onReceive(receiveEvent);

// not used Wire.onRequest(requestEvent);

// init PWN output

pinMode(PWM_PIN, OUTPUT);

}

First thing we do is switch shaker on, off and set speed (within a limited range to not make to pinball machine jump):

int currentSpeed = 1;
int maxSpeed = 20;

void off() {
   analogWrite( PWM_PIN, 0 );
}

void on() {
   analogWrite( PWM_PIN, currentSpeed );
}

void setSpeed( int speed ) {
  if( speed > 0 && speed <= maxSpeed ) {
    currentSpeed = speed;
  }
  on();
}

int currentSpeed = 1;

int maxSpeed = 20;

void off() {

analogWrite( PWM_PIN, 0 );

}

void on() {

analogWrite( PWM_PIN, currentSpeed );

}

void setSpeed( int speed ) {

if( speed > 0 && speed <= maxSpeed ) {

currentSpeed = speed;

}

on();

}

Second we wire these functions to i2c control:

void receiveEvent(int count)
{
  if (count == I2C_MSG_IN_SIZE)
  {
    byte cmd = Wire.read();
    byte value = Wire.read();
    switch( cmd ) {
      case 0x01:
        on();
        break;
      case 0x02:
        off();
        break;
      case 0x03:
        setSpeed(value);
        break;
      default:
        // unknown command
    }
  }
}

void receiveEvent(int count)

{

if (count == I2C_MSG_IN_SIZE)

{

byte cmd = Wire.read();

byte value = Wire.read();

switch( cmd ) {

case 0x01:

on();

break;

case 0x02:

off();

break;

case 0x03:

setSpeed(value);

break;

default:

// unknown command

}

And additionally we can create “sequences”. A sequence would play back some schema of on and off or speed up and speed downs. The idea is to define a sequence as 3 integers: command byte, value, interval in milliseconds. We define these commands:

0x00: stop -> end of the sequence
0x01: switch on, value -> speed
0x02: switch off, value -> don’t matter
0x03: ramp up, value -> target speed at end of interval

We delegate playing those sequences to the Arduino and later just trigger it from the TILT!Audio board by sending some command to the i2c bus:

#define END 0x00
#define ON 0x01
#define OFF 0x02
#define RAMP 0x03
#define SETSPEED 0x04
#define PLAYSEQ 0x05

int sequences[] = { ON, 5, 500, OFF, 0, 500, ON, 5, 500, END };
int* seqPtr = NULL;

unsigned long nextAction = 0; // timer marker for next action
float rampInc;                // speed incs for ramps in steps
int rampNo = 0;               // counts number of step in ramp phase

void loop() {
  unsigned long now = millis();
  if( now > nextAction ) {

    // ramp active
    if( rampNo > 0 ) {
      nextAction = now + 50;
      setSpeed( currentSpeed + rampInc );
      rampNo--;
    } else {
      // read next command from sequence
      int cmd = *seqPtr++;
      if( cmd == END ) {
        seqPtr = NULL; // end of sequence
        nextAction = 0;
      } else {
        int val = *seqPtr++;
        int delay = *seqPtr++;
        nextAction = now + delay;
        switch(cmd) {
          case ON:  setSpeed(val); break;
          case OFF: off(); break;
          case RAMP:
            rampNo = delay / 50; // inc every 50ms
            nextAction = now + 50;
            rampInc = (val - currentSpeed) / (float) rampNo; 
        }
      }
    }
  }
}

#define END 0x00

#define ON 0x01

#define OFF 0x02

#define RAMP 0x03

#define SETSPEED 0x04

#define PLAYSEQ 0x05

int sequences[] = { ON, 5, 500, OFF, 0, 500, ON, 5, 500, END };

int* seqPtr = NULL;

unsigned long nextAction = 0; // timer marker for next action

float rampInc; // speed incs for ramps in steps

int rampNo = 0; // counts number of step in ramp phase

void loop() {

unsigned long now = millis();

if( now > nextAction ) {

// ramp active

if( rampNo > 0 ) {

nextAction = now + 50;

setSpeed( currentSpeed + rampInc );

rampNo--;

} else {

// read next command from sequence

int cmd = *seqPtr++;

if( cmd == END ) {

seqPtr = NULL; // end of sequence

nextAction = 0;

} else {

int val = *seqPtr++;

int delay = *seqPtr++;

nextAction = now + delay;

switch(cmd) {

case ON: setSpeed(val); break;

case OFF: off(); break;

case RAMP:

rampNo = delay / 50; // inc every 50ms

nextAction = now + 50;

rampInc = (val - currentSpeed) / (float) rampNo;

}

And again create a function that triggers the sequence playback and wire it to i2c control:

void playSequence( int startIndex ) {
  if( startIndex >= 0 && startIndex < sizeOfSequences ) {
    seqIdx = startIndex;
    nextAction = millis();
  }
}

// add another case in receiveEvent

      case PLAYSEQ:
        playSequence(value);
        break;

void playSequence( int startIndex ) {

if( startIndex >= 0 && startIndex < sizeOfSequences ) {

seqIdx = startIndex;

nextAction = millis();

}

// add another case in receiveEvent

case PLAYSEQ:

playSequence(value);

break;

Find the complete example on github.

To get an idea, how it finally will play all together I did a test installation:

In order to test your TILTAudio board including the WPC bus interface to the pinball machine you can use an arduino mega board.

Just connect the mega with the TILT!Audio board like this:

Connections from the Arduino mega to WPC bus on TILT!Audio

Connecting also the 5v power line is optional. You need to choose either to power everything from on source or just skip the red 5v wire and power the 5v on the TA board and the Arduino separately.

For the address decoder (the smd chips) to work the raspberry pi needs to be plugged in as the 3v3 power for the decoder comes from the pi’s onboard regulator.

Also the resistor network RN3-5 must be installed, without them bus connections are not there. 12V can be skipped for testing, which means amps will not work, but you could also connect a speaker either to the PI’s audio jack directly or use the audio jack on the DAC module.

Then load the following ino script to the Arduino:

void setup() {
   // set gpio mode
   DDRC = 255; // switch port c completely to output
   DDRA = 255; // switch port a completely to output
   PORTA = 255; // high
   PORTC = 255; // high
   pinMode(LED_BUILTIN, OUTPUT);
}
int data[] = { 0x01, 0x20, 0, 0 };
int ledState = 0;
void play(int start, int end ) {
   for( int i = start; i <= end; i++ ) {
     delayMicroseconds(900);
     PORTA = data[i];
     PORTC = 0b01011100;      // sound address + rw = low, with wden high
     delayMicroseconds(20);
     PORTC = 0b00011100;      // sound address + rw = low, with wden low
     delayMicroseconds(30);
     PORTC = 0b01011100;      // sound address + rw = low, with wden high
   }
}
void toggleLed() {
   digitalWrite(LED_BUILTIN, ledState);
   ledState = !ledState;
}

void loop() {
  play(0,1);
  delay(2000);
  toggleLed();
  data[2] = random(4);
  data[3] = random(256);
  play(2,3);
  delay(4000);
}

void setup() {

// set gpio mode

DDRC = 255; // switch port c completely to output

DDRA = 255; // switch port a completely to output

PORTA = 255; // high

PORTC = 255; // high

pinMode(LED_BUILTIN, OUTPUT);

}

int data[] = { 0x01, 0x20, 0, 0 };

int ledState = 0;

void play(int start, int end ) {

for( int i = start; i <= end; i++ ) {

delayMicroseconds(900);

PORTA = data[i];

PORTC = 0b01011100; // sound address + rw = low, with wden high

delayMicroseconds(20);

PORTC = 0b00011100; // sound address + rw = low, with wden low

delayMicroseconds(30);

PORTC = 0b01011100; // sound address + rw = low, with wden high

}

void toggleLed() {

digitalWrite(LED_BUILTIN, ledState);

ledState = !ledState;

}

void loop() {

play(0,1);

delay(2000);

toggleLed();

data[2] = random(4);

data[3] = random(256);

play(2,3);

delay(4000);

}

This way you can emulate sound effect commands to would normally come from the pinball machine.

I will upload a more detailed example on the github repo: https://github.com/sker65/tiltaudio-extensions

Connections needed:

Arduino	TILT!Audio
PA0:22	CD0 wpc15
PA1:23	CD1 wpc13
PA2:24	CD2 wpc11
PA3:25	CD3 wpc9
PA4:26	CD4 wpc7
PA5:27	CD5 wpc5
PA6:28	CD6 wpc3
PA7:29	CD7 wpc1
PC0:37	CA0 wpc25
PC1:36	CA1 wpc23
PC2:35	CA2 wpc21
PC3:34	CA3 wpc19
PC4:33	CA4 wpc17
PC5:32	RW:wpc31
PC6:31	WDEN:wpc29
GND	GND

Tag: arduino

Shaker control with pwm

Test a TILT!Audio board