The Arduino Motor shield comes with TinkerKit! connectors on the board. They can be used to control inputs, outputs and TWI TinkerKit! devices. In this tutorial we’ll be driving a DC motor with a potentiometer, changing its direction and even printing the output values on an LCD.

In order to see the rotation of the DC motor, we designed a blade, that you can download here, and a base. Basically the support is a piece of wood to which we drilled two holes, one for the motor and one for the cables.

Then we plugged the DC motor’s cables into the A port of the motor shield. Polarity is not important with DC motors, so you can plug plus and minus in any order.

In order to control the motor without TinkerKit!, we need to use two pins of the shield, one for direction and one for speed. To find out the number of the pins, we followed the Arduino Motor Shield Documentation. We can even brake using pin number 9. So this is our first code, to make it spin in one direction:

void setup() {
   //Setup Channel A
  pinMode(12, OUTPUT); //Initiates Motor Channel A
  pinMode(9, OUTPUT); //Initiates Brake Channel A

  digitalWrite(9, LOW);   //Disengage the Brake
  
  digitalWrite(12, LOW);   //Set direction
  analogWrite(3, 255);   //Channel A at full speed
}

void loop() {
}

On the pin 12 we write HIGH or LOW to make it spin left or right. Now we can plug a TinkerKit! linear potentiometer to control the direction and speed of the rotation. Let’s plug it on an input port.

In order to use the module, we have to include the TinkerKit! library, then declare it as a regular TKPotentiometer. The port used, in our case, is the number 2.

#include <TinkerKit.h>

TKPotentiometer pot(2);

We can map the value of the potentiometer on a range that goes from -255 to 255, then we check if it’s positive or negative for the direction, and use the absolute value (without the sign) to set the rotation speed.

#include <TinkerKit.h>

TKPotentiometer pot(2);

void setup() {
  //Setup Channel A
  pinMode(12, OUTPUT); //Initiates Motor Channel A
  pinMode(9, OUTPUT); //Initiates Brake Channel A

  digitalWrite(9, LOW);   //Disengage the Brake

  digitalWrite(12, LOW);   //Set direction
  analogWrite(3, 255);   //Channel A at full speed
}

void loop() {
  int val = pot.get(); //8-896
  delay(30);

  //our potentiometer goes from 8 to 896
  //use serial print to check the values
  val = map(val, 8, 896, -255, 255);

  if (val < 0) {
    //spin left
    digitalWrite(12, HIGH); 
  } 
  else {
    //spin right
    digitalWrite(12, LOW); 
  }
  
  //val without sign 
  int abso = abs(val);
  
  //constrain it to 0-255 to be sure
  constrain(abso,0,255);  

  //set speed
  analogWrite(3, abso);  
  
}

Now we can even plug a TinkerKit! LCD on the TWI port, to read the values of speed and direction. In order to use the LCD as a TWI device, we have to upload the TWIFirmware on it, that can be found in the examples of the TKLCD library. Follow this tutorial for more information.

In our code, we have to include TKLCD library, Wire and LiquidCrystal in our sketch, then declare it as a TKLCD_Twi.

#include <LiquidCrystal.h>
#include <Wire.h>
#include <matrix_lcd_commands.h>
#include <TKLCD.h>
#include <TinkerKit.h>

TKPotentiometer pot(2);
TKLCD_Twi lcd = TKLCD_Twi();

Then in our code, we can create a string for direction that can be LEFT or RIGHT, then print it on the LCD with the absolute value of the potentiometer:

#include <LiquidCrystal.h>
#include <Wire.h>
#include <matrix_lcd_commands.h>
#include <TKLCD.h>
#include <TinkerKit.h>

TKPotentiometer pot(2);
TKLCD_Twi lcd = TKLCD_Twi();

void setup() {
  //Setup Channel A
  pinMode(12, OUTPUT); //Initiates Motor Channel A
  pinMode(9, OUTPUT); //Initiates Brake Channel A

  digitalWrite(9, LOW);   //Disengage the Brake

  digitalWrite(12, LOW);   //Set direction
  analogWrite(3, 255);   //Channel A at full speed

  lcd.begin();
}

void loop() {
  int val = pot.get(); //8-896
  delay(30);

  //our potentiometer goes from 8 to 896
  //use serial print to check the values
  val = map(val, 8, 896, -255, 255);

  String dir;

  if (val < 0) {
    //spin left
    digitalWrite(12, HIGH); 
    dir = "LEFT";
  } 
  else {
    //spin right
    digitalWrite(12, LOW); 
    dir = "RIGHT";
  }

  //val without sign 
  int abso = abs(val);

  //constrain it to 0-255 to be sure
  constrain(abso,0,255);  

  //set speed
  analogWrite(3, abso); 
  
  //write on the lcd
  lcd.clear();  
  lcd.print(dir + " " + abso); 

}

Once we have uploaded the firmware on the LCD, we can connect the TWI out port of the shield, to the TWI1 port on the LCD. Mind that if you are powering the Arduino, the LCD and the motor just from the USB port of your computer, you will face some uploading issues. We recommend to upload the skecth on the Arduino, then connect the TWI cable and motor. Use it with external power for best results.

In this tutorial we are using the DMX Relay Receiver to control a couple of high-voltage outputs; the board mounts four relays that can be individually controlled to control an output.

In this example we are using it with the DMX Master Shield but it’s also possible to use it independently, by uploading your own custom firmware on the board. We are working on a tutorial for that so stay tuned.

a small reminder:

First we connect the outputs; in our case we decided to connect a lamp and an extension cable (the same of the relay module tutorial), to two of the board’s relays. Once you chose the device that you want to plug, cut the cable’s sheath to see the wires inside (always working without any electricity inside of course).

What we see is two wires; in order to open the circuit we cut one of them and peel a small portion of the rubber (around 5mm) from both sides, so that the copper inside is visible

Each relay has three output ports that are C (common), NO (normally open) and NC (normally closed). Look at the Relay tutorial and documentation for more detailed information about them. The relay opens and closes the circuit when triggered, what it does in details is closing the NO and opening the NC.
In this way we can create a series of non-invasive domotic devices by connecting them to the NC port of a relay, so that we can continue to use them as regular devices until we want to control them.

Back to our receiver, chose a relay then plug one side of the wire into the middle port (C) and the other on one of the remaining two sides.

Do the same with another device if you want.

This is what we have so far

The DMX Relay Recevier requires 12V of external power to work, as usual we supply this with a recycled transformer, to which we cut the wire so that we can fit the smaller inner wires in the VIN connectors. Remember to identify correctly + and - because they’re not exchangeable.

Now we connect the Receiver with the Master, matching the Master’s OUT ports D+ D- and GND with the same-named ports on the Receiver.

Then we set the address of the receiver, to make it simple we set it to 1. In this way when we can write

DmxMaster.write(1,HIGH);

to target the first relay on the board, then the others are sequential. In our case we are using relays number 1 and 4.

(this is a picture of another module, but never mind, what’s important is the address)

Let’s start with something basic, like turning on each of the two relay individually; try to write it by yourself first, then keep reading for the solution. Remember to include the DMX library.

Ok, first of all we have to include the DMX library, that allows us to use the DmxMaster object. Then in the setup() function, we can use the maxChannel method to define the top channel that we are using, in our case is 4 because we hooked up the extension cable on the fourth relay.

#include <DmxMaster.h>

void setup() {
  DmxMaster.maxChannel(4);
}

Then in the loop we turn on one lamp, wait five seconds then turn on the other lamp

DmxMaster.write(1, HIGH);
delay(5000);  
DmxMaster.write(1,LOW);
DmxMaster.write(4, HIGH);
delay(5000);  
DmxMaster.write(4,LOW);

And that’s basically it, take a look at the result and the full code after the video.

Here we connected another lamp to the extension cable but you can plug anything you want (except from a multiple socket of course; in fact doing so will burn the relay, your house and probably you’ll die in agony (seriously, don’t plug a multiple socket in a single relay)

/*channel: 
 1: SMALL LAMP
 4: SOCKET 
 */

#include <DmxMaster.h>

void setup() {
  DmxMaster.maxChannel(4);
}

void loop() {
  DmxMaster.write(1,HIGH);
  DmxMaster.write(4,LOW);
  delay(5000);
  DmxMaster.write(4,HIGH);
  DmxMaster.write(1,LOW);
  delay(5000);  
}

In this tutorial we are using the DMX MosFet Receiver to control an RGB LED strip. The board mounts four mosfets while the strip has three outputs, one for each color. You can evend find more advanced strips that have four outputs, three for RGB and one for the white. In both cases, the DMX MosFet Receiver is a compact solution to control the strip.

In this example we are using it with the DMX Master, but it’s also possible to use it independently, by uploading your own custom firmware on the board. We are working on a tutorial for that so stay tuned.

First of all we connect the Receiver with the Master, matching the Master’s OUT ports D+ D- and GND with the same-named ports on the Receiver.

Then we have to connect the LED strip, if you look on the receiver’s OUTPUT ports, each mosfet has two outputs (+ and -), but all the ports labeled C are connected (C is for COMMON). In this way we can plug the power (or ground) to any of the C ports and it’s like connecting all of them to the same ground or power.
In our picture the power is the red cable, that we are connecting on a C port, while the blue ones are the individual GND for red, green and blue.

Then we have to supply the voltage required by our LED strip. In our case it’s 12V that we’re getting from a transformer to which we cut the wire so that we can fit them in the “EXTERNAL POWER” connector. Remember to identify correctly + and - because they’re not exchangeable.

Then we set the address of the receiver, to make it simple we set it to 1. In this way when we write

DmxMaster.write(1,128);

we are addressing to the first mosfet on the board and the others are sequential. In our case it’s 1 for red, 2 for blue and 3 for green.

Let’s start with something basic, like turning on each color individually; try to write it by yourself first, then keep reading for the solution. Remember to include the DMX library.

Ok, first of all we have to include the DMX library, that allows us to use the DmxMaster object. Then in the setup() function, we can use the maxChannel method to define the top channel that we are using, in our case is 3 because we’re not the last mosfet, but let’s write 4 so that if we want we can use all of them.

#include <DmxMaster.h>

void setup() {
  DmxMaster.maxChannel(4);
}

Then in the loop we nest another loop that turns on each channel every second.

for(int i = 1; i < 4; i++) {
    DmxMaster.write(i, 255);
    delay(1000);  
    DmxMaster.write(i,0);
  }

And that’s basically it, take a look at the result and the full code after the break.

/*channel: 
 1: RED
 2: BLU
 3: GREEN
 */

#include <DmxMaster.h>

void setup() {
  /*also if we are using only three channels,
   we set the maximum to four so that we can still 
   use the last mosfet if we want */
  DmxMaster.maxChannel(4);
}

void loop() {
  for(int i = 1; i < 4; i++) {
    DmxMaster.write(i, 255); //full on
    delay(1000);  
    DmxMaster.write(i,0); //off
  }
}

The DMX Relay Receiver is a DMX module that mounts four relays; they can be individually controlled using a DMX master like TinkerKit!’s DMX Master Shield. Each Relay supports up to 220V at 10A.

The board itself is divided in three parts:

1. Relay output

Where the high-voltages connections are made. Each Relay has three outputs: the one in the middle is the common line, while the external ones are normally-open and normally-closed. Refer to the relay tutorial for more detailed information on hot to wire a relay properly.

2. DMX connections

Plug in here the wires from the Master Shield or another DMX Receiver. The connections are easy, D+ goes to D+, D- to D- and GND to GND. For the external power, the Relay module requires 12V.

3. Address

DMX works with one master and up to 128 receivers, all connected to a single line. In order to send signals to the right output, each receiver is identified by an address from 0 to 512.
Each receiver has an address that is set from this pin interface. The address is expressed with a binary number where each pin correspond to a digit.

As you probably understood from the pictures, if the pin is down that digit is 0, while if it’s up it is 1. Mind that the number is written from right to left; the most significant digit is in fact on the far right. If you notice in the last example, where we select an address with the number 20 (10100 in binary), we start writing it from right to left. This address refers to the first relay on the board (the one with the number 1 label), all the others have addresses that are sequential to the first one.

e.g. if set the address of the board on 3 (101), if you want to turn on the first relay you have to write:

DmxMaster.write(3,HIGH)

if you want to turn on the second:

DmxMaster.write(4,HIGH)

and so on. This means that if you have multiple DMX receivers, you have to set their addresses with a gap of four numbers, in order to have full control on all the modules on the board.

This way of setting addresses can be a bit confusing at the beginning, that’s why we created this visual tool that helps to understand how it works.

This is an example code used to control a DMX Relay Receiver with an address of 5, we turn each relay on sequentially and then off altogether.

/*
Relay sequential "blink"
 use this with a DMX Relay Receiver (it works also with the MosFet)
 receiver. The address of the board is set into the ADDRESS variable 
 */

#include <DmxMaster.h>

int ADDRESS = 3; //the address of the board in decimal system

void setup() {
  /*set the max channel, in this way that the module
  doesn't have to cycle through all the possible
  channels every time*/
  DmxMaster.maxChannel(ADDRESS + 3);
}

void loop() {

  for (int i = ADDRESS; i < ADDRESS + 4; i++) { 
    DmxMaster.write(i, HIGH);
    delay(1000);
    DmxMaster.write(i, LOW);
  }

}

The TinkerKit! LCD also supports TWI connections. TWI stands for “Two-Wire Interface” and it’s another way to call the I2C bus technology. Basically it allows to connect multiple devices in series. This means that you can hook a large number of LCD screens, connecting them “in-line” using the two TWI ports, one for input and one for output. One of them must be the master (or you can use a TInkerKit! shield), while the others must run the TWI firmware. The TWI port has four pins, that’s why we need the 4-pin cable to connect them.

First of all let’s connect two modules, then we move to the code. We need the TKLCD library that you can download from the library section of the website. If you downloaded it already, be sure to have the last version because TWI support has been added only recently.

Between the examples of the TKLCD library, there is one that is called TwiFirmware. We have to load it into one of or our LCD modules, the other module doesn’t need a firmware.

Now we have to declare our LCDs. One is a regular TKLCD_Local, while the TWI, it’s a TKLCD_Twi

TKLCD_Local local;
TKLCD_Twi twi;

Then in the setup we initialize them normally

local.begin();
twi.begin();

After this we can use them in the loop as a normal TKLCD, let’s try to write somthing on them:

local.print("Hi TWI");
delay(2000);
local.clear();

twi.println("Hi Local");
delay(2000);
twi.clear();

Ok, that was rather easy, but the cool thing about TWI is that you can connect as much modules as you want. Now we try to connect three LCD modules. One will be the local master and the other two are TWI slaves. We have to load them with the TWI firmware.

If we have more than one TWI, in order to understand which one we are controlling we need to define a different address for each. Let’s open the TwiFirmware example in the TKLCD library and then, at line 88, there’s this command:

#define MATRIX_I2CADDR 0x33 // change this in order to communicate with another LCD

Every TWI module has an address that is defined in this line of the firmware program. By default it’s 0×33 but we can change it. If we have more than one module we have to define a different address for each module. Now we set one address to 0×33 and the other to 0×44, then we upload them.

Now all we have to do is program the master module. We don’t have to change barely anything from our program, we still have to declare just one TWI, but in the loop we have to set a different address everytime that we want to change the target TWI LCD. This is done using lcd.setActiveAddress(NEW_ADDRESS).

Here what we do is writing on the three screens in sequence:

local.print("I'm a local");
delay(2000);
local.clear();

twi.setActiveAddress(0x33);
twi.println("I'm TWI 0x33");
delay(2000);
twi.clear();

twi.setActiveAddress(0x44);
twi.println("I'm TWI 0x44");
delay(2000);
twi.clear();

By changing addresses, you can connect a large array of TWI devices.

Today the DMX Master Shield is officially available worldwide on the Arduino Store! For the ones who don’t know the possibilities of this shield, it is able to control a series of 512 DMX outputs, individually, using Arduino and TinkerKit!

It is part of the TinkerKit DMX family, new toys will be available for the end of April, stay tuned!

Good news! We just released a series of lessons about how to interface processing with your TinkerKit!, take a look in the tutorials section. They start from a basic introduction to the brand new Processing Library, then they move on to something more specific, like how to map and calibrate your sensors. In the end you’ll also interface with a pong game taken from openProcessing!

In this tutorial we’ll see how to adapt an existing processing sketch that uses regular inputs like keyboard and mouse, to TinkerKit! sensors. We are going to use OpenProcessing, a website where Processing users can upload their creations and the source is available to anybody.

Let’s get started: go on openprocessing.org and browse for a game. We start with pong, something basic that everyone knows. Type “pong” in the search bar, then open an example that you like. We chose classic pong by David Avetisyan; now copy the code and paste it in a new processing window. Run it to verify that it works. It’s a simple one-player pong, where you can move the rectangle left and right using two keys, A and D.

We don’t like that button-based interaction, now that we know the possibilities that we have with the TinkerKit sensors! We can start with a potentiometer to understand the logic, then we change to something more interesting. Hook up a potentiometer (better linear but also rotary is fine) to an input port and follow these steps.

Include and Declare

First we have to include the libraries that we normally use for TinkerKit and Arduino. Open any example of the TinkerKit! library for processing, then copy the first three lines, the ones with the “include” and paste them into our pong sketch, right at the beginnning. After these lines declare an arduino object

arduino Arduino;

In the setup, we have to initialize the arduino object, like we normally do. We can paste the line from the example.

arduino = new Arduino(this, Arduino.list()[0], 57600);

Now we are set. If we run this sketch, it should work. Even though the lines we added don’t change anything in terms of behavior, our sketch is configured to work with TinkerKit!. The next step is to identify the variable that is used to control the player’s rectangle. We can start to look for where the keyPressed functions are and see which variable they change. In the paddle class there are some keyPressed functions:

 if ( keyPressed== true && key=='a')
    {
      x=x-10;
    }
    if ( keyPressed==true && key=='d')
    {
      x=x+10;
    }

As we can see from the code, the rectangle horizontal position is determined by the x variable, that is changed once we press ‘a’ or ‘d’. What we can do is change the x using the potentiometer. Let’s start by declaring it at the top, then in the move() function of the paddle object (where the keyPressed are), we can comment the keyPressed lines and add a new float variable for the potentiometer.

float val = pot.get();

Then what we have to do is assign to x the mapped value of the potentiometer. Considering that the paddle moves from 0 to width, our map function will look like

x = map(val,0,1023,0,width);

Now if we try to run this sketch, we get an error, it says “cannot converto from float to int”. That’s because the x variable has been declared as int and the map function returns a float value. The simplest way to fix this is to change the declaration of x as float. Run the sketch and you should have a pong controlled by a tinkerkit sensor.

here’s the full code:

/* edit of the pong sketch by 
//David Avetisyan, CP1, (4/5)
found on openprocessing.org

We changed the input control for
the paddle from keyboard to a 
linear potentiometer
*/

import processing.serial.*;
import cc.arduino.*;
import com.tinkerkit.*;

Arduino arduino;

TKPotentiometer pot;

Ball bally;
Paddle pongy;
int t= 1;
int p=255;
void setup()
{

  arduino = new Arduino(this, Arduino.list()[0], 57600);    

  smooth();
  size(600, 500);
  bally= new Ball();
  pongy= new Paddle();
  
  pot = new TKPotentiometer(arduino, TK.I0);
}

void draw()
{
  background(0);
  pongy.show();
  pongy.move();
  bally.show();
  bally.bounce();
  bally.move();
}
class Ball
{
  int x, y;
  boolean Up, Right;
  Ball()
  {

    x= 250;
    y= 0;
    boolean Up= false;
    boolean Right= true ;
  }
  void show()
  {

    fill(255, 255, 255);

    ellipse(x, y, 20, 20);
  }
  void bounce()
  {
    if (get(x, y+16) == color(0, 255, 0))
    {
      Up=true;
      p=-10;
    }
    if (y>500)
    {
      x=250;
      y=0;
    }

    if (x==0)
    {
      Right=true;
    }
    if (x==600)
    {
      Right=false;
    }

    if (y==0)
    {
      Up=false;
    }
  }
  void move()
  {
    if (Right== true)
    {
      x=x+5;
    }
    else
    {
      x=x-5;
    }
    if (Up== true)
    {
      y=y-5;
    }
    else
    {
      y=y+5;
    }
  }
}

class Paddle
{
  int x, y;
  boolean left, right;
  Paddle()
  {

    x= 100;
    y= 480;
    boolean left= false;
    boolean right= true ;
  }
  void show()
  {

    fill(0, 255, 0);
    rect(x, y, 100, 25);
  }
  void move()
  {

    if (x>495)
    {
      x=500;
    }
    if (x<0)
    {
      x=0;
    }

  float val = pot.get();
  
  x = map(val,0,1023,0,width);

//    if ( keyPressed== true && key=='a')
//    {
//      x=x-10;
//    }
//    if ( keyPressed==true && key=='d')
//    {
//      x=x+10;
//    }
//    if (keyPressed==true && key=='r')
//    {
//    }
  }
}