Mesa juego de Futbol (7 / 9 paso)

Paso 7: Código de Arduino

#define motor1 10
#define motor2 11

#define distThresh 50

Declaraciones de variables globales
int s1Baseline;
int s1Tolerance;
const int numRecRead = 10;
int recReading [numRecRead];
int recReadCur;

void setup () {}
Serial.Begin(9600);           Biblioteca Serial a 9600 bps

pinMode (sensor1, entrada);

pinMode (motor1, salida);
pinMode (motor2, salida);

resetRecVal();

generador de números aleatorios de semilla por dificultad
randomSeed(analogRead(0));

Calibrar sensores y sistema de referencia y tolerancias
int s1Cal [2];
calibrateSensor (sensor1, s1Cal);
s1Baseline = s1Cal [0];
s1Tolerance = s1Cal [1];

}

void loop() {}
int s1Val, s1ValAvg;
doble s1Dist;
Serial.println(digitalRead(Center));
Obtener valores de los sensores
s1Val = checkSensor (sensor1, s1Baseline, s1Tolerance);
s1ValAvg = averageReading(s1Val);
Serial.println(s1Val);
Si (s1ValAvg > distThresh) {}
s1Dist = sensorToDistance(s1Val);

Si moveGoalie(5) (s1Dist < 14);  moverse a la derecha
else if (s1Dist > 18 & & s1Dist < 32) moveGoalie(-5);  mover a la izquierda

resetRecVal();
}
}

Devuelve el valor del sensor si hubiera lectura (es decir, bola pasada enfrente)
o 0,0 si ninguna lectura fue tomada (es decir, la pelota no pasó)
sensorPin - el pin del sensor para comprobar
línea de base - que los sensores "no lectura" valor
tolerancia - el umbral de la línea de fondo que se debe considerar una lectura
(es decir, si el valor está dentro (base +-umbral no informe
una lectura)
int checkSensor (int sensorPin, base doble, doble tolerancia) {}
sVal doble = analogRead(sensorPin);  Valor reportado por el sensor
Si (abs (línea de base - sVal) < tolerancia) / / si la lectura está dentro de tolerancia
return 0;                          no volver "lectura"
volver sVal;                          lo contrario, devuelve el valor
}

Devuelve la distancia correspondiente a la lectura del sensor
sensorVal - valor leído por el sensor
doble sensorToDistance (int sensorVal) {}
doble escala = 2050;
doble expon = 1.0/0,85;
doble dist = pow((scale/sensorVal), expon);

Si (dist > 35) dist = 35; //normalize dist

volver dist;
}

Calibra el sensor (funcionamiento en la configuración)
Toma los puntos de calibración del sensor para encontrar el valor medio de
y el ruido en las lecturas de sensor
sensorPin - Pin del sensor a calibrar
calData - int [] valores a almacenar en la
void calibrateSensor (int sensorPin, int calData[]) {}
int numReadings = 300;  300 puntos de calibración
int datos [numReadings];  utilizado para almacenar los puntos de calibración
int i;
minVal int = 10000;  inicializar el valor mínimo de alta
int maxVal = -1;  inicializar el valor máximo bajo

para (i = 0; i < numReadings; ++ i) {}
int t = analogRead(sensorPin);  leer datos de la muestra
datos [i] = t; rellenar la matriz de datos

Récord min y max sensor lecturas
Si (t < minVal) //if t es menor que la actual minVal
minVal = t;  reemplazar el minVal
Si (t > maxVal) //if t es mayor que maxVal
maxVal = t; reemplazar el maxVal
}

Buscar la difusión de los datos
int extensión = maxVal - minVal;

Encontrar la media de los datos de ejemplo
doble media = 0;
para (i = 0; i < numReadings; ++ i)
significa datos += [i];
significa / = numReadings;

calcular std dev
stddev doble = 0;
para (i = 0; i < numReadings; ++ i)
StdDev += pow ((datos [i] - promedio), 2);
StdDev = numReadings;
StdDev = sqrt(stddev);

retorno [media, extensión]
calData [0] = media;
calData [1] = stddev * 2;
retorno;

}

parada de 0
10 - rápido
< 0 izquierda
> Derecho 0
void moveGoalie (int dir) {}
int mag = map(abs(dir), 10, 0, 0, 255);
int retMag = mapa (abs ((dir + 4)/4.0), 4, 14, 100, 255); volver más despacio

Si (dir > 0) {}
analogWrite (motor1, mag);
analogWrite (motor2, 0);
Delay(100);
analogWrite (motor1, 0);
analogWrite (motor2, 0);
Delay(1000);
analogWrite (motor1, 0);
analogWrite (motor2, retMag);
Delay(200);
}
else if (dir < 0) {}
analogWrite (motor1, 0);
analogWrite (motor2, mag);
Delay(300);
analogWrite (motor1, 0);
analogWrite (motor2, 0);
Delay(1000);
analogWrite (motor1, retMag);
analogWrite (motor2, 0);
Delay(300);
}

parada de portero
analogWrite (motor1, 0);
analogWrite (motor2, 0);
}

int averageReading (int newVal) {}
% recReadCur = (numRecRead - 1);

recReading [recReadCur ++] = transfondo;

int suma = 0;
válido de int = 0;
para (int i = 0; i < numRecRead; ++ i) {}
Si (recReading [i] > 0) ++ válido;
suma += recReading [i];
}

Si (válido < 7) return 0;

volver (suma/válido);
}

void resetRecVal () {}
para (int i = 0; i < numRecRead; ++ i) //initialize recRead
recReading [i] = 0;
recReadCur = 0;
}