Skip to content
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
/* bzbowls
* March 2019
* Created for PIE People Inside Electronics
* Premiering March 27th http://www.peopleinsideelectronics.com/wired-wednesday
*
* Physical controller is the same as bell-controller
* 15 motors
*
* ~~ Controller Scheme ~~
*
* Mode A:
* Switches: Bells are on or off (no metro)
* Knobs: PWM level of different groups of motors (3 groups of 5)
* Sensor: Try fast switch to all low PWM or all high PWM
*
* Mode B:
* Original bell-controller performance mode for testing
* Mode C:
* Original bell-controller installation mode for testing
*/
#include <Metro.h> // Include Metro library
#include <math.h> // for math
// Define mode switch (installation vs performance modes)
const int modePin = 53;
int modeState = HIGH;
// Define sensor mode switch
const int sensormodePin = 52;
int sensormodeState = HIGH;
// Define sensor
const int sensorPin = A0;
unsigned long sensorValue = 0;
float sensorMapped = 0;
// scaled according to this help topic:
// http://forum.arduino.cc/index.php?topic=145443.0
// Define knobs (left to right)
const int knob0Pin = A2;
unsigned long knob0Value = 0;
float knob0Mapped = 0;
const int knob1Pin = A3;
unsigned long knob1Value = 0;
float knob1Mapped = 0;
const int knob2Pin = A1;
unsigned long knob2Value = 0;
float knob2Mapped = 0;
// Set ideal pwm level
int off = 0;
int pwm = 255;
int pwmgp = 50;
int on = 255;
//int pwmHi = 255;
//int pwmLo = 50;
int pwm1 = pwm;
int pwm2 = pwm;
int pwm3 = pwm;
//int pwmSensor = pwm;
//ModeA Groups
int modeAgroup1 = 1;
int modeAgroup2 = 2;
int modeAgroup3 = 3;
// Define motors pins (*15)
const int motor0 = 13;
const int motor1 = 12;
const int motor2 = 11;
const int motor3 = 10;
const int motor4 = 9;
const int motor5 = 8;
const int motor6 = 7;
const int motor7 = 6;
const int motor8 = 5;
const int motor9 = 4;
const int motor10 = 3;
const int motor11 = 2;
const int motor12 = 44;
const int motor13 = 45;
const int motor14 = 46;
// Define motor states (*15)
int motor0State = pwm;
int motor1State = pwm;
int motor2State = pwm;
int motor3State = pwm;
int motor4State = pwm;
int motor5State = pwm;
int motor6State = pwm;
int motor7State = pwm;
int motor8State = pwm;
int motor9State = pwm;
int motor10State = pwm;
int motor11State = pwm;
int motor12State = pwm;
int motor13State = pwm;
int motor14State = pwm;
// Define toggles (*15)
const int toggle0Pin = 22;
const int toggle1Pin = 23;
const int toggle2Pin = 24;
const int toggle3Pin = 25;
const int toggle4Pin = 26;
const int toggle5Pin = 27;
const int toggle6Pin = 28;
const int toggle7Pin = 29;
const int toggle8Pin = 30;
const int toggle9Pin = 31;
const int toggle10Pin = 32;
const int toggle11Pin = 33;
const int toggle12Pin = 34;
const int toggle13Pin = 35;
const int toggle14Pin = 36;
// Define toggle states (*15)
int toggle0State = HIGH;
int toggle1State = HIGH;
int toggle2State = HIGH;
int toggle3State = HIGH;
int toggle4State = HIGH;
int toggle5State = HIGH;
int toggle6State = HIGH;
int toggle7State = HIGH;
int toggle8State = HIGH;
int toggle9State = HIGH;
int toggle10State = HIGH;
int toggle11State = HIGH;
int toggle12State = HIGH;
int toggle13State = HIGH;
int toggle14State = HIGH;
// Set the active interval (*15)
float t0 = 125;
float t1 = 130;
float t2 = 135;
float t3 = 140;
float t4 = 145;
float t5 = 150;
float t6 = 155;
float t7 = 160;
float t8 = 165;
float t9 = 170;
float t10 = 175;
float t11 = 180;
float t12 = 185;
float t13 = 190;
float t14 = 195;
// Set the rest interval (*15)
float t0rest = 155;
float t1rest = 150;
float t2rest = 145;
float t3rest = 140;
float t4rest = 135;
float t5rest = 130;
float t6rest = 125;
float t7rest = 120;
float t8rest = 115;
float t9rest = 110;
float t10rest = 105;
float t11rest = 100;
float t12rest = 95;
float t13rest = 90;
float t14rest = 85;
// Instatiate metro object (*15)
Metro metro0 = Metro(t0);
Metro metro1 = Metro(t1);
Metro metro2 = Metro(t2);
Metro metro3 = Metro(t3);
Metro metro4 = Metro(t4);
Metro metro5 = Metro(t5);
Metro metro6 = Metro(t6);
Metro metro7 = Metro(t7);
Metro metro8 = Metro(t8);
Metro metro9 = Metro(t9);
Metro metro10 = Metro(t10);
Metro metro11 = Metro(t11);
Metro metro12 = Metro(t12);
Metro metro13 = Metro(t13);
Metro metro14 = Metro(t14);
///////////////////////////////////////
//////// installation settings ////////
///////////////////////////////////////
// counter variables (*15)
int counter0 = 1;
int counter1 = 1;
int counter2 = 1;
int counter3 = 1;
int counter4 = 1;
int counter5 = 1;
int counter6 = 1;
int counter7 = 1;
int counter8 = 1;
int counter9 = 1;
int counter10 = 1;
int counter11 = 1;
int counter12 = 1;
int counter13 = 1;
int counter14 = 1;
// how many times to do pattern before it reevaluates itself (way arbitrary)
//ModeB
int unit0 = 5;
int unit1 = 3;
int unit2 = 7;
int unit3 = 9;
int unit4 = 12;
// installation time multiplier
int installationgp = 30; // grand pause (*trest)
int installationrest = 14; // pause (*trest)
void setup()
{
//Serial.begin(9600);
// declare output pins
pinMode(motor0,OUTPUT);
pinMode(motor1,OUTPUT);
pinMode(motor2,OUTPUT);
pinMode(motor3,OUTPUT);
pinMode(motor4,OUTPUT);
pinMode(motor5,OUTPUT);
pinMode(motor6,OUTPUT);
pinMode(motor7,OUTPUT);
pinMode(motor8,OUTPUT);
pinMode(motor9,OUTPUT);
pinMode(motor10,OUTPUT);
pinMode(motor11,OUTPUT);
pinMode(motor12,OUTPUT);
pinMode(motor13,OUTPUT);
pinMode(motor14,OUTPUT);
}
void loop() {
motorcontrol(metro0, motor0, motor0State, t0, t0rest, toggle0Pin, toggle0State, counter0, unit0, modeAgroup1);
motorcontrol(metro1, motor1, motor1State, t1, t1rest, toggle1Pin, toggle1State, counter1, unit0, modeAgroup1);
motorcontrol(metro2, motor2, motor2State, t2, t2rest, toggle2Pin, toggle2State, counter2, unit0, modeAgroup1);
motorcontrol(metro3, motor3, motor3State, t3, t3rest, toggle3Pin, toggle3State, counter3, unit0, modeAgroup1);
motorcontrol(metro4, motor4, motor4State, t4, t4rest, toggle4Pin, toggle4State, counter4, unit0, modeAgroup1);
motorcontrol(metro5, motor5, motor5State, t5, t5rest, toggle5Pin, toggle5State, counter5, unit1, modeAgroup2);
motorcontrol(metro6, motor6, motor6State, t6, t6rest, toggle6Pin, toggle6State, counter6, unit1, modeAgroup2);
motorcontrol(metro7, motor7, motor7State, t7, t7rest, toggle7Pin, toggle7State, counter7, unit1, modeAgroup2);
motorcontrol(metro8, motor8, motor8State, t8, t8rest, toggle8Pin, toggle8State, counter8, unit1, modeAgroup2);
motorcontrol(metro9, motor9, motor9State, t9, t9rest, toggle9Pin, toggle9State, counter9, unit1, modeAgroup2);
motorcontrol(metro10, motor10, motor10State, t10, t10rest, toggle10Pin, toggle10State, counter10, unit2, modeAgroup3);
motorcontrol(metro11, motor11, motor11State, t11, t11rest, toggle11Pin, toggle11State, counter11, unit2, modeAgroup3);
motorcontrol(metro12, motor12, motor12State, t12, t12rest, toggle12Pin, toggle12State, counter12, unit2, modeAgroup3);
motorcontrol(metro13, motor13, motor13State, t13, t13rest, toggle13Pin, toggle13State, counter13, unit2, modeAgroup3);
motorcontrol(metro14, motor14, motor14State, t14, t14rest, toggle14Pin, toggle14State, counter14, unit2, modeAgroup3);
}
//////////////////////////////////
//////// Custom Functions ////////
//////////////////////////////////
// Motor Control
// usage example:
// motorcontrol(metro0, motor0, motor0State, t0, t0rest, toggle0Pin, toggle0State, counter0, unit0, modeAgroup1);
void motorcontrol(Metro& metro, int motor, int &motorState, float t, float trest, int togglePin, int toggleState, int &counter, int unit, int modeAgroup) {
if (metro.check() == 1) { // check if the metro has passed its interval
// see if installation of performance mode
modeState = digitalRead(modePin);
// to turn motors on/off in either mode
toggleState = digitalRead(togglePin);
if( modeState == HIGH ) { // BZBOWLS MODE ON
// NEW MODE FOR BZBOWLS
// on/off with separate PWM control for 3 groups of 5
// no variable interval in modeA
metro.interval(10);
// READ KNOBS AS PWM CONTROL
knob0Value = 1023 - analogRead(knob0Pin); // invert because hooked up backwards
knob0Value = knob0Value * knob0Value;
knob0Value = knob0Value / 1309; // "ease in-out"
knob0Mapped = map(knob0Value, 0, 799, 0, 255);
pwm1 = knob0Mapped;
knob1Value = 1023 - analogRead(knob1Pin); // invert because hooked up backwards
knob1Value = knob1Value * knob1Value;
knob1Value = knob1Value / 1309; // "ease in-out"
knob1Mapped = map(knob1Value, 0, 799, 0, 255);
pwm2 = knob1Mapped;
knob2Value = 1023 - analogRead(knob2Pin); // invert because hooked up backwards
knob2Value = knob2Value * knob2Value;
knob2Value = knob2Value / 1309; // "ease in-out"
knob2Mapped = map(knob2Value, 0, 799, 0, 255);
pwm3 = knob2Mapped;
// FSR sensor to control overall speed with fast/slow modes
sensormodeState = digitalRead(sensormodePin);
sensorValue = analogRead(sensorPin);
sensorValue = sensorValue * sensorValue;
sensorValue = sensorValue / 1309; // "ease in-out"
if( toggleState == LOW ) {
// if it's off, it's off
motorState=off;
analogWrite(motor,motorState);
} else if ( toggleState == HIGH ) { // if motor is switched on
if(sensorValue > 0) {
// if sensor activated, assign PWM level according to sensor mode
if(sensormodeState == LOW ) { // and set to high
pwm = map(sensorValue,0,750,20,255);
} else if ( sensormodeState == HIGH ) {
pwm = map(sensorValue,0,750,255,20);
}
} else {
// if sensor unused, assign pwm level according to group
if (modeAgroup == 1) {
pwm=pwm1;
} else if (modeAgroup == 2) {
pwm=pwm2;
} else if (modeAgroup == 3) {
pwm=pwm3;
}
}
motorState=pwm;
analogWrite(motor,motorState);
}
} // end toggle state high
// end performance mode
if( modeState == LOW ) {
// BELL CONTROLLER
// use first knob to control note-on length (t)
knob0Value = 1023 - analogRead(knob0Pin); // invert because hooked up backwards
knob0Mapped = mapf(knob0Value, 0, 1023, 1, 8);
t = t*knob0Mapped;
// use third knob to control motor strength (pwm)
knob2Value = 1023 - analogRead(knob2Pin); // invert because hooked up backwards
knob2Value = knob2Value * knob2Value;
knob2Value = knob2Value / 1309; // "ease in-out"
knob2Mapped = map(knob2Value, 0, 799, 0, 255);
pwm = knob2Mapped;
// use second knob to control note-off length (trest)
knob1Value = 1023 - analogRead(knob1Pin); // invert because hooked up backwards
knob1Value = knob1Value * knob1Value;
knob1Value = knob1Value / 1309; // "ease in-out"
knob1Mapped = mapf(knob1Value, 0, 1023, 1, 15);
trest = trest*knob1Mapped;
// FSR sensor to control overall speed with fast/slow modes
sensormodeState = digitalRead(sensormodePin);
sensorValue = analogRead(sensorPin);
sensorValue = sensorValue * sensorValue;
sensorValue = sensorValue / 1309; // "ease in-out"
if( toggleState == LOW ) {
motorState=off;
analogWrite(motor,motorState);
}
if( toggleState == HIGH ) {
if(sensormodeState == LOW ) {
if(sensorValue > 0) {
pwm = map(sensorValue,0,750,20,255);
} else {
pwm = knob2Mapped;
}
} else {
if(sensorValue > 0) {
pwm = map(sensorValue,0,750,255,20);
} else {
pwm = knob2Mapped;
}
}
if (motorState != off) {
motorState=off;
metro.interval(trest); // rest between chirps
} else {
motorState=pwm;
metro.interval(t); // original chirp speed
}
analogWrite(motor,motorState);
} // end toggle state high
// end performance mode
}
} // end metro check
} // end of motorcontrol function
// Map floats
float mapf(float x, float in_min, float in_max, float out_min, float out_max) {
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}