Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

16/06/2016 #21

Avatar de locodelafonola

hola y gracias
Ardogan dijo: Ver Mensaje

Exactamente , 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 ) 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
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
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
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
Código 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
Código PHP:
   for(i=0i<=MOT_STEPSi++)//Ahora busca la posición cero de nuevo!
   
{
    
MakeStep(0);
    
MakeStep(0);
    
_delay_ms(4);
    if(!(
PR_SENSOR & (1<<PIN_SENSOR))) break;
   }
  for(
i=0i<=CORR_VALi++)//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
Código PHP:
//Seleccione la posición del angulo
extern void SetAngleuint8_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 CheckAnglevoid )
 {
  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_STEPSIst1=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==0Ist1=MOT_STEPS;
      
Ist1--;
     }
   } 
  if(
Ist1>Soll1
   {
    if((
Ist1-Soll1)<=(MOT_STEPS/2))
     {
      
MakeStep(1);
      if(
Ist1==0Ist1=MOT_STEPS
      
Ist1--;     
     } else {
      
MakeStep(0);
      
Ist1++;
      if(
Ist1>=MOT_STEPSIst1=0;  
     }
   }
 }


//Paso el motor en dirección definida
void MakeStepuint8_t direction )
 {
  if(
direction==0
   {
    
Step1++;
    if(
Step1>=8Step1=0;
   } else {
    if(
Step1==0Step1=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
Código 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
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
26/06/2016 #22

Avatar de Ardogan

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 ).

locodelafonola dijo: Ver Mensaje
...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 .

locodelafonola dijo: Ver Mensaje
...
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?.

locodelafonola dijo: Ver Mensaje
...codigo...
y por ejemplo podriamos definir la cantidad de pasos ala derecha (right) y a la izquierda (left) y quedaria declarado algo asi
Código 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.

locodelafonola dijo: Ver Mensaje
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.

locodelafonola dijo: Ver Mensaje
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.

locodelafonola dijo: Ver Mensaje
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ó).
27/06/2016 #23

Avatar de locodelafonola

hola ... y muchas gracias che ¡¡¡¡
Ardogan dijo: Ver Mensaje
¿Para eso no conviene poner fines de carrera?. Ah... más abajo veo que ya hay un sensor de cero/home .
exacto che ., la idea de los limites ., que tuviste vos ., desde el principio., es para mi lo mas acertado y logico
Ardogan dijo: Ver Mensaje
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°
Ardogan dijo: Ver Mensaje
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
Ardogan dijo: Ver Mensaje
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
Ardogan dijo: Ver Mensaje
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
Ardogan dijo: Ver Mensaje
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
05/07/2016 #24


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;
}
---------- Actualizado después de 2 minutos ----------

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.
05/07/2016 #25


Otro apunte: he puesto las variables tipo int, pero si tu sistema lo admite pueden ser unsigned char (¿8 bits, no?)

---------- Actualizado después de 2 minutos ----------

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.

---------- Actualizado después de 3 minutos ----------

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

---------- Actualizado después de 27 minutos ----------

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
}
05/07/2016 #26

Avatar de locodelafonola

hola
laremi400 dijo: Ver Mensaje
Otro apunte: he puesto las variables tipo int, pero si tu sistema lo admite pueden ser unsigned char (¿8 bits, no?)

---------- Actualizado después de 2 minutos ----------

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.

---------- Actualizado después de 3 minutos ----------

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

---------- Actualizado después de 27 minutos ----------

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
Código 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"
Código PHP:
#define PLUS true
#define MINUS false
 // *** establecer valor de WHILE  ***//
enum {false=0true=1}; 
y para que veas te adjunto una captura de pantalla del compilador
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)
Imágenes Adjuntas
Tipo de Archivo: jpg capture_07052016_185810.jpg (172,0 KB (Kilobytes), 53 visitas)
05/07/2016 #27

Avatar de Nuyel

En C el tipo bool no existe, tienes que hacer #include <stdbool.h> para que se agrege
06/07/2016 #28


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?
07/07/2016 #29

Avatar de locodelafonola

hola y muchas gracias a los dos
laremi400 dijo: Ver Mensaje
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
Código 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>20535t=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<60535t=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
Código 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=(<< PB0);   //aplicar el pulso al 1 bobina

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

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

        
_delay_loop_2(t);

         
PORTB=(<< PB2);

        
_delay_loop_2(t);

         
PORTB=(<< 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=(<< PB3);   // aplicar pulsos a última bobina

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

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

         
_delay_loop_2(t);

          
PORTB=(<< PB1);

        
_delay_loop_2(t);

          
PORTB=(<< 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
08/07/2016 #30


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?.

---------- Actualizado después de 12 minutos ----------

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.
08/07/2016 #31

Avatar de locodelafonola

hola yyyyyyyyyyyyy ., muchisimas pero muchisimas gracias ., por rl tiempo y las sugerencias e ideas
laremi400 dijo: Ver Mensaje
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?.

---------- Actualizado después de 12 minutos ----------

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
Código 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 Pasar librería de Arduino a AVRStudio (ATmega)
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)
Código 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
Código 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
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
09/07/2016 #32


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?.
10/07/2016 #33

Avatar de locodelafonola

hola y gracias de nuevo
laremi400 dijo: Ver Mensaje
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
Código 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_portvoid ) {
  
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
11/07/2016 #34


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.
11/07/2016 #35

Avatar de Nuyel

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
11/07/2016 #36

Avatar de locodelafonola

hola
laremi400 dijo: Ver Mensaje
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
Código 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 .,
Código PHP:
DDRA 
luego declaro los pines de ese puerto ., que voy a usar ., como salida
Código 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
Código PHP:
PORTA |= (1<<PA0
., con .,
Código 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
Código PHP:
PORTA 
en el otro caso es algo distinto el manejo ., primero defino e introduzco una variable para manipular
Código PHP:
 #define DDR_COIL1 DDRA
  #define PRT_COIL1 PORTA
  #define PIN_COIL1 PA0 
luego los habilito y le doy valor alto
Código PHP:
// ***** inicializacion de Puertos ****// 
 
void Init_X_Y_portvoid ) {
  
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
Código PHP:
PRT_COIL1 PORTA 
entonses en el array del bucle solo lo llamo ., porque el estado alto ya esta definido al inicializarlo
Código 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
Código 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
Código PHP:
switch(value
para manejar los
Código 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
Código 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
Pasar librería de Arduino a AVRStudio (ATmega)
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
14/07/2016 #37


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&...27178174,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!.
14/07/2016 #38

Avatar de locodelafonola

hola y anyes que nada te agradezco mucho tu voluntad e interes en ayudarme
laremi400 dijo: Ver Mensaje
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&...27178174,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
Código PHP:
//Ports
DDRA=  0xFF;                        //low outputs
PORTA0
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
22/07/2016 #39

Avatar de Nuyel

ok, he estado un tiempo sin venir, ¿me hacen un resumen del problema ahora?
22/07/2016 #40

Avatar de locodelafonola

hola y muchisimas gracias por el interes
Nuyel dijo: Ver Mensaje
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)
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Arduino y Raspberry Pi

Cerrar
Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.