This code accomplishes the same thing the first generation of code had done, except more efficiently. Efficiently in that less wires go to the Arduino. Here, I added a servo controller along with an Input/Output expander made of Multiplexers (4051's). There is smaller versions of these codes as well as wiring documents on the previous page that better explains each. The end accomplishment though is that 18 servos and 18 sensors can be run off of 2 pins (five address pins, one transmit pin, and two outputs) of the Arduino, excluding power and ground.
/*reader pin
*/
#include <SoftwareSerial.h>
SoftwareSerial Servos(10, 11); // RX is digital pin 10 (connect to TX of other device) * TX is digital pin 11 (connect to RX of other device)--we only need to connect pin 11
int n;//first random number
int m;//second random number
int threshold=30;//of ambient light
int targets=6;
int score=0;//initialized to 0
int time=1000;//time to hit target once it pops up
int TIME=60000;//total time for game==1 minute--and yes 60000 fits into an int
int TIME_Played=0;//initialize time played
int anodePin=4;//all led's use this pin for their long leg
int Apin=14;//A0
int Bpin=15;//A1
int Cpin=16;//A2
int Dpin=17;//A3
int Epin=18;//A4
int cathodePin0=19;//A5
int A;
int B;
int C;
int D;
int E;
int delays[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //starts all delays at 0
int tworandom(int i,int j);//random funcition generator for second number
int reads(int led);//read led
int readsavg(int n, int led);//takes average of n readings for led
int reset(int servonum);//initialize current servo, reset delay of current servo, assign a new serov to n or m
int scores(int servonum);//score when you shoot (shooting aliens==++)
int scored(int servonum);//score when you don't shoot (don't shoot humans==++)
void talk(int command, int servo, int data1, int data2);
void rotate(int servo,int angle);
void initialize(void);//sets initial servo positons
int convert(int i);
void setup()
{
//deactivates pullup resistors
_SFR_IO8(0x35) |= 4;
_SFR_IO8(0x35) |= (1<<4);
randomSeed(analogRead(0));//select start point of random number chain before setting pin A0 to output--reading analog should allow for random start in chain--wiring led to there may get rid of random start--will just cause every game to be the same--will change for final design, but for this week it would not be a problem
n=random(targets); //choose first random number
m=tworandom(n,m); //choose second random number based off of the first
pinMode(anodePin, OUTPUT); //set pins associated with led light sensors to outputs
pinMode(Apin, OUTPUT);
pinMode(Bpin, OUTPUT);
pinMode(Cpin, OUTPUT);
pinMode(Dpin, OUTPUT);
pinMode(Epin, OUTPUT);
pinMode(cathodePin0, OUTPUT);
digitalWrite(anodePin, HIGH);
digitalWrite(cathodePin0,LOW);
digitalWrite(Apin,LOW);
digitalWrite(Bpin,LOW);
digitalWrite(Cpin,LOW);
digitalWrite(Dpin,LOW);
digitalWrite(Epin,LOW);
initialize();
Serial.begin(9600);//set up serial communication to monitor
Servos.begin(9600);
}
void loop(){
rotate(m,0);//pop up the first two servos
rotate(n,0);
Serial.print("n and m are");
Serial.print(n);
Serial.println(m);
int number=3;//number of times led is read
//all delays initialized at 0 or reset to 0 in "reset"
delays[m]=delays[m]+(2*number*50);//each read delays 50 so n times 50 is full delay
delays[n]=delays[n]+(2*number*50);
//read sensors
int i = readsavg(number, n);//servo will be 0 to 5 but led is 14 to 19
int j = readsavg(number, m);
if((i<threshold)&&(i>0)){
//you hit target n
Serial.println("You hit n");
scores(n);
n=reset(n,m);
/*delaysn=0;
initialize(n);
n=tworandom(m);//*/
}
if((j<threshold)&&(j>0)){
Serial.println("You hit m");
//you hit target m
scores(m);
/*delaysm=0;
initialize(m);
m=tworandom(n);*/
m=reset(m,n);
}
if((delays[n]>time)&&(delays[m]>time)){
Serial.println("ran out of time 0");
/*delaysn=0;
delaysm=0;
initialize(m);
initialize(n);
n=random(targets); //choose first random number
m=tworandom(n); //choose second random number based off of the first*/
n=reset(n,m);
m=reset(m,n);
}
if(delays[n]>time){
Serial.println("ran out of time 1");
//you ran out of time for target n
scored(n);
/*delaysn=0;
initialize(n);
n=tworandom(m);//*/
n=reset(n,m);
}
if(delays[m]>time){
Serial.println("ran out of time 2");
//you ran out of time for target m
scored(m);
/*delaysm=0;
initialize(m);
m=tworandom(n);*/
m=reset(m,n);
}
TIME_Played=TIME_Played+(2*number*50);
if(TIME_Played<TIME){
Serial.print("Game over. Your score is");
Serial.print(score);
while(1){
}
}
}
//////////////////////
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
///////////////////////////////////////////////////////
int tworandom(int i,int j){
//i is the number staying the same j is the one you are changing
//chooses second random number that is not the same as the fist or equal to that of its pair
int k=0;
k=random(targets);//not redundant--if i is not in the first position setting m to 0 at first would cause it to be 0 almost always
while(((k%(targets/2))==(i%(targets/2)))||(k==j)){
/*((k-3)==i)||(k==i)||((k+3)==i)||(k==j)*/
k=random(targets);
}
return k;
}
int reads(int led){
int val = 0;
int vcc=anodePin;
convert(led);//get address of led
//set multiplexer's to read that address
digitalWrite(Apin, A);
digitalWrite(Bpin, B);
digitalWrite(Cpin, C);
digitalWrite(Dpin, D);
digitalWrite(Epin, E);
digitalWrite(vcc, HIGH);
digitalWrite(cathodePin0, LOW);
/*Serial.print(A);
Serial.print(B);
Serial.print(C);
Serial.print(D);
Serial.println(E);*/
//already emitting light
delay(50);
//switch potentials -- charge LED to -5V
digitalWrite(vcc, LOW);
digitalWrite(cathodePin0, HIGH);
//measure time for potential to equalize (for cathode to be LOW)
//switch pinmode
pinMode(cathodePin0, INPUT);
//measure time it takes for cathodePin to go to zero
//this value probably depends on the chip clock or something
while((digitalRead(cathodePin0) != 0)&&(val<100)){
delay(1);
val++;
}
pinMode(cathodePin0, OUTPUT);
digitalWrite(vcc, HIGH);
digitalWrite(cathodePin0, LOW);
//Serial.println(val, DEC);
return val;
}
int readsavg(int n, int led){
int val=0;
for(int i=0; i<n; i++){
val=val+reads(led);//read n times and sum
}
val=val/n;//divide by n for average
return val;
}
int reset(int servonum1, int servonum2){
rotate(servonum1,90);//reset to position
delays[servonum1]=0;//reset delays
int j=tworandom(servonum2,servonum1);//change 1 based on 2
}
int scores(int servonum){
//scores==score when shot
if(servonum<=(targets/2)){
//servos 0, 1, 2 are humans
score--;//don't shoot humans
}
if(servonum>((targets/2))){
//servos 3, 4, 5 are aliens
score++;//do shoot aliens
}
}
int scored(int servonum){
//scored==scored when did not shoot
if(servonum<=(targets/2)){
//servos 0, 1, 2 are humans
score++;//good you did not shoot the humans
}
if(servonum>((targets/2))){
//servos 3, 4, 5 are aliens
score--;//baka, you forgot to shoot the aliens--have you seen Independence Day?
}
}
//////////////////////
////////////////////
//Servo Controller
void talk(int command, int servo, int data1, int data2){
/*
This uses the pololu portocol for controlling the servos--the shorting block must be removed for
these commands to work--I say this twice, because it is important.
The data 1 is lsb and data 2 is msb, it ignores the first bit, and the units in 1/4 micro seconds.
For example, the code uses 0x70, 0x2E->in binary 00111000, 00101110 to indicate 6000 1/4 micro seconds, which is lsb: 0111000, msb:
0101110, but together in proper oder reads as 0x1770.
This is further 1500 microseconds which is the 90 degree position--The conversion from degrees to microseconds is covered below.
*/
Servos.write(0xAA); //start byte
Servos.write(0x0C); //device id which is 12 in decimal for the 24 serial servo controller
Servos.write(command); //command number
Servos.write((byte)servo); //servo number (0-23)
Servos.write((byte)data1); //data 1--lsb--lowest 7 bits
Servos.write((byte)data2); //data 2--msb--highest 7 bits
delay(75);
}
/* I made this cheat sheet of postions and inputs until a proper conversion was found,
it discusses how to convert from degrees to microseconds and then to proper bits need to be sent:
Microseconds are found by multiplying by 11 and then adding 500 to degrees--remember that the controller
takes ins quarter of a microsecond (four times this number) though and discrads the
first bit of data of each data byte (i.e. send the lowest 7 bits with a leading 0 and then
the highest 7 bits with a leading 0)
The afore said covnversion is found by noting that the signals to the servo controller vary
from 500 (0) to 2500 (180). Thus to get zero subtract 500. To get everything else divide 2000 by 180.
The result is not exactly 11, but the error is very slight.
(microseconds--least significant bit, most significant bit)
500--0X50,0X0F->about 0 degrees
700--0X0F,0X15->18
750--0X38,0X17->22
800--0X00,0X19->27
1000--0X20,0X1F->45
1200--0X40,0X25->63
1500--0X70,0X2E->about 90 degrees
1800--0X20,0X38->118
2500--0X10,0X4E->about 180 degrees
*/
/////////////////////////////////////////////////////
void rotate(int servo,int angle){
//Uses talk() to send servo to some angle
int converted=(angle*11+500)*4;//in quarter microseconds
int data2=converted>>7;//most significant bit
int data1=converted&0x7F;//least significant bit
talk(0x04, servo, data1, data2);//sends data
}
void initialize(void){
//set all servos to an inital 90 degrees. Allows for rotation in either direction of 90 degrees
for(int i=0; i<targets; i++){
rotate(i,90);
}
delay(250);
}
int convert(int i){
//converts a decimal number from 0 to 17, inclusively, to binary
A=i/16;
if(A==1){
i=i-16;
B=0;
C=0;
D=0;
E=i;
}
if(A==0){
B=i/8;
if(B==1){
i=i-8;
C=i/4;
if(C==1){
i=i-4;
D=i/2;
if(D==1){
i=i-2;
E=i;
}
if(D==0){
E=i;
}
}
if(C==0){
D=i/2;
if(D==1){
i=i-2;
E=i;
}
if(D==0){
E=i;
}
}
}
if(B==0){
C=i/4;
if(C==1){
i=i-4;
D=i/2;
if(D==1){
i=i-2;
E=i;
}
if(D==0){
E=i;
}
}
if(C==0){
D=i/2;
if(D==1){
i=i-2;
E=i;
}
if(D==0){
E=i;
}
}
}
}
}