Pasar librería de Arduino a AVRStudio (ATmega)

hola y gracias
Exactamente (y), solo para que el micro tenga forma de saber si por algún motivo el motor se atascó.


Ah... entiendo hay que pensar en una buena estructura de código para no tener cosas repetidas y que sea entendible.
Deberías tener una estructura conteniendo la info necesaria de cada motor, y las funciones para hacer funcionar el motor deberían usar esa información para manejar las entradas/salidas de la forma que corresponda.


Y cual es el problema con la velocidad?, así como esta trabaja muy lento?.
La velocidad la cambias con el delay de activación/desactivación de las salidas.
En tus rutinas estas utilizando _delay_us(2750); por ejemplo en la rutina xplus4.
Son 4 pasos con 8 delays -> 2750 us/delay * 8 delay / 4 pasos = 5500 us / paso = 5.5 ms/paso
Si tenes un motor de 400 pasos por revolución: 400 pasos / rev * 5.5 ms / paso * 1 s / 1000 ms = 2.2s /rev
1 rev/2.2s = 0.45 rev/s * 60 s/min = 27 rpm aprox
En fin, de esa forma aproximas la velocidad del motor de acuerdo al tiempo entre pasos, y claro, depende de los datos del motor (pasos por revolución).
Es decir, si con 2750 us tienes 27 rpm, con 2750/2 = 1375 us tendras 54 rpm aprox.

En cuanto a trabajar con timer, sí, podrías correr el código de secuencia de pasos (quizás usando una función similar a la que propuse :rolleyes:) en la rutina de interrupción del temporizador, y que el valor de comparación del comparador salga de la velocidad de rotación deseada del motor. Y con eso tu programa en el main solo tiene que setear cuando iniciar el movimiento (habilitando la interrupción y estableciendo la cuenta de pasos) y después el programa principal no se entera.
Pero quizás para hacer esto es difícil de hacer en este punto y para no complicarte seguí con los retardos, que no son para nada lo ideal pero bueno, no se muere nadie.




Ajá... a ver... entonces a través de los potenciómetros UART se fija la posición del móvil en la cuadrilla XY.
Después si querés que aumente la velocidad cuando más lejos esté la posición actual de la deseada, podrías hacer algo como:



Bueno, ya te dí bastante en que pensar, conclusión: velocidad depende del tiempo de retardo; ahora en este momento esta bien que pienses la estructura general del programa y decidas que parámetros de entrada y salida vas a manejar (tanto en el UART como en las funciones para mover los motores, etc).
gracias amigo muy pero muy educativo ., y sobre todo una enseñanza espectacular​
esto es algo que estamos armando con otro integrante del foro ., mi amigaso "" raulalberto1955 "" ., fui al taller a buscar los motores para probar​
tambien te muestro llos motores que tengo (son algunos ., no entran todos en la foto​
mis motores .jpg
y seguidamente te muestro los tres motores del proyecto., el que tiene la cinta ., es el de los amgulos ., los otros son para el movimiento de mesa ., todos son 1,8° ., 200 pasos y 12v​
motores pap utilizados en pruebas.jpg
esas bridas ., son para el movimiento de las guias ., que seria como el movimiento de un motor de limpiaparabrisas de un auto​
pero no giran (van y vienen) o sea que giran nada mas que unos 45° o 50° nada mas ., y tambien ., te muestro los driver que arme para estos​
tambien estube viendo con raul ., lo del desplazamiento delas guias ., que son guias de cajoneras de cocinas​
esas guias viene con unos gujes de plastico ., eso nos da un "juego o olgura" como que al cruzarce nos frena la guia​
la idea que dio raul es que remplacemos esos plasticos ., por rodamientos ., el asunro que al averiguar su precio ., es alto y mas si son 16 los voy a comprar ., pero por ahora no ., en todo caso quedamos con raul ., probarlas como estan., si hace falta mas torque cambiare los motores por otros mas grandes​
en cuanto al movimiento es si ., me estuve fijando en todo lo ultimo comentado ., viendo las librerias que poseo funcionado corectamente ., me parecio que esas funciones se puede agaptar cambiando algunas lineas​
hay una parte del codigo que no la publique ., que es la de na divicion de angulos en 360°​
te pongo un dibujo de como funciona eso​
Ver el archivo adjunto 144897
esto como mas o menos te explique antes ., hace un giro de 360° (casi 350° ) para luego volver a 0 ., y digo casi por lo siguiente​
es la definicion de la libreria figua asi​
PHP:
  // Cuántos pasos para Giro de 360 grados
  #define MOT_STEPS 192  // original 200
se supone que alli ., va la cantidad de pasos que nesesita para dar una vuelta​
se supone que alli tendria que figurar 200 pasos ., porque el motor es de 1,8° y 200 pasos por vuelta​
si te fijas dice o se declara el valor de 192., esto es porqu al principio ell dico soporte se podia des plazar con libertad hasta los 360°​
pero luego al hacer adaptaciones al uncillo ., nos topaba en el soporte ., y cuando giraba muy rapido al llegar lo golpeba​
entonses baje la cuenta de pasos a 192 y no como tendria que ser de 200 pasos​
esta cuenta de pasos se almacena en esta sentecia MOT_STEP​
PHP:
   for(i=0; i<=MOT_STEPS; i++)//Ahora busca la posición cero de nuevo!
   {
    MakeStep(0);
    MakeStep(0);
    _delay_ms(4);
    if(!(PR_SENSOR & (1<<PIN_SENSOR))) break;
   }
  for(i=0; i<=CORR_VAL; i++)//posición correcta con valor fijo si es necesario
   {
    MakeStep(CORR_DIR);
   }
 }
si le prestas atencion te daras cuenta que girao puede girar hacia la izquierda o la derecha ., y lleva la cuenta de los pasos (los decuenta o cuenta segun el caso​
y a mi se me ocurrio ., que podriamos reformr esta misma libreria y en concreto esta parte​
PHP:
//Seleccione la posición del angulo
extern void SetAngle( uint8_t Angle )
 {
  Soll1 = Angle*ANGLE_HALFSTEPS;
 }


/*
// Esto hace girar sólo en una dirección
void Check( void )
 {
  if(Ist!=Soll) 
   {
    MakeStep(0);
    Ist++;
    if(Ist>=MOT_STEPS) Ist=0; 
   }
 }
*/


// Comprueba si la rueda/Angulo tiene que ser girada
extern void CheckAngle( void )
 {
  if(Ist1<Soll1) 
   {
    if((Soll1-Ist1)<=(MOT_STEPS/2))	//Asumimos la dirección correcta, porque
     {					// que es menos o igual a un medio de rotación
      MakeStep(0);			//Girar a la derecha un paso =)
      Ist1++;
      if(Ist1>=MOT_STEPS) Ist1=0;
     } else {				// Rotación derecha llevaría demasiado tiempo ., si no
      MakeStep(1);			//girar la dirección de la rueda a la izquierda
      if(Ist1==0) Ist1=MOT_STEPS;
      Ist1--;
     }
   } 
  if(Ist1>Soll1) 
   {
    if((Ist1-Soll1)<=(MOT_STEPS/2))
     {
      MakeStep(1);
      if(Ist1==0) Ist1=MOT_STEPS; 
      Ist1--;     
     } else {
      MakeStep(0);
      Ist1++;
      if(Ist1>=MOT_STEPS) Ist1=0;  
     }
   }
 }


//Paso el motor en dirección definida
void MakeStep( uint8_t direction )
 {
  if(direction==0) 
   {
    Step1++;
    if(Step1>=8) Step1=0;
   } else {
    if(Step1==0) Step1=8;
    Step1--;
   }
  SetPort(Step1);
  _delay_ms(4);
 }
y por ejemplo podriamos definir la cantidad de pasos ala derecha (right) y a la izquierda (left) y quedaria declarado algo asi​
PHP:
  // Cuántos pasos para giro de right
  #define MOT_STEPS_right 25  // original 200


 // Cuántos pasos para giro de left
  #define MOT_STEPS_left 25  // original 200
de esa manera con mas o menos 25 pasos por direccion nos da los 90° (mas o menos eso no es problema) aca te pongo un dibujo de como sria en este caso​
en cuanto ala velocidad ., conviene que este separada del recorrido o distancia ., perque como em hizo ver raul habar piezas que si nesesitan velocidad y otras el mecanizado es muy lento ., pero puede ser como el ejemplo que pusiste vos mas atras que estaria perfecto​
funcionamiento eje 1.jpg
la cuestion es que habria que hacer una sola libreria ., porque las dos son iguales ., luego solo habria que cambiar la definicion de X por Y y listo​
te adjunto la libreria de eje Z ., tal cual la estamos usando( sin complicarte con la usart​
yo creo., que ahora si esta mas claro el asunto ., y muchas gracias de nuevo amigo
 

Adjuntos

  • libreria X Y stepper.rar
    22 KB · Visitas: 2
Última edición:
Ufff, que semana, recién ahora tengo un ratito. Disculpame locodelafonola por el faltazo, es que se vino una semana muy complicada (de esas que involucran abogados :cabezon: ).

...todos son 1,8° ., 200 pasos y 12v...
esas guias viene con unos gujes de plastico ., eso nos da un "juego o olgura" como que al cruzarce nos frena la guia....

¿Para eso no conviene poner fines de carrera?. Ah... más abajo veo que ya hay un sensor de cero/home (y).

...
y a mi se me ocurrio ., que podriamos reformr esta misma libreria y en concreto esta parte
O sea que en vez de pasos queres usar funciones con angulo, ¿de 0º a 350º sería?.

...codigo...
y por ejemplo podriamos definir la cantidad de pasos ala derecha (right) y a la izquierda (left) y quedaria declarado algo asi
PHP:
  // Cuántos pasos para giro de right
  #define MOT_STEPS_right 25  // original 200


 // Cuántos pasos para giro de left
  #define MOT_STEPS_left 25  // original 200
de esa manera con mas o menos 25 pasos por direccion nos da los 90° (mas o menos eso no es problema) aca te pongo un dibujo de como sria en este caso
Dibujo salvador :).
Ahora... esto es algo distinto de lo que se quería antes que era posicionar en una grilla cierto?, esto es controlar el ángulo de giro del eje motor.

en cuanto ala velocidad ., conviene que este separada del recorrido o distancia ., perque como em hizo ver raul habar piezas que si nesesitan velocidad y otras el mecanizado es muy lento ., pero puede ser como el ejemplo que pusiste vos mas atras que estaria perfecto

Si, la velocidad con que se dan los pasos depende del delay entre pasos.

la cuestion es que habria que hacer una sola libreria ., porque las dos son iguales ., luego solo habria que cambiar la definicion de X por Y y listo
te adjunto la libreria de eje Z ., tal cual la estamos usando( sin complicarte con la usart
Ah, entonces la cuestión es como estructurar el código para que el posicionador XY (ésto último que sería el eje Z), ¿es ese el problema?. No quiero empezar a escribir sin tener clara cual es la pregunta primero, que lo que no aclara oscurece.

yo creo., que ahora si esta mas claro el asunto ., y muchas gracias de nuevo amigo
Cuando quieras cumpa, por acá vamos a estar (si es que los abogados no me rompen la semana, que lo tiró).
 
hola ... y muchas gracias che ¡¡¡¡
¿Para eso no conviene poner fines de carrera?. Ah... más abajo veo que ya hay un sensor de cero/home (y).
exacto che ., la idea de los limites ., que tuviste vos ., desde el principio., es para mi lo mas acertado y logico​
O sea que en vez de pasos queres usar funciones con angulo, ¿de 0º a 350º sería?.
NO., NO NO ., NO y disculpame si me explique mal ., SON PASOS ., no angulos ., pero refejan un angulo​
si tenemos 200 pasos para un giro de 360° ., serian cuatro angulos de 90°​
esos 90° ., se consiguen con una cuenta de 50 pasos ., que multiplicado por cuato nos da los 200 pasos de giro completo ., para los 360°​
Dibujo salvador :).
Ahora... esto es algo distinto de lo que se quería antes que era posicionar en una grilla cierto?, esto es controlar el ángulo de giro del eje motor
no che sigue siendo lo mismo ., con la diferencia que la velocidad ( que no es problema en esa libreria) valla aparte​
por ahora dejemosla fija ., con cualquier valor de delay ., o el que tiene para tener una guia​
Si, la velocidad con que se dan los pasos depende del delay entre pasos.
por eso te decia que eso no es problema ., ya con la primer libreria que reforme ., era rapido ., asique esa parte ., la veremos despues ., es facil de ajustar​
lo que yo no me explique bien (mil disculpas amigo ) es en los pasos por eso entendiste grados ., si para la derecha tenemos 25 pasos ., volvenos al CERO ., y para la izquierda tenemos otros 25 paso​
eso nos da un total de 50 pasos., que son el equivalente a los 90°​
que si lo dividimos en izquierda y derecha., nos da un valos de 45° (mas o menos el motor es de 1,8° por paso​
por eso te decia lo de la libreria de ajustar a 25 pasos ., para cada sentido de giro​
Ah, entonces la cuestión es como estructurar el código para que el posicionador XY (ésto último que sería el eje Z), ¿es ese el problema?. No quiero empezar a escribir sin tener clara cual es la pregunta primero, que lo que no aclara oscurece.
te vuelvo a repetir ., solo habria que crear una sola libreria ., o sea X o Y porque las dos son exactamente iguales ., (solo cambia el comando del potenciometro virtual)​
si las dos librias que son iguales arrancan en el punto CERO ( confirmado por el censor) ., automaticamente el eje Z queda alineado (por eso no te preocupes ., es un ajuste mecanico ., no interviene electronica ni motores) tranquilo amigo​
Cuando quieras cumpa, por acá vamos a estar (si es que los abogados no me rompen la semana, que lo tiró)
amigaso no es problema ., espero que puedas resolver eso "quilombitos" con los "cuervos" ., de una manera beneficiosa ., para vos un abrazo ., y nuevamente gracias​
....... juan
 
Un apunte sobre el programa. He hecho una modificación sobre el código que habías puesto a modo de idea. Es sólo eso una idea, por si te sirve de algo.
La he aplicado sólo al minus16, pero con un poco de imaginación la puedes pasar para todo el programa.
No lo he compilado ni lo puedo probar, pero como idea de como se puede hacer sin "copia/pega" puede valer
Código:
void yminus16(int cuantos_pasos){
  int pasos,cual;
  int valor_ptr,valor_pin;

  for(pasos = 0; pasos < cuantos_pasos;pasos++) {
    for(cual=8;cual > 4;cual--) {
        paso_minus(cual);
    }
  }
}  
void paso_minus(int cual) {
  int valor_ptr,valor_pin;

  valor_ptr = get_ptr(cual);
  valor_pin = get_pin(cual);     
  valor_ptr |=  (1<<valor_pin);
  set_ptr(valor_ptr);
  _delay_us(2750);
  valor_ptr = get_ptr(cual);
  valor_pin = get_pin(cual);     
  valor_ptr &= ~(1<<valor_pin);
  set_ptr(valor_ptr);
  _delay_us(250);

}

void set_ptr(int a_cual,int valor){

  switch(a_cual) {
    case 8: {PRT_COIL8 = valor;} break;
    case 7: {PRT_COIL7 = valor;} break;
    case 6: {PRT_COIL6 = valor;} break;
    case 5: {PRT_COIL5 = valor;} break;
  }

}

int get_ptr(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: {valor = PRT_COIL8;} break;
    case 7: {valor = PRT_COIL7;} break;
    case 6: {valor = PRT_COIL6;} break;
    case 5: {valor = PRT_COIL5;} break;
  }
return valor;
}  
int get_pin(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: {valor = PIN_COIL8;} break;
    case 7: {valor = PIN_COIL7;} break;
    case 6: {valor = PIN_COIL6;} break;
    case 5: {valor = PIN_COIL5;} break;
  }
return valor;
}



No sé si el "case" lo admitirá tu sistema, pero si es C debería poder con él.
La función yminus16 debería pasar a llamarse yminus y funcionaría cambiando el nº de pasos.
Espero que sirva de algo.
 
Última edición:
Otro apunte: he puesto las variables tipo int, pero si tu sistema lo admite pueden ser unsigned char (¿8 bits, no?)



Después de hacer una función que haga uno de los cuadrantes, pues igual hacemos lo mismo con todos:
Código:
#include <avr/io.h>
  #include <stdint.h>
  #include <avr/interrupt.h>
  #include <util/delay.h>
  #include <stdio.h>
  #include "lib_X_Y.h"


#define XTAL 8000000


//************ Programa principal MAIN ***********//
int main(void)
{
    cli();




// Inicializar Puertos 
 void Init_X_Y_port( void )
 {
  
  DDR_COIL1 |= (1<<PIN_COIL1);
  DDR_COIL2 |= (1<<PIN_COIL2);
  DDR_COIL3 |= (1<<PIN_COIL3);
  DDR_COIL4 |= (1<<PIN_COIL4);
  DDR_COIL5 |= (1<<PIN_COIL5);
  DDR_COIL6 |= (1<<PIN_COIL6);
  DDR_COIL7 |= (1<<PIN_COIL7);
  DDR_COIL8 |= (1<<PIN_COIL8);
  
   
 }

// ***** inicializacion del timer****//
void init_timer(){
        TCCR0|=(1<<CS02)|(1<<CS00); //TCCR0|= (1<<CS02);    // Precontador 256
        TIMSK|=(1<<TOIE0);    // desbordamientos de la interrupción
            
}



   
   // init_timer();    // Establecer el temporizador
    Init_X_Y_port();// inizialisa las salidas  
   
    sei();

    for(;;)
       {
       
    
  
//****** inicia funcion 4 solamente ******//
       yplus(4);
       xplus(4);
       yplus(4);
      xminus(4);
      yminus(4);
       xplus(4);
      yminus(4);
      xminus(4);  
       yplus(16);
       xplus(16);
       yplus(16);
      xminus(16);
      yminus(16);
       xplus(16);
      yminus(16);
      xminus(16);     

     }          
 
    };


void xplus(int cuantos_pasos){
  int pasos,cual;
  
  for(pasos = 0; pasos < cuantos_pasos;pasos++) {
    for(cual = 1;cual < 5;cual++) {
        paso(cual);
    }
  }
}

void xminus(int cuantos_pasos){
  int pasos,cual;
  
  for(pasos = 0; pasos < cuantos_pasos;pasos++) {
    for(cual=4;cual > 0;cual--) {
        paso(cual);
    }
  }
}  

void yplus(int cuantos_pasos){
  int pasos,cual;
  
  for(pasos = 0; pasos < cuantos_pasos;pasos++) {
    for(cual = 5;cual < 9;cual++) {
        paso(cual);
    }
  }
}

void yminus(int cuantos_pasos){
  int pasos,cual;
  
  for(pasos = 0; pasos < cuantos_pasos;pasos++) {
    for(cual=8;cual > 4;cual--) {
        paso(cual);
    }
  }
}  

/*
valor_ptr |= (1<<valor_pin);
valor_ptr &= ~(1<<valor_pin);
*/
void paso(int cual) {
  int valor_ptr,valor_pin;

  valor_ptr = get_ptr(cual);
  valor_pin = get_pin(cual);     
  valor_ptr |= (1<<valor_pin);
  set_ptr(valor_ptr);
  _delay_us(2750);
  //esta y la siguiente no harian falta, 
  //pero no sé si se altera el estado del BIT en otro sitio
  valor_ptr = get_ptr(cual);
  valor_pin = get_pin(cual);     
  valor_ptr &= ~(1<<valor_pin);
  set_ptr(valor_ptr);
  _delay_us(250);

}
//
//Le da valor al PTR
//
void set_ptr(int a_cual,int valor){
  switch(a_cual) {
    case 8: PRT_COIL8 = valor; break;
    case 7: PRT_COIL7 = valor; break;
    case 6: PRT_COIL6 = valor; break;
    case 5: PRT_COIL5 = valor; break;
    case 4: PRT_COIL8 = valor; break;
    case 3: PRT_COIL7 = valor; break;
    case 2: PRT_COIL6 = valor; break;
    case 1: PRT_COIL5 = valor; break;
  }
}
//toma el valor del PTR 
int get_ptr(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: valor = PRT_COIL8; break;
    case 7: valor = PRT_COIL7; break;
    case 6: valor = PRT_COIL6; break;
    case 5: valor = PRT_COIL5; break;
    case 4: valor = PRT_COIL8; break;
    case 3: valor = PRT_COIL7; break;
    case 2: valor = PRT_COIL6; break;
    case 1: valor = PRT_COIL5; break;
  }
return valor;
}  
//toma el valor de PIN
int get_pin(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: valor = PIN_COIL8; break;
    case 7: valor = PIN_COIL7; break;
    case 6: valor = PIN_COIL6; break;
    case 5: valor = PIN_COIL5; break;
    case 4: valor = PIN_COIL8; break;
    case 3: valor = PIN_COIL7; break;
    case 2: valor = PIN_COIL6; break;
    case 1: valor = PIN_COIL5; break;
  }
return valor;
}

P.D. Si vas a usar el código, primero repásalo!!! No estoy compilando ni repasando a fondo lo que escribo, así que SEGURO hay meteduras de pata.
Espero que en lo general te sirva.



Lo más interesante de este código es mostrar como voy descomponiendo en trozos con cada vez menos lineas.



Por último una función que engloba a cada una de cada cuadrante y un poco de orden en el main.
Espero que te sea util.

Código:
#include <avr/io.h>
  #include <stdint.h>
  #include <avr/interrupt.h>
  #include <util/delay.h>
  #include <stdio.h>
  #include "lib_X_Y.h"

#define XTAL 8000000
#define EJE_X 0
#define EJE_Y 1
#define PLUS true
#define MINUS false


//************ Programa principal MAIN ***********//
//He "ordenado" un poco el main
int main(void)
{
cli();
init_timer();    // Establecer el temporizador
Init_X_Y_port();// inizialisa las salidas  
sei();

//for(;;) //este for no lo entiendo
  
mover_motor(4,EJE_Y,PLUS);
mover_motor(4,EJE_X,PLUS);
mover_motor(4,EJE_Y,PLUS);
mover_motor(4,EJE_X,MINUS);
mover_motor(4,EJE_Y,MINUS);
mover_motor(4,EJE_X,PLUS);
mover_motor(4,EJE_Y,MINUS);
mover_motor(4,EJE_X,MINUS);

mover_motor(16,EJE_Y,PLUS);
mover_motor(16,EJE_X,PLUS);
mover_motor(16,EJE_Y,PLUS);
mover_motor(16,EJE_X,MINUS);
mover_motor(16,EJE_Y,MINUS);
mover_motor(16,EJE_X,PLUS);
mover_motor(16,EJE_Y,MINUS);
mover_motor(16,EJE_X,MINUS);

 
};

//Lo siguiente que se puede concentrar son las cuatro funciones en los ejes a una sola de mover motor 
void mover_motor(int cuantos_pasos,int eje,bool positivo_sn) {
  int pasos,cual;
  int paso_mayor,paso_menor;

  if(eje == EJE_X) {
      paso_menor=1;
      paso_mayor=4;
    }
    else { //si no es es Y ¿no?
      paso_menor=5;
      paso_mayor=8;
    }

  for(pasos = 0; pasos < cuantos_pasos;pasos++) {
    if(positivo_sn) {
      for(cual=paso_menor;cual < paso_mayor+1;cual++) paso(cual);
    }
    else {
     for(cual=paso_mayor;cual > paso_menor-1;cual--) paso(cual); 
    }
  }
}


/*
valor_ptr |= (1<<valor_pin);
valor_ptr &= ~(1<<valor_pin);
*/
void paso(int cual) {
  int valor_ptr,valor_pin;

  valor_ptr = get_ptr(cual);
  valor_pin = get_pin(cual);     
  valor_ptr |= (1<<valor_pin);
  set_ptr(valor_ptr);
  _delay_us(2750);
  //esta y la siguiente no harian falta, 
  //pero no sé si se altera el estado del BIT en otro sitio
  valor_ptr = get_ptr(cual);
  valor_pin = get_pin(cual);     
  valor_ptr &= ~(1<<valor_pin);
  set_ptr(valor_ptr);
  _delay_us(250);

}
//
//Le da valor al PTR
//
void set_ptr(int a_cual,int valor){
  switch(a_cual) {
    case 8: PRT_COIL8 = valor; break;
    case 7: PRT_COIL7 = valor; break;
    case 6: PRT_COIL6 = valor; break;
    case 5: PRT_COIL5 = valor; break;
    case 4: PRT_COIL8 = valor; break;
    case 3: PRT_COIL7 = valor; break;
    case 2: PRT_COIL6 = valor; break;
    case 1: PRT_COIL5 = valor; break;
  }
}
//toma el valor del PTR 
int get_ptr(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: valor = PRT_COIL8; break;
    case 7: valor = PRT_COIL7; break;
    case 6: valor = PRT_COIL6; break;
    case 5: valor = PRT_COIL5; break;
    case 4: valor = PRT_COIL8; break;
    case 3: valor = PRT_COIL7; break;
    case 2: valor = PRT_COIL6; break;
    case 1: valor = PRT_COIL5; break;
  }
return valor;
}  
//toma el valor de PIN
int get_pin(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: valor = PIN_COIL8; break;
    case 7: valor = PIN_COIL7; break;
    case 6: valor = PIN_COIL6; break;
    case 5: valor = PIN_COIL5; break;
    case 4: valor = PIN_COIL8; break;
    case 3: valor = PIN_COIL7; break;
    case 2: valor = PIN_COIL6; break;
    case 1: valor = PIN_COIL5; break;
  }
return valor;
}  
//Estas dos funicones no entiendo por que estaban en el main()
//pero si esto es lenguaje C se puede hacer así
// Inicializar Puertos 
 void Init_X_Y_port( void ) {
  DDR_COIL1 |= (1<<PIN_COIL1);
  DDR_COIL2 |= (1<<PIN_COIL2);
  DDR_COIL3 |= (1<<PIN_COIL3);
  DDR_COIL4 |= (1<<PIN_COIL4);
  DDR_COIL5 |= (1<<PIN_COIL5);
  DDR_COIL6 |= (1<<PIN_COIL6);
  DDR_COIL7 |= (1<<PIN_COIL7);
  DDR_COIL8 |= (1<<PIN_COIL8);
}
// ***** inicializacion del timer****//
void init_timer() {
  TCCR0|=(1<<CS02)|(1<<CS00); //TCCR0|= (1<<CS02);    // Precontador 256
  TIMSK|=(1<<TOIE0);    // desbordamientos de la interrupción
}
 
Última edición:
hola
Otro apunte: he puesto las variables tipo int, pero si tu sistema lo admite pueden ser unsigned char (¿8 bits, no?)



Después de hacer una función que haga uno de los cuadrantes, pues igual hacemos lo mismo con todos

P.D. Si vas a usar el código, primero repásalo!!! No estoy compilando ni repasando a fondo lo que escribo, así que SEGURO hay meteduras de pata.
Espero que en lo general te sirva.



Lo más interesante de este código es mostrar como voy descomponiendo en trozos con cada vez menos lineas.



Por último una función que engloba a cada una de cada cuadrante y un poco de orden en el main.
Espero que te sea util.
muchisimas gracias por la idea ., pero hay una sola funcion que me larga error en el compilador y es la siguiente​
PHP:
void mover_motor(int cuantos_pasos,int eje,bool positivo_sn) {
donde la funcion "" bool"" ., no entiendo en el uso que le diste​
tambien tube que definir el valor de "TRUE y FALSE"​
PHP:
#define PLUS true
#define MINUS false
 // *** establecer valor de WHILE  ***//
enum {false=0, true=1};
y para que veas te adjunto una captura de pantalla del compilador​
capture_07052016_185810.jpg
en lo que respecta a el ""FOR ()"" ., que no entendias ., es porque para las pruebas de movimiento elegi dos valores​
el 4 (positivo y negativo) y el 16 (positivo y negativo)​
ya que toda la libreria que pase ., me largaba error de exeso de lineas ., entonces use esos dos valores nada mas​
pero si la pude probar en lo fisico ( sin la UART claro)​
y si los motores se movian a mucha velocidad ( parece que vibran ., pero no ., van y vienen)​
 
Última edición:
Hice la entrada a esta función con un boolean a modo de ejemplo de como se puede hacer. Mi intención es más didáctica que práctica.
Puedes hacerlo con un int como EJE_X y EJE_Y.
en lo de los motores no puedo ayudarte, pero ¿has probado con diferentes valores en el delay?
 
hola y muchas gracias a los dos
Hice la entrada a esta función con un boolean a modo de ejemplo de como se puede hacer. Mi intención es más didáctica que práctica.
Puedes hacerlo con un int como EJE_X y EJE_Y.
en lo de los motores no puedo ayudarte, pero ¿has probado con diferentes valores en el delay?
bueno compile y probe la libreria resultante​
lo primero comprobe que faltaba el #include <stdbool.h> ., como dijo el compañero Nuyel ( me confie ., que estaba incuida y no me habia fijado)​
ahora ., hice varias pruebasy probe cambiando algunas cosas pero sigo sin tener salida en los puertos (PORT A)​
la idea es muy buena ., pero no logro comprender la funcion "BOOL" la verdad que esta libreria me esta dando muchisimos dolores de cabeza ., la del eje Z ., es muchisima mas compleja que esta (aparte de cumplir funciones adicionales) ., pero me funciona perfectamente​
claro que nesesito que la velocidad o ""delay" sea variable .,(pero que se pueda variar aparte) pero empeze con los movimientos primero ., con un delay fijo​
yo tambien pase ., otra libreria de arduino que usa botones o pulsadores., para variar la velocidad y el sentido de giro​
claro que cuando empiezo a implementar el comando con la UART y los poteciometros virtuales ., alli empiezan los problemas​
pero esto (pienso yo claro .,pecando de ignorante y inocente) ., no tendria porque ser tan complejo y dificultoso porque la idea es simple​
sobre 200 pasos de un motor para 360° ., necesito que se desplace 24 pasos a la derecha desde el centro ., y desde el centro 24 pasos a la izquierda​
aca un fracmento de la libreria de los botones ., la parte de aumentar y disminuir el delay​
PHP:
 uint16_t t=50535;          // valor de tiempo de espera para bucle de retardo
void keydly()             //  retardo de supresión de rebotes del pulsador
{
   uint8_t i;
   for(i=0;i<7;i++)

      _delay_loop_2(10000);   // función de biblioteca bucle de retardo con retardo fijo

}

void aumentarvelocidad()                 // aumentar la velocidad del motor

{

     // PORTB = 0x00;

   if(t>20535) t=t-2000;       // la disminución de valor de retardo de tiempo si su límite mínimo es

   if(t==20535) ;//PORTB = 0x01;  // no alcanzado. Para conocer el límite minimo dar una indicación sobre el LED3

}

void disminuirvelocidad()                   // disminuir la velocidad del motor

{

     // PORTB = 0x00;

   if(t<60535) t=t+2000;        // incrementar el valor de retardo de tiempo si su límite máximo no es

   if(t==60535) ;//PORTB = 0x02;   // alcanzado. Para conocer el límite máximo dar una indicación sobre el LED4

}
esa sera la parte de los DELAY"s la parte de los puertos del motor es esta​
PHP:
  void girosentidohorario()         //girar en sentido horario de motor

  {

    while(PINA==0xFF)   //aplicar secuencia de pulsos hasta que se pulsa ningún botón

          {

         PORTB=(1 << PB0);   //aplicar el pulso al 1 bobina

        _delay_loop_2(t);  //generar retardo de acuerdo con el valor de retardo de tiempo

         PORTB=(1 << PB1);   //aplicar impulsos a la siguiente bobina y del mismo modo

        _delay_loop_2(t);

         PORTB=(1 << PB2);

        _delay_loop_2(t);

         PORTB=(1 << PB3);

        _delay_loop_2(t);

        }           

    }

void girosentidoantihorario()    // gire en sentido antihorario del motor

                  {

   while(PINA==0x0F)   // aplicar secuencia de pulsos hasta que se pulsa ningún botón

                 { 

          PORTB=(1 << PB3);   // aplicar pulsos a última bobina

         _delay_loop_2(t);  // dar retardo de acuerdo con el valor de retardo de tiempo

          PORTB=(1 << PB2);  // aplicar próximos pulsos como por secuencia requerida

         _delay_loop_2(t);

          PORTB=(1 << PB1);

        _delay_loop_2(t);

          PORTB=(1 << PB0);

         _delay_loop_2(t);

              }                           

        }
tambien queda claro que si yo nesesito que refleje un angulo de 90° (mas o menos eso no es tan importante porque se corrije con la mecanica)​
y si tomamos en cuenta que los motores son de 200 pasos ., nesesito que gire solo 50 pasos para un angulo de mas o menos 90° reflejados​
hasta alli todo claro ., y digamos que (como lo mostre en el dibujo mas atras) ., divido el angulo de 90° en 2​
tengo el centro y 45° a la izquierda ., y desde el centro 45° a la derecha​
aunque parezca algo complicado ., si tomamos en cuenta que son 4 bobinas y cada una refleja un paso ., nesesito que se repita la secuencia 6 veces para cada lado​
claro que la cuenta me da 24 pasos ., y no los 25 pasos que tendrian que ser .,pero ese pequeño error de 1,8° (por paso) que faltaria ., se resuelve con el ajuste mecanico ( no es problema)​
talvez sea confuso el accionar ., pero porque funciona de dos maneras distintas ., y para empezar ., yo nesesito que se mueva acorde a como muevo o deslizo el potenciometro virtual​
no subo mas codigos ., de los que he probado ., para no llenar el post de cosas que no me funcionaron​
 
BOOL (boolean) es un tipo de variable. Es como un int o un char pero solo puede admitir dos valores "verdadero" y "falso". Se usa para definir dos estados. También puede ser "1" o "0".
Si te complica la vida, fijate en cómo está definido EJE_X y EJE_Y y hazlo con un int.
Este tipo de variables se usan cuando vas ha hacer una sentencia if del tipo "si no es burro, es burra".
No sé si me consigo explicar.
En cuanto al motor, yo que tu haría primero un programa que haga que de vueltas en un sentido y que le puedas regular la velocidad. Partiendo de ese programa se pueden ir cambiando cosas hasta dar con la solución buena.
Yo no me conformaría con hacer arreglos mecánicos; un motor paso a paso está pensado para poder ser controlado de manera exacta ¿no?.



Otra cuestión: estoy haciendo cosas a ciegas. ¿Que tal si pones la definición de PRT_COIL(1-8) PIN_COIL y DDR-COIL (y todas que falten en el código). Si veo las definiciones igual lo entiendo mejor y te puedo ayudar mejor.
Y una última: me acabo de fijar en el código que y hay un error en estas tres funciones. A ver si así está más correcto
Código:
void set_ptr(int a_cual,int valor){
  switch(a_cual) {
    case 8: PRT_COIL8 = valor; break;
    case 7: PRT_COIL7 = valor; break;
    case 6: PRT_COIL6 = valor; break;
    case 5: PRT_COIL5 = valor; break;
    case 4: PRT_COIL4 = valor; break;
    case 3: PRT_COIL3 = valor; break;
    case 2: PRT_COIL2 = valor; break;
    case 1: PRT_COIL1 = valor; break;
  }
}
//toma el valor del PTR 
int get_ptr(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: valor = PRT_COIL8; break;
    case 7: valor = PRT_COIL7; break;
    case 6: valor = PRT_COIL6; break;
    case 5: valor = PRT_COIL5; break;
    case 4: valor = PRT_COIL4; break;
    case 3: valor = PRT_COIL3; break;
    case 2: valor = PRT_COIL2; break;
    case 1: valor = PRT_COIL1; break;
  }
return valor;
}  
//toma el valor de PIN
int get_pin(int a_cual){
  int valor;

  switch(a_cual) {
    case 8: valor = PIN_COIL8; break;
    case 7: valor = PIN_COIL7; break;
    case 6: valor = PIN_COIL6; break;
    case 5: valor = PIN_COIL5; break;
    case 4: valor = PIN_COIL4; break;
    case 3: valor = PIN_COIL3; break;
    case 2: valor = PIN_COIL2; break;
    case 1: valor = PIN_COIL1; break;
  }
return valor;
}

Habia puesto la mitad de los PTR y PIN (5 a 8) Ahora esta con 1 a 8. Igual no te habias dado cuenta.
 
Última edición:
hola yyyyyyyyyyyyy ., muchisimas pero muchisimas gracias ., por rl tiempo y las sugerencias e ideas
BOOL (boolean) es un tipo de variable. Es como un int o un char pero solo puede admitir dos valores "verdadero" y "falso". Se usa para definir dos estados. También puede ser "1" o "0".
Si te complica la vida, fijate en cómo está definido EJE_X y EJE_Y y hazlo con un int.
Este tipo de variables se usan cuando vas ha hacer una sentencia if del tipo "si no es burro, es burra".
No sé si me consigo explicar.
En cuanto al motor, yo que tu haría primero un programa que haga que de vueltas en un sentido y que le puedas regular la velocidad. Partiendo de ese programa se pueden ir cambiando cosas hasta dar con la solución buena.
Yo no me conformaría con hacer arreglos mecánicos; un motor paso a paso está pensado para poder ser controlado de manera exacta ¿no?.



Otra cuestión: estoy haciendo cosas a ciegas. ¿Que tal si pones la definición de PRT_COIL(1-8) PIN_COIL y DDR-COIL (y todas que falten en el código). Si veo las definiciones igual lo entiendo mejor y te puedo ayudar mejor.
Y una última: me acabo de fijar en el código que y hay un error en estas tres funciones. A ver si así está más correcto


Habia puesto la mitad de los PTR y PIN (5 a 8) Ahora esta con 1 a 8. Igual no te habias dado cuenta.
bueno ., la funcion "" BOOL "" si la entendia y sabia como funciona ., lo que no entendia era como la aplicabas dentro del
PHP:
void mover_motor(int cuantos_pasos,int eje,bool positivo_sn)
alli me "marie" con las fuciones ., pero ahora ., previo a tu explicacion ., ya la entiendo un poco mas​
en cuanto a lo que pedis ., de la definicion de PRT_COIL(1-8) PIN_COIL y DDR-COIL ., esas estan en la libreria .H y que esta publicada en el mensje N° 7 https://www.forosdeelectronica.com/f47/pasar-libreria-arduino-avrstudio-atmega-144094/#post1107090
y que ademas estan incluidas cuando compilo el proyecto​
esta modularizado todo el proyecto ., para que todo no este en el "" MAIN "" ., porque sino seria kilometrico jajajajajajajajaja​
y en el "" MAIN " irian el llamado de funciones mas accesorios y el LOOP de lectura de los potenciometros virtuales​
hasta ahora la parte que funciona tiene 6 librerias .C (mas las otras 6.H)​
la idea es hacer una libreria .C con esta funcion y seria una sola o X o Y ., porque las dos son iguales​
y como las funciones son idependientes y separadas de cada eje ., en cuanto ala precicion con 24 pasos para cda lado esria perfecto​
RAUL ., hizo unas bieletas regulables ., para corregir la diferencia de grados o ditancia ., luego fabrica las definitivas con la medida correcta​
yo diria de usar esa libreria ultima que postie ., la que cambia el giro y la velocidad con botones​
esa tiene 4 pasos hacia adelante ., y 4 pasos hacia atras aunque por ahora tenga una velocidad fija en el valor de (t)​
PHP:
  _delay_loop_2(t);
en cuanto al potenciometro virtual ., tiene un valor que varia de 0 a 255 ., o de acuerdo a la pocicion que tenga en el programa de la compu​
ese valor se puede comparar con una funcion digamos​
PHP:
           if (potenciometrovirtual[0] <= 120)
			{
			motor_X_left;		// motor gira a la izquierda
			
			}
		else if (potenciometrovirtual[0] > 140)
			{
			motor_X_right;		// motor gira a la derecha
			
			}
		   else
			{
			sensor_0°_centre;		// parada de motor  o 0° del centro
		        
			}
eo seria mas o menos la idea ., talvez surjan otras maneras ., como que el motor al llegar a los 24 pasos en los extremos se tiene que parar​
en el dibujo que hice aca​
Ver el archivo adjunto 144863
creo que el dibujo explica mas que yo ., bueno quedo a la espera de ideas ., y gracias de nuevo ., por el tiempo y la voluntad​
 
Pues por mucho que miro no veo esas definiciones.
A ver si yo entiendo esto: hay por ahí entre todo ese montón de código, un puerto representado por un BYTE ¿si?.
Es decir 8 bits. Y si pongo un bit de estos 8 a 1, entonces el motor se mueve un paso en un sentido ¿es asi?.
 
hola y gracias de nuevo
Pues por mucho que miro no veo esas definiciones.
A ver si yo entiendo esto: hay por ahí entre todo ese montón de código, un puerto representado por un BYTE ¿si?.
Es decir 8 bits. Y si pongo un bit de estos 8 a 1, entonces el motor se mueve un paso en un sentido ¿es asi?.
bueno esas definiciones estan en la libreria .H pero alli estan definidos los puertos ., no los estados de los mismos​
yo creo que tu pregunta ., se refiere ., a como le das los estados a cada puerto​
ahora entiendo a que te referis y para aclarartelo un poco te muestro una libreria que probe en lo fisico​
PHP:
#include<avr/io.h>
#include<util/delay.h>
#include "lib_X_Y.h"
#define DELAY 0
#define DELAY_STEP 4
// ***** inicializacion de Puertos ****// 
 void Init_X_Y_port( void ) {
  DDR_COIL1 |= (1<<PIN_COIL1);
  DDR_COIL2 |= (1<<PIN_COIL2);
  DDR_COIL3 |= (1<<PIN_COIL3);
  DDR_COIL4 |= (1<<PIN_COIL4);
  
}
void Forward()
{
	PRT_COIL1 =  (1<<PIN_COIL1);
	_delay_ms(4);
	PRT_COIL1 = 0;
	_delay_ms(DELAY);
	PRT_COIL2 =  (1<<PIN_COIL2);
	_delay_ms(4);
	PRT_COIL2 = 0;
	_delay_ms(DELAY);
	PRT_COIL3 =  (1<<PIN_COIL3);
	_delay_ms(4);
	PRT_COIL3 = 0;
	_delay_ms(DELAY);
	PRT_COIL4 =  (1<<PIN_COIL4);
	_delay_ms(4);
	PRT_COIL4 = 0;
	_delay_ms(DELAY);
}

void Reverse()
{
	PORTA |= (1<<PA3);
	_delay_ms(DELAY_STEP);
	PORTA = 0;
	_delay_ms(DELAY);
	PORTA |= (1<<PA2);
	_delay_ms(DELAY_STEP);
	PORTA = 0;
    _delay_ms(DELAY);
	PORTA |= (1<<PA1);
	_delay_ms(DELAY_STEP);
	PORTA = 0;
	_delay_ms(DELAY);
	PORTA |= (1<<PA0);
	_delay_ms(DELAY_STEP);
    PORTA = 0;
	_delay_ms(DELAY);
}


int main ()
{
 	DDRA = (1<<PA0) | (1<<PA1) | (1<<PA2) | (1<<PA3);
	PORTA = 0;

Init_X_Y_port();// inizialisa las salidas  
   
	 while(1)
	{
	Forward();
	}
	return 0;
}
inclusive esta probada con el potenciometro virtual (como explique mas atras​
si te fijas el giro a derecha y el giro a izquierda tienen distinras formas de definicion ., pero funcionan exactamente igual​
en la compilacion que adjunto solo hay que cambiar Forward() por Reverse() ., dentro del while(1) ., compilar de nuevo y listo​
con el poteciometro virtual ., funcionana sin cambiar nada ., claro que la definicion de la USART cambia un poco​
pero en lo que respecta ., al funcionamiento de los puertos es tal cual esta aca ., te adunto el proyecto eb AVRstudio para que veas claro que aca solo tengo cambio de sentido de giro ., con velocidad fija ., y que en el medio de los dos comandos ., el motor se para ., porque no es uno ni otro ., entonces es 0 o parado​
 

Adjuntos

  • Dirección y Velocidad de control de motor paso a paso utilizando Microcontrolador.rar
    12.3 KB · Visitas: 2
A ver si aclaro al pregunta:
Código:
#define DDR_COIL1 DDRA
  #define PRT_COIL1 PORTA
  #define PIN_COIL1 PA0
Sé lo que es una macro. Y lo que es un define. Lo que no sé es que tipo de variable es cada una de estas definiciones (entero, long, llamada a una función) ni que valor tiene (0x01, 0, 1, 3567, etc...)
¿Que es DDRA, PORTA o PA0?¿Que valor tienen?¿cuando se les asigna ese valor?¿quien lo hace?¿Son funciones o valores propios de una librería del compilador o del motor que usas?
Si me cuentas todo eso que no sé, podré ayudarte, sino no se me ocurre cómo.
 
Son direcciones de memoria, aunque PA0 creo que es un decimal con el desplazamiento de los bits.

DDRx creo que era data direction register
PORTx El registro de escritura del puerto
Y el último creo que un decimal con el numero de bit por como se emplea (1<<pin) tendría un valor de 0 a 7 según el bit
 
Última edición:
hola
A ver si aclaro al pregunta:
Código:
#define DDR_COIL1 DDRA
  #define PRT_COIL1 PORTA
  #define PIN_COIL1 PA0
Sé lo que es una macro. Y lo que es un define. Lo que no sé es que tipo de variable es cada una de estas definiciones (entero, long, llamada a una función) ni que valor tiene (0x01, 0, 1, 3567, etc...)
¿Que es DDRA, PORTA o PA0?¿Que valor tienen?¿cuando se les asigna ese valor?¿quien lo hace?¿Son funciones o valores propios de una librería del compilador o del motor que usas?
Si me cuentas todo eso que no sé, podré ayudarte, sino no se me ocurre cómo.
bueno ., veremos ., si te aclaro un poco mas eso (esperemos que no oscurezca)bueno yo no uso la de finiciones de puertos ni es hexadecimal ., ni decimal ., y me molesta mucho encontrar eso​
mas si queres saber en que estado se habilita un puerto ., mas si es un tutorial ., eso se usa para mejorar el tamaño del codigo​
entonces tenes que volverte " mono " para entender lo que estan explicando ., y para colmo en un codigo de algunas lineassi eso esta pensado para luego aplicarlo ., a algo mas complejo alli empieza de nuevo el "baile"​
pero vamos a lo otro y empezemos con lo facil ., cuando yo declaro​
PHP:
 DDRA = (1<<PA0) | (1<<PA1) | (1<<PA2) | (1<<PA3);
    PORTA = 0;
alli lo primero que hago., es declarar la direccion del registro del puerto .,
PHP:
DDRA
luego declaro los pines de ese puerto ., que voy a usar ., como salida
PHP:
= (1<<PA0) | (1<<PA1) | (1<<PA2) | (1<<PA3)
uso solamente esos los demas pines del puerto no intervienen ., ni hacen nada​
luego que los defini y declare ., los pongo a 0 (cero) ., sin ningun estado (PORTA = 0)​
lo que me doy cuenta que te confunde es cuando le cambio el estado ., y eso lo ago en el array que va letendo el bucle indefinidamente ( a menos que yo cambie el estado de lectura claro​
por ejemplo
PHP:
PORTA |= (1<<PA0)
., con .,
PHP:
|=
yo estoy poniendo el pin/port ese a estado alto (5v) ., y lo mantengo asi por lo que dure el DELAY declarado ., luego lo vuelvo a poner a cero ( sin valor) ., con​
PHP:
PORTA = 0
en el otro caso es algo distinto el manejo ., primero defino e introduzco una variable para manipular​
PHP:
 #define DDR_COIL1 DDRA
  #define PRT_COIL1 PORTA
  #define PIN_COIL1 PA0
luego los habilito y le doy valor alto​
PHP:
// ***** inicializacion de Puertos ****// 
 void Init_X_Y_port( void ) {
  DDR_COIL1 |= (1<<PIN_COIL1);
  DDR_COIL2 |= (1<<PIN_COIL2);
  DDR_COIL3 |= (1<<PIN_COIL3);
  DDR_COIL4 |= (1<<PIN_COIL4);
ahora en el array de bucle uso la variable., para llamar al pin/port​
PHP:
PRT_COIL1 PORTA
entonses en el array del bucle solo lo llamo ., porque el estado alto ya esta definido al inicializarlo​
PHP:
PRT_COIL1 =  (1<<PIN_COIL1);
y lo mantengo en el array por el tiempo del DELAY ., luego tomo la variable y la pongo a 0 (cero) o nada​
PHP:
 PRT_COIL1 = 0;
lo uso de esta forma ., porque me da la posibilidad de manejar los puertos de otra manera como el el eje Z ., donde en el​
PHP:
switch(value)
para manejar los​
PHP:
case (i):
de esa manera puedo manejar los puertos de otra manera ., y si logro mejor torque del motor (aparte sirve de freno de posiscion) ., como esta en en este ejemplo​
PHP:
switch(value) 
   {
    case 0:
     PRT_COIL1 |=  (1<<PIN_COIL1);
     PRT_COIL2 &= ~(1<<PIN_COIL2);
     PRT_COIL3 &= ~(1<<PIN_COIL3);
     PRT_COIL4 &= ~(1<<PIN_COIL4);
     break; 
    case 1:
     PRT_COIL1 |=  (1<<PIN_COIL1);
     PRT_COIL2 |=  (1<<PIN_COIL2);
     PRT_COIL3 &= ~(1<<PIN_COIL3);
     PRT_COIL4 &= ~(1<<PIN_COIL4);
     break;    
    case 2:
     PRT_COIL1 &= ~(1<<PIN_COIL1);
     PRT_COIL2 |=  (1<<PIN_COIL2);
     PRT_COIL3 &= ~(1<<PIN_COIL3);
     PRT_COIL4 &= ~(1<<PIN_COIL4);
     break;
    case 3:
     PRT_COIL1 &= ~(1<<PIN_COIL1);
     PRT_COIL2 |=  (1<<PIN_COIL2);
     PRT_COIL3 |=  (1<<PIN_COIL3);
     PRT_COIL4 &= ~(1<<PIN_COIL4);
     break; 
    case 4:
     PRT_COIL1 &= ~(1<<PIN_COIL1);
     PRT_COIL2 &= ~(1<<PIN_COIL2);
     PRT_COIL3 |=  (1<<PIN_COIL3);
     PRT_COIL4 &= ~(1<<PIN_COIL4);
     break;
    case 5:
     PRT_COIL1 &= ~(1<<PIN_COIL1);
     PRT_COIL2 &= ~(1<<PIN_COIL2);
     PRT_COIL3 |=  (1<<PIN_COIL3);
     PRT_COIL4 |=  (1<<PIN_COIL4);
     break; 
    case 6:
     PRT_COIL1 &= ~(1<<PIN_COIL1);
     PRT_COIL2 &= ~(1<<PIN_COIL2);
     PRT_COIL3 &= ~(1<<PIN_COIL3);
     PRT_COIL4 |=  (1<<PIN_COIL4);
     break;
    case 7:
     PRT_COIL1 |=  (1<<PIN_COIL1);
     PRT_COIL2 &= ~(1<<PIN_COIL2);
     PRT_COIL3 &= ~(1<<PIN_COIL3);
     PRT_COIL4 |=  (1<<PIN_COIL4);
     break; 
   }
lo curioso de esa secuencia es que es lo mismo que cuente hacia adelante que hacia atras​
yo he intentado reformar esta libreria pero sin exito .,( no doy en la "tecla" con la cuenta de pasos., ni la direccion)​
aparte que tiene el DELAY fijo ., y yo nesesito que sea variable​
si tienen dudas de como se declaran los puertos y las funciones ., yo ya publique la libreria I/O.H que acepta el compilador para este micro ., esta por aca​
https://www.forosdeelectronica.com/f47/pasar-libreria-arduino-avrstudio-atmega-144094/#post1107324
alli puede ver que se declara par el uso de puertos ., pero en ningun momento hay nada que declare estados ., eso se hace en el main​
 
Última edición:
Hola otra vez. He mirado el asunto... y hasta aquí llego. Sin tener AVR ni AVR Studio ni tener más idea del asunto no me atrevo a decir nada más.
Tienes aquí un enlace: http://www.google.es/url?sa=t&rct=j...ZSdfS-mZt0TaaLhsaXOt7A&bvm=bv.127178174,d.d2s

que me ha ayudado a entender como se definen los puertos y por que las macros.
Te recomendaría que le echases un vistazo, por que me parece que los puertos de salida se inicializan a 0xFF en vez de a cero.
Suerte!.
 
hola y anyes que nada te agradezco mucho tu voluntad e interes en ayudarme
Hola otra vez. He mirado el asunto... y hasta aquí llego. Sin tener AVR ni AVR Studio ni tener más idea del asunto no me atrevo a decir nada más.
Tienes aquí un enlace: http://www.google.es/url?sa=t&rct=j...ZSdfS-mZt0TaaLhsaXOt7A&bvm=bv.127178174,d.d2s

que me ha ayudado a entender como se definen los puertos y por que las macros.
Te recomendaría que le echases un vistazo, por que me parece que los puertos de salida se inicializan a 0xFF en vez de a cero.
Suerte!.
bueno veo que sigue tu confucion ., cuando yo defino​
PHP:
//Ports
DDRA=  0xFF;						//low outputs
PORTA= 0;
alli pasan dos cosas ., habilito el puerto como salida ., y se declara como estado bajo​
eso es porque se configura internamente las resistencias pull-up​
cosa que en avr no es como pic​
pero inmediatamente pongo los pin/port de portA a 0 ( o ningun estado)​
ahora ., la cuestion es ., si bien ., yo necesito usar los 8 puertos ., no deben trabajar juntos., o sea son dos bloques de 4 puertos​
esa es una de las razones de porque se define por pin y no por puerto completo​
ahora los estados los tenes que definir individualmente​
porque si estas controlando un array de 4 puertos y mandas a masa o estado bajo todo el puertoA​
interferis en las otras funciones de los otros cuatro., que talvez se esten moviendo ., y en ese momento no nesesitan pararce​
por eso es la razon que los estados se definen en el loop., o bucle y no en el arranque o definicion​
como podria darce el caso que en los primeros pines tenga 4 led con PWM variable ., y en los cuatro siguientes un motor​
esa es una de la cuestiones ., de la razon del porque asi​
yo te recomendaria si usas arduino que te leyeras estos tutoriales son muchos mas didacticos​
http://www.fourwalledcubicle.com/AVRArticles.php
pero de todos modos agradezco muchisimo tu interes y voluntad para ayudarme​
 
hola y muchisimas gracias por el interes
ok, he estado un tiempo sin venir, ¿me hacen un resumen del problema ahora?
bueno con el ejemplo anterior ., logre que gire hacia un sentido y hacia el otro sentido​
pero aun estoy muy lejos del funcionamiento que nesesito​
tome la idea que planteo el amigo Ardogan ., de ir de a poco con las funciones ., en el ejemplo anterior ., ya logre controlar el sentido de giro con los potesvirtuales​
aunque alli esta con el delay fijo ( se que no es lo corecto ., pero bueno eso lo vere mas adelante )​
y esa es la parte que me gustraria hacer variable​
justamente para variar la velociddad ., en un sentido u otro ., (y ver como manejarlo con los potesvirtuales)​
 
Atrás
Arriba