Moviendo un motor paso a paso bipolar.

Este es el programa más simple para mover un motor bipolar. Lo único que hace es girar en un sentido de forma indefinida. Sirva de punto de partida para vuestros programas.

#define Motor_Pin1 8
#define Motor_Pin2 9
#define Motor_Pin3 10
#define Motor_Pin4 11

int tiempo = 5;

void setup()
{
  pinMode(Motor_Pin1, OUTPUT);
  pinMode(Motor_Pin2, OUTPUT);
  pinMode(Motor_Pin3, OUTPUT);
  pinMode(Motor_Pin4, OUTPUT);
}

void loop()
{
  digitalWrite(Motor_Pin1, HIGH);
  digitalWrite(Motor_Pin2, LOW);
  digitalWrite(Motor_Pin3, LOW);
  digitalWrite(Motor_Pin4, LOW);
  delay (tiempo);
  digitalWrite(Motor_Pin1, LOW);
  digitalWrite(Motor_Pin2, HIGH);
  digitalWrite(Motor_Pin3, LOW);
  digitalWrite(Motor_Pin4, LOW);
  delay (tiempo);
  digitalWrite(Motor_Pin1, LOW);
  digitalWrite(Motor_Pin2, LOW);
  digitalWrite(Motor_Pin3, HIGH);
  digitalWrite(Motor_Pin4, LOW);
  delay (tiempo);
  digitalWrite(Motor_Pin1, LOW);
  digitalWrite(Motor_Pin2, LOW);
  digitalWrite(Motor_Pin3, LOW);
  digitalWrite(Motor_Pin4, HIGH);
  delay (tiempo);
}


Ánimo, y a ver si este programa de 5 pelado, se convierte en un programa de 10.

Este otro programa, lo he hecho para aunar todas las técnicas para alimentar un motor bipolar, en el que podemos cambiar los parámetros, para variar la velocidad, el par, los pasos, etc....
Como siempre, le he quitado los comentarios, para que penseis, y penseis, y penseis..... y como podeis ver, poco código para hacer más que el programa anterior.

#define Motor_Pin1 8
#define Motor_Pin2 9
#define Motor_Pin3 10
#define Motor_Pin4 11

/*****************************************************************************************************************
 ************************************** parametrización del motor ************************************************
 *****************************************************************************************************************/
#define pasospv    4096       //Pasos por vuelta del reductor
#define vueltas    1          //Número de vueltas que queremos que de el motor
#define tipo_pasos 4          //Paso completo (4) o medio paso (8)
#define par_motor  0          //Bajo par (0) Alto par (1)

float delayTime = 8;          //Segundos por vuelta. Tiempo mínimo 5 segundos.

/*****************************************************************************************************************/

bool paso[8][4]= {{1,0,0,0},  
                  {1,1,0,0},
                  {0,1,0,0},
                  {0,1,1,0},
                  {0,0,1,0},
                  {0,0,1,1},
                  {0,0,0,1},
                  {1,0,0,1}};

void setup()
{
  for (int i = 0; i <= 3; i++){
    pinMode(i+8,OUTPUT);
  }
  delayTime = ((((delayTime * 1000)/4096)*(8/tipo_pasos))*1000);  
}



void loop()
{
  for (int k = 0; k < ((pasospv/8)*vueltas); k ++){               
    for (int i = par_motor; i < 8; i = i + (8/tipo_pasos)){       
      for (int j = 0; j < 4; j ++){                               
        digitalWrite(j+8, paso[i][j]);
      }
      delayMicroseconds (abs (delayTime));                        
    }
  }
  delay (2000);
}

TRABAJANDO CON ARRAYS

El código que adjunto más abajo está sin comentarios, pero ha sido explicado en clase, por lo que no estaría mal que ahora lo explicaseis vosotros.
El código compila perfectamente, por lo que con un copiar pegar lo podeis meter en vuestro IDE, y hacer pruebas, cambios, y todo lo que haga falta para comprenderlo mejor.

Y como no, un poco de tarea fácil. Este programa introduce los números del 1 al 10 en un array, empecemos por cambiar eso, y ahora meterá las decenas hasta el 100 (10,20,30.....100) y seguidamente, sorpresa, no los sumaremos, los invertiremos dentro del array, se me acaba de ocurrir, y cuando digo que los invertiremos digo eso, invertirlos, del 100 al 10, y no pido repetir el algoritmo invertido, no, eso sería muy fácil, me interesa más que el programa invierta el contenido del array, haya lo que haya dentro del array. Intentemos no utilizar demasiada memoria, variables, y código. Seguro que se nos ocurre un algoritmo interesante.

Si veo que sale fácil, cosa que estoy seguro, a mitad de semana igual se me ocurre algo nuevo.

______________________________________________________________________

/* SUMA DE NUMEROS DE UN ARRAY */

int count=0;
int NUMEROS[10];
bool FLAG = 1;
int RESULTADO = 0;

void setup()
{
pinMode(8,INPUT);
Serial.begin(9600);
Serial.println("PROGRAMA DE SUMA DE LOS NÚMEROS DE UN ARRAY");
Serial.println("");
}

void loop()
{
if (digitalRead(8) & FLAG){
Serial.print("Pulsado botón____ ");
delay (2);
count ++;

Serial.print("Pulsaciones = ");
Serial.println(count);

NUMEROS[count -1]=count;

Serial.print("NUMEROS[");
Serial.print(count-1);
Serial.print("] = ");
Serial.println(NUMEROS[count-1]);
Serial.print("\t");


FLAG = 0;
}

if (count == 10){
Serial.print("SUMANDO LOS NÚMEROS DEL ARRAY - ");

for (int i = 0; i < 10; i ++){
RESULTADO = RESULTADO + NUMEROS[i];
Serial.print("* ");
delay(250);
}

Serial.print("\t");
Serial.print("RESULTADO = ");
Serial.println(RESULTADO);


count = 0;
for (int i = 0; i < 10; i ++)NUMEROS[i] = 0;
RESULTADO = 0;
}

if (!digitalRead(8)) FLAG = 1;
}

Motor Bike Robot