Tests de la tarjeta

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 */


// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin 13 as an output.
  pinMode(3, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(3, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);              // wait for a second
  digitalWrite(3, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);              // wait for a second
}

/*
test de prueba del pulsador de EduBasica
Test sketch for switch
julio 2013 - Manuel Hidalgo
junio 2015 - Pablo Garcia
programa de dominio publico
*/

//asignacion de etiquetas // labels
int pinPulsador = 2; // pin pulsador // pin for the switch
int ledR = 5; // pin Red LED // pin for the red LED

//declaracion de variables/variables
int estado;    //guarda el estado del pulsador // for storing the switch's state (ON/OFF)

void setup() {
  //configuracion de E/S a los pines // INPUT/OUTPUT setup for pins
  pinMode(ledR, OUTPUT);      
  pinMode(pinPulsador, INPUT);     
}

void loop(){
  // lee el estado del pulsador // reads the state of the switch
  estado = digitalRead(pinPulsador);

  //Si el pulsador ON // if switch is ON (pressed)
  if (estado == HIGH) {     
    // led rojo ON   // red LED ON 
    digitalWrite(ledR, HIGH);  
  } 
  else { //IF switch is OFF (not pressed)
    // led rojo OFF:
    digitalWrite(ledR, LOW); 
  }
}

/*Test del potenciometro
 En este test tenemos: 
 Entrada analogica, salida analogica, salida puerto serie
 Lee la entrada analogica A0, potenciometro, mapea el resultado a un rango de 0 a 255,
 y lo utiliza para generar PWM en el pin D5.
 Tambien escribe los datos en el monitor serie del IDE.
////////////////////////////////////////////////////////////
In this test:
 *Analog input from the pot (through analog to digital converter) A0.
 *Maps the reading from 0-1023 to 0-255.
 *Generates the PWM over D5.
 *Writes the data on serial monitor.
 *Analog output (using PWM through a digital pin) pin5.
 
 created 29 Dec. 2008
 modified 9 Apr 2012
 by Tom Igoe
 
 This example code is in the public domain.
 
 Adaptado para el test del potenciometro de EduBasica 
 Manuel Hidalgo - LeoBot. Julio 2014
 Pablo Garcia. May 2015
 
 */

// labels for the pins
const int analogInPin = A0;  // Analog input pin that the potentiometer is attached to
const int analogOutPin = 5; // Analog output pin that the LED is attached to

int sensorValue = 0;        // value read from the pot
int outputValue = 0;        // value output to the PWM (analog out)

void setup() {
  // initialize serial communications at 9600 bps:
  Serial.begin(9600); 
}

void loop() {
  // read the analog in value:
  sensorValue = analogRead(analogInPin);            
  // map it to the range of the analog out:
  outputValue = map(sensorValue, 0, 1023, 0, 255);  
  // change the analog out value:
  analogWrite(analogOutPin, outputValue);           

  // print the results to the serial monitor:
  Serial.print("potenciometro/pot = " );                       
  Serial.print(sensorValue);      
  Serial.print("\t LED rojo/red = ");      
  Serial.println(outputValue);   

  // wait 10 milliseconds before the next loop
  // for the analog-to-digital converter to settle
  // after the last reading:
  delay(10);                     
}

/*Test del sensor LDR
 En este test tenemos: 
 Entrada analogica, salida analogica, salida puerto serie
 Lee la entrada analogica A1, LDR,adapta y mapea el resultado a un rango de 0 a 255,
 y lo utiliza para generar PWM en el pin D5.
 Tambien escribe los datos en el monitor serie del IDE.
  
 El circuito:
 *Divisor de tension: +5V - R10 - LDR - masa.
 *Terminal del conectado a la entrada analogica A1. 
 * Led rojo conectado a D5, pin digital de salida.
////////////////////////////////////////////////////////////////////////////////// 
 Sketch Test for the LDR:
 *Analog input from the LDR (through analog to digital converter) A1.
 *Maps the reading from 0-1023 to 0-255.
 *Generates the PWM over D5.
 *Writes the data on serial monitor.
 *Analog output (using PWM through a digital pin) pin5.
   
 Manuel Hidalgo - LeoBot.  Julio 2014
 Pablo Garcia - May 2015
 */

// Etiquetas de identificacion de los pines // label for pins connections
const int inAnaLDR = A1;     // Entrada analogica sensor LDR // analog input for LDR
const int outAnaLedRojo = 5; // Salida analogica (PWM) al led rojo // analog output (using PWM) for red LED

int valorSensorLDR = 0;     // Lectura del valor del sensor LDR // for reading sensor's value
int valorPWM = 0;          // Valor de salida PWM (salida analogica) al pin 5. Led rojo // mapped value to 0-255

void setup() {
  // inizialización de comunicaciones monitor serie a 9600 bps: // init communications at 9600 bauds per second
  Serial.begin(9600); 
}

void loop() {
  // lee el valor analogico del LDR, A1. // reading on analog 1 pin
  valorSensorLDR = analogRead(inAnaLDR);            
  // mapea el rango de los valores de lectura del LDR, 
  //que pueden ser diferentes por la luz recibida (los 2 primeros datos se deben de cambiar)
  //al rango de valores de salida PWR en el pin 5 (salida analogica)
  ///////////////////////////////////////////////////////////////////////
  /*we have to map the read values to the PWM signal, but the input values will change with different light conditions
  so you have to check the values using the serial monitor to obtain an accurate low and high values (first 2 numbers) */
  valorPWM = map(valorSensorLDR, 808, 920, 0, 255);  
  // salida analogica PWM //write analog
  analogWrite(outAnaLedRojo, valorPWM);

  //Escribe los resultados en el monitor serie. // Writing the values over serial monitor
  Serial.print("valor entrada LDR / input value = ");  
  Serial.print(valorSensorLDR);      
  Serial.print("\t LED rojo/red = ");      
  Serial.println(valorPWM);   

  // Espera 10 milisegundos para que el conversor ADC haga la nueva lectura // waits 10 ms for the ADC makes a new reading
  delay(10);                     
}

/*
  Test del transistor controlado desde el pin 6
  Sirve para controlar dispositivos que necesitan más 
  intesidad de corriente que la que pueda proporcionar
  una salidad de Arduino (> 40mA).
  Ejemplo: relé, motor dc,...
  EL INTERRUPTOR DE CORRIENTE DE EDUBASICA TIENE QUE ESTAR EN POSICION ON
  /////////////////////////////////////////////////////
  Sketch test for TIP121 transistor connected though digital 6 pin
  Arduino is only giving 40mA, so you can use this to activate/deactivate
  another more powerful device as rele, dc motor...
  THE POWER SWITCH PROVIDEED ON EDUBASICA MUST TO BE ON 
  
  Manuel Hidalgo - LeoBot. Julio 2014
  Pablo Garcia. May 2015
*/

//Etiquetas de identificación de los pines // labels for pins
const int baseTrt = 6;    //salida digital, pin 6, conectado a la R6 de la base del transistor
                          //digital output, pin 6, connected to resistor R6 (in the base of the transistor)
const int pinLedV = 3;    //salida digital,pin 3, led verde // output for the green LED (on digital pin3)


void setup(){
  //configuracion de los pines // pin setup
  pinMode(baseTrt, OUTPUT);
  pinMode(pinLedV, OUTPUT);
}

void loop(){
  //Activamos el transitor // activates the transistor for 5 seconds
  digitalWrite(baseTrt,HIGH);
  digitalWrite(pinLedV,HIGH);  //led verde ON
  delay(5000);                //permanece activado 5s
  
  //Desactivamos el transistor //deactivate transistor for 5 seconds
  digitalWrite(baseTrt,LOW);
  digitalWrite(pinLedV,LOW);  //led verde OFF
  delay(5000);                //permanece desactivado 5s
}

/*
  Test del motor A controlado un puente en H
  del C.I. L293D
  Comprueba el funcionamiento del motor A  
  EL INTERRUPTOR DE CORRIENTE DE EDUBASICA TIENE QUE ESTAR EN POSICION ON
////////////////////////////////////////////////////////////
  Sketch Test for motorA controlled by L239D H bridge (600mA)
  THE POWER SWITCH PROVIDEED ON EDUBASICA MUST TO BE ON 
  
  Manuel Hidalgo - LeoBot  Julio 2014
  Pablo Garcia - May 2015
*/


//Etiquetas de identificación de los pines // labels for pins
//pines para controlar la direccion de giro // with 2 pins we control de spinning direction
const int motorA_Dir1 = 8;        
const int motorA_Dir2 = 9;
const int motorA_Velocidad = 10;  //salida PWM para controlar la velocidad // PWM for speed

//Variables
int vPWM = 155;    //valor de la velocidad en PWM // PWM speed

void forward(){
    //Activamos el motor A en un sentido de giro
  //spinning direction 1 (high-low)
  digitalWrite(motorA_Dir1,HIGH);
  digitalWrite(motorA_Dir2,LOW); 
  analogWrite(motorA_Velocidad,vPWM);
}
   
void backw(){
    //Activamos el motor A en un sentido de giro
  //spinning direction 1 (high-low)
  digitalWrite(motorA_Dir1,LOW);
  digitalWrite(motorA_Dir2,HIGH); 
  analogWrite(motorA_Velocidad,vPWM);
}

void stop(){
 //Paramos el motor durante 2s //stop for 2 secs
  //STOP (low, low)
  digitalWrite(motorA_Dir1,LOW);
  digitalWrite(motorA_Dir2,LOW);
}

void setup(){
  //configuracion de los pines //pins setup
  pinMode(motorA_Dir1, OUTPUT);
  pinMode(motorA_Dir2, OUTPUT);
}

void loop(){
  forward();
  delay(4000);              
  stop();
  delay(2000);
  backw();
  delay(4000); 
  stop();
  delay(2000);  
}

/*
  Test del motor B controlado un puente en H
  del C.I. L293D
  Comprueba el funcionamiento del motor B  
  Manuel Hidalgo - LeoBot
  Julio 2014
*/

//Etiquetas de identificación de los pines
const int motorB_Dir1 = 12;        //pines para controlar la direccion de giro
const int motorB_Dir2 = 13;
const int motorB_Velocidad = 11;  //salida PWM para controlar la velocidad

//Variables
int vPWM = 155;    //valor de la velocidad en PWM

void setup(){
  //configuracion de los pines
  pinMode(motorB_Dir1, OUTPUT);
  pinMode(motorB_Dir2, OUTPUT);
  
}

void loop(){
  //Activamos el motor B en un sentido de giro
  digitalWrite(motorB_Dir1,HIGH);
  digitalWrite(motorB_Dir2,LOW); 
  analogWrite(motorB_Velocidad,vPWM);
  delay(5000);                //permanece activado 5s
  
  //Paramos el motor durante 2 segundo
  digitalWrite(motorB_Dir1,LOW);
  digitalWrite(motorB_Dir2,LOW);
  delay(2000);
  
  //Activamos el motor B en un sentido de giro
  digitalWrite(motorB_Dir1,LOW);
  digitalWrite(motorB_Dir2,HIGH); 
  analogWrite(motorB_Velocidad,vPWM);
  delay(5000);                //permanece activado 5s
  
  //Paramos el motor durante 1 segundo
  digitalWrite(motorB_Dir1,LOW);
  digitalWrite(motorB_Dir2,LOW);
  delay(2000);
}

/*
Sketch Test for transforming EduBasica's analog input (POT or LDR)
into servo position
 */

// include the servo library
#include <Servo.h>

Servo myServo;  // create a servo object 
//select the analog input you want to use to control the pot
//A0= potentiometer ,  A1=LDR
int const potPin = A1; // analog pin used to connect the potentiometer or LDR
int potVal;  // variable to read the value from the analog pin 
int angle;   // variable to hold the angle for the servo motor 

void setup() {
  myServo.attach(7); // attaches the servo on Edubasica's pin 7 
  Serial.begin(9600); // open a serial connection to your computer
}

void loop() {
  potVal = analogRead(potPin); // read the value of the pot/LDR
  // print out the value to the serial monitor
  Serial.print("potVal: ");
  Serial.print(potVal);

  // scale the numbers from the pot 
  //angle = map(potVal, 0, 1023, 0, 179);
  // if you want to use the LDR the mapping depends on the light conditions
  angle = map(potVal, 800, 1000, 0, 179);
  Serial.print(", angle: "); // print out the angle for the servo motor 
  Serial.println(angle); 

  // set the servo position  
  myServo.write(angle);
  // wait for the servo to get there 
  delay(15);
}