Arduino Vending Machine: 2 - Accepting Dollar Bills

Updated - (8/1/2012)!
Summary
This is a tutorial of how to use an Arduino to count the number of dollar bills accepted by a bill validator (BA-30).

Description
This tutorial is about using an Arduino to count dollars that were accepted by a bill validator. This is a common type of bill validator used in machines that take money and give something (vending machines).  The goal is to connect the bill validator to the Arduino and be able to know when a dollar bill has been accepted.

Specifically, we will use an Arduino to read pulses from a bill validator.  Normally, the pulses read from the bill validator will be in the range of 8000 to 9000.  When we insert a dollar bill into the bill validator and the bill validator accepts the bill, we will be able to read pulses above 12000 from the bill validator.  Given this, we can tell when a bill is accepted.
If (duration > 12000)
{
     billCount++;
}

Before we begin
Divide and Confuse...
In many forums around the web, there is great interest in how to use an Arduino to accept cash.  Unfortunately,  there is very little concrete information about how to it.  What's worse is that these devices, bill validators and coin mechanisms, use different protocols.  Many devices that share a common protocol share the Multi-Drop Bus (MDB) protocol which uses a 9-bit word.  Enough said.

Bill Validator explained
The bill validator takes dollar bills.  For the most part, all it does is take money in paper form, validate it (make sure it is real), store it, and report that one piece of money (of a certain value) has been accepted.  The bill validator is also known as a bill acceptor or that thing that takes dollars (or other appropriate local currency).

The idea for everything is simple, we are just listening for when the bill is accepted.  We are using the Arduino to listen to the bill validator.  The bill validator has all of the logic to know when it has accepted the paper currency.  In the case of this tutorial, we are using the BA-30, made by Coinco.  The nice thing about the BA-30 is that it provides us with two ways to listen to it.  The first is using pulses and the other is using the MDB protocol.  We will be using the pulses.

Safety (always)
"You gotta play it safe around the power lines" - Louie T.L. Bug
Experimenting with the combined equipment of an Arduino, bill validator, and computer can cause harm to you or your equipment under certain situations.  Here's some items to consider for some of the components involved.

Bill Validator
In order to power the bill validator, you will need to hook it up to power from an outlet.  It is relatively simple but if you don't feel comfortable, don't do it.  Find someone that has done something similiar and have them help you.

D.) Other
This is the other category.  This is all meant to be fun.  When experimenting, there may be times you feel uncomfortable or unsafe about doing something in a project.  At times like these, find a person, forum, or group (Arduino forums linked) to ask and make your situation safe at all times.

Steps
Control the ESC/Motor using an Arduino

1. Setup the bill validator.
2. Connect the bill validator to Arduino.
3. Upload your sketch to the Arduino.
4. Use a dollar and watch for the output.

Begin
1. Setup the bill validator.

Figure 1.1 - The pins

We are going to work with the pins A through F {A,B,C,D,E,F} as these are for pulses.  Disregard the pins G through K as they are for MDB and aren't covered in this tutorial.

As you can see from Figure 1.2, I use a wire harness for the BA30.  You can find them on the internet.  If you are looking for them, search for "BA30 wire harness" or "BA30 coinco wire harness". As long as one end goes to the BA30, you don't really care what the other end goes to.

 First we need power.  Power the BA30 with main (110V) power.  NOTE: Power from an outlet can kill you.  Don't attempt this if you don't know how to be safe.  There is a picture below with all of the pins labeled (Figure 1.1).  This picture is from the kegbot blog at: http://kegbot.blogspot.com/2004/11/coinco-magpro-mag50b-pinout.html Take the line of a power cord and splice the hot into "110VAC Hot" (on the picture it's pin F), and again splice the hot into the "Hot Enabled" (on the picture it's pin E).  Take the line's neutral and splice it into "110VAC Neutral" (on the picture it's pin C).

Figure 1.2 - Sideview with pins labeled

2. Connect the bill validator to the Arduino
According to the diagram in Figure 1.1, the bill validators pin labeled "A" is the "cr-" line.  It is difficult to see but the line is green.  Take this line from the bill validator and put it in the Arduino pin #7 (this is the pin used in the sketch).  The next line we need from the bill validator is labeled "B" or the "cr+" line.  This line needs to tie into the +5v as shown below (Figure 2.1)

Figure 2.1 - Connecting bill validator to Arduino

3. Upload you sketch to the Arduino
The hard part is over.  Upload the following sketch to your Arduino:


/*
* Sean
* globalw2865@gmail.com
* 30JUL2012
* Bill validator/Arduino (second draft)
*/

/*
* RESOURCES:
* http://www.arduino.cc/en/Reference/PulseIn
* http://kegbot.blogspot.com/2004/11/coinco-magpro-mag50b-pinout.html
* http://www.coinco.com/coin/faq/servicematerials/921970_1.pdf
*/

/*
* Description:
* Arduino records and counts dollar bill received from pin 7 (billValidator).
*/

// Constants //
// pin for the bill validator's credit(-) line
const int billValidator = 7;

// Variables //

// recording the duration of pulse (milliseconds)
unsigned long duration;

// holding the total dollars recorded
int dollarCounter = 0;

void setup()
{
  // Pin setups for bill validator and button
  pinMode(billValidator, INPUT);
 
  // Initialize serial ports for communication.
  Serial.begin(9600);
  Serial.println("Waiting for dollar...");
}

void loop()
{
  // get the duration of the pulse
  duration = pulseIn(billValidator, HIGH);
   
  // Receiving a dollar bill will create a pulse
  // with a duration of 150000 - 160000.
  // NOTE: When there is no dollar bill pulse,
  // I will receive a pulse of 8400 - 8600
  // on every loop.
  // Dollar received
  if(duration > 12000)
  {
  // Count dollar
  dollarCounter++;
  // Checking for understanding
  Serial.print("Dollar detected.\n Total: ");
  // Display new dollar count
  Serial.println(dollarCounter);
  }
     
}


4. Use a dollar and watch for the output

First dollar (Figure 4.1)

Figure 4.1

Second dollar (Figure 4.2)

Figure 4.2

5. Done
The tutorial is fairly simple.  Many thanks to anyone who has corrected me.  Also, if anyone is interested in this, you will probably be interested in the posts on the Bounis Blog.  They go into detail on the MDB protocol (well done).