Arduineces y otras hierbas (Monitorizar fugas de agua)

Todo cuanto tiene que ver con la obtención, almacenamiento y proceso de la información digital, sus aplicaciones y el software y hardware utilizado.
Responder
Mensaje
Autor
alberttoy
Mensajes: 1090
Registrado: Mar Sep 16, 2014 12:55 am
País: españa
Ciudad: barcelona

Re: Mis primeros pasos con Arduino

#191 Mensaje por alberttoy »

Si. Puedes alimentarlo a 24V o mas. La cuestión es que para vencer la reactancia hace falta mas voltaje pero luego en el rato en que dura el pulso la corriente es excesiva. Especialmente si lo haces funcionar mas lento.
En un catalogo de motores de los 80 vi un truco. Poner una resistencia potente entre el positivo y el común. Esto permite alimentarlo a mas voltaje. Cuando no pasa corriente se alimenta a mas voltaje que cuando ya conduce.

Si quieres afinar mas, igual puedes alimentar con una fuente durante el principio del pulso y otra el resto.
Los controladores modernos hacen funcionar motores de 2,3V con fuentes de 80V

Avatar de Usuario
heli
Mensajes: 1946
Registrado: Mié Sep 06, 2006 7:28 am
País: España
Ciudad: Alcalá de Henares
Ubicación: Alcala de Henares (Madrid, España)
Contactar:

Re: Mis primeros pasos con Arduino

#192 Mensaje por heli »

Los motores paso a paso de buenas prestaciones son de muy bajo voltaje, alrededor de 2.4 a 5V porque tienen pocas espiras para tener una inductancia baja y responder rápidamente a los cambios de corriente. Asi pueden alcanzar velocidades altas.
La inductancia de los motores hace que no respondan bien a las variaciónes rápidas de corriente, hay que recordar que el campo magnético de los los electroimanes es proporcional a la corriente, no a la tensión.
Antiguamente se usaban dos tensiones de alimentación y dos circuitos de alimentación, uno durante de tensión alta durente unos milisegundos y otro de tensión nominal durante el resto del ciclo de cada paso. Así conseguían aumentar la velocidad de subida de la corriente.

Actuelmente se alimentan a tensiones altas, pero trabajando a corriente constante mediante circuitos PWM realimentados.
Todavía esta en línea mi driver con micropasos http://heli.xbot.es/wp-content/Antiguo/ ... rostep.htm
Muy recomendable el tutorial de motores paso a paso: http://homepage.divms.uiowa.edu/~jones/step/ de Douglas W. Jones.

Para estudiar con detenimiento es muy interesante el tema de los micropasos... mis alumnos siempre se sorprenden y se interesan muchísimo por el funcionamiento de los micropasos y su relación con la trigonometría...
¡No es imposible, lo que pasa es que no sabes como hacerlo!
Aka: no es difícil si sabes como.
http://heli.xbot.es

Avatar de Usuario
mister_electronico
Mensajes: 122
Registrado: Mié Ene 15, 2014 8:44 pm
País: España
Ciudad: Asturias

Re: Mis primeros pasos con Arduino

#193 Mensaje por mister_electronico »

Que curioso por que yo tengo distintos motores paso a paso y entre ellos tengo los mismos motores paso a paso Sanyo que muestras en tu pagina web, y bueno siempre girandolos manualmente los pasos que dan son como mecanicamente enclavados, y siempre haciendo las desmultiplicacion mediante engranajes, nunca pense puedira hacerse pasos intermedios y que estos puedan ser estables....
Que curioso.... interesante.

Saludos.

Avatar de Usuario
Anilandro
Mensajes: 4905
Registrado: Dom Feb 11, 2007 10:16 pm
Ubicación: Islas Baleares, España
Contactar:

Re: Mis primeros pasos con Arduino

#194 Mensaje por Anilandro »

Sí, los motores unipolares (los de 5, 6 u 8 cables) pueden controlarse de tres formas distintas, la wave drive, que activa una de las cuatro bobinas cada vez, con 4 posiciones por ciclo y alineamiento del rotor con las bobinas ...La normal que las activa de dos en dos, que tiene más par pero también más consumo, y también 4 posiciones por ciclo pero con el alineamiento del rotor siempre entre dos bobinas ...Y el de "medio paso", que combina los dos anteriores, un paso con una bobina y un paso con dos, totalizando 8 pasos por ciclo, con par y consumo intermedio de los otros dos sistemas...
Este motor se puede atacar con 4 transistores independientes, es fácil de hacer andar.

El cuanto al motor PAP bipolar, sólo tiene dos bobinas y una sola manera de activarlo. Para ponerlo en marcha necesitamos dos puentes en H o una fuente simétrica +/-. La ventaja es que tiene más par que los anteriores.

Estos dos días he estado trabajando un poco con una plataforma giratoria que era del mecanismo de cambio de cintas de un sistema profesional de backup de datos de HP, que desguazamos. Le he quitado todo lo inútil y estoy controlando su motor PAP bipolar con un Arduino y un módulo con el integrado L298, que lleva dos puentes en H...

...El problema es que me he tenido que rascar todo el programa porque la librería "stepper" de Arduino no acaba de ir bien, cuando el motor está detenido siempre sigue aplicándole tensión en una bobina. Esto lo mantiene más frenado pero dispara el consumo, que llega a calentar el radiador... al final he hecho yo las rutinas de control, y va muy bien, además lo controlo con un mando a distancia por infrarrojos, con el que puedo darle la puesta a cero grados, +10, -10, +90. -90 y posición absoluta de 0 a 360º...

Imagen

...Aún he de perfeccionar el sincro entre pasos y grados, ya que la plataforma gira 360º con 700 ciclos de 4 pasos, es decir, nada que sea divisible de forma entera, y debo acudir a operaciones de coma flotante que al moverse un rato arriba y abajo, poco a poco me van introduciendo pequeñas diferencias entre la posición teórica de la plataforma y la real, obligando a repetir la rutina de inicio, en que el mecanismo se sincroniza con una barrera fotoeléctrica en una posición determinada... La diferencia que llega a acumular es pequeña, de un máximo de dos o tres grados, pero la quiero eliminar...

El mismo grabador HP tenía también otro motor PAP igual que actuaba sobre un sin fin para mover un cursor...

Imagen

Estas cosas voy a dejarlas montadas ya que esta semana comenzamos en el Taller de Robótica con este tipo de motores, y los único que lleva normalmente el Arduino Starter Kit es unipolar 28BYJ-48 con desmultiplicación mecánica, que gira muy lento y ni siquiera puede verse el eje primario del motor...

Saludos
La VIDA sólo es energía que ha aprendido a defenderse... (Anilandro)

*** La Web de Anilandro *** http://sites.google.com/site/anilandro

Avatar de Usuario
heli
Mensajes: 1946
Registrado: Mié Sep 06, 2006 7:28 am
País: España
Ciudad: Alcalá de Henares
Ubicación: Alcala de Henares (Madrid, España)
Contactar:

Re: Mis primeros pasos con Arduino

#195 Mensaje por heli »

El cuanto al motor PAP bipolar, sólo tiene dos bobinas y una sola manera de activarlo
Esto no es estrictamente así, los motortes bipolares se manejan exactamente igual que los unipolares.
La diferencia entre unos y otros es que los bipolares necesitan tensiones positivas y negativas en sus dos bobinas y los uniolares usan una sola polaridad en cada pareja de bobinas. Una pareja para lo que sería positivo en un bipolar y otra pareja de bobinas para lo que sería negativo en el bipolar.
Pero los modos de paso, medio paso, micropasos etc son exactamente iguales. Basta con sustituir "cambiar polaridad" por "cambiar a la otra bobina". La otra bobina esta bobinada "al revés" (no es estricamente así pero vale para hacernos una idea) de forma que usarla con la misma polaridad que su pareja implica campo magnético contrario, lo mismo que se consigue con el cambio de polaridad de los bipolares.

Los motores de altas prestaciones suelen ser bipolares porque tienen menos cobre, lo que significa menos inductancia y mas corriente, y son mas compactos. Pero se complica el manejo con los dos puentes en H.
Los motores mas sencillos suelen ser unipolares, que se controlan mas facilmente con simples transistores. Como nunca trabajan mas de dos bobinas a la vez (una pareja para cada polaridad) las consideraciones de disipación térmica del cobre son menores. Para bajas tensiones también son mejores porque las pérdidas en el driver por VCe (o Rds ON en mosfet) se reducen a la mitad al conmutar cada bobina con un solo transistor frente a dos del motor bipolar.

Yo también me he peleado con las librerías de stepper de arduino y algunas son bastante malas, pero no es dificil escribir el código uno mismo.
Los motores PAP en parado necesitan tensión para evitar la desincronización por la fuerza que ejerce la carga, pero para bajar el consumo se suele usar una corriente reducida (corriente de retención) mediane PWM.

mister_electronico:
Los motores PAP donde se notan los pasos es porque son motores híbridos de "de reluctancia variable" y "paso a paso". Son los mas comunes porque son los de mejores prestaciones, pero también los hay donde NO se notan los pasos al girar porque el imán móvil no tiene salientes.
¡No es imposible, lo que pasa es que no sabes como hacerlo!
Aka: no es difícil si sabes como.
http://heli.xbot.es

Avatar de Usuario
Anilandro
Mensajes: 4905
Registrado: Dom Feb 11, 2007 10:16 pm
Ubicación: Islas Baleares, España
Contactar:

Re: Mis primeros pasos con Arduino

#196 Mensaje por Anilandro »

Esta semana, en el taller de introducción a la robéóica pasamos a otra cosa, algunos van a tener que tomar un soldador por primera vez en su vida, y también aprender a extraer componentes de placas obsoletas e identificarlos de forma básica, de momento buscando sólo Mosfets de canal N y transistores bipolares...

Otro tema que vamos a tratar es el protocolo PPM (Pulse Position Moldulation), el típico de los radiocontroles de toda la vida, (aunque ahora de cada vez son más los PCM), y para ello construiré un pequeño "coche" teledirigido de dos ruedas motrices más una libre. El trabajo del Arduino será de momento muy básico, actuar de interface entre las señales PPM y la placa de control de motores basada en el L293.

...Los motores serán los típicos amarillos con desmultiplicación que vienen de China a precios irrisorios, unos 2,5€ junto con la rueda y con envío gratuito. Esto naturalmente se traduce en una calidad del material manifiestamente mejorable. Por ejemplo, algo que me di cuenta en seguida fue que la rueda apenas aguanta frenarse sin que el eje estriado comience a girar dentro del pivote de salida. La solución ha sido desmontar los motores y reforzar la unión eje-pivote con cianocrilato. pero el otro problema, algo más serio, ha sido ya que me he dado cuenta que este motor al girar en vacío consume casi 170 mA, lo cual es a todas luces excesivo para su tamaño y potencia...

...Estudiando un poco este problema, he recordado que al desmontar el mecanismo para reforzar la unión con los ejes, me di cuenta que los engranajes estaban impregnados de una grasa de silicona que es casi como pegamento, muy espesa, y pensé que tal vez parte del consumo era a causa de la retención mecánica que ejercen los piñones más rápidos al verse frenados por esta grasa. El caso es que como he podido los he limpiado (esta grasa es correosa y no se disuelve en nada que yo conozca) y luego he engrasado el conjunto reductor con una gota de aceite de vaselina... y la hostia... el mismo motor ha pasado de consumir en vacío 170 mA a tan solo 70... y claro está andado a más revoluciones...

Otro asunto a sido como decodificar la señal PPM para poder atacar los motores a través de dos puentes en H... porque a presar que el PPM sea en realidad analógico, los receptores de hoy en día interiormente son digitales, el chip receptor de 2,4 Ghz se comunica con el decodificador mediante lo que parece ser un protocolo serie del que desconozco sus características, con lo cual me ha resultado imposible obtener la señal PPM ni en los receptores Futaba ni en los FlySky que utilizo... la solución se me ha ocurrido al "sumar" mediante un OR de seis entradas las señales individuales de los 6 canales de salida, con lo cual, al seguir siendo secuenciales y mantener un breve espacio de separación, puedo "reconstruir" una parte de la señal PPM, y digo una parte porque el impulso de sincronismo aparece invertido respecto a los canales y al PPM original...

El programita que he hecho utiliza interrupciones en el pin 2 del Arduino y ya consigo cinco canales limpios (para este "coche" ahora solo necesito 2), así que de momento seguiré por este camino, dejando para otra semana la implantación de una "navegación automática", basada en diversos sensores...

Saludos a todos
La VIDA sólo es energía que ha aprendido a defenderse... (Anilandro)

*** La Web de Anilandro *** http://sites.google.com/site/anilandro

sawtech
Mensajes: 68
Registrado: Mié Feb 01, 2017 6:59 pm
País: argentina
Ciudad: caba

Re: Mis primeros pasos con Arduino

#197 Mensaje por sawtech »

Ahi va otro tutorial

A4988 tutorial de conexión y jugando un poco
Imagen

https://youtu.be/Bd113ekUtAU

sawtech
Mensajes: 68
Registrado: Mié Feb 01, 2017 6:59 pm
País: argentina
Ciudad: caba

Re: Mis primeros pasos con Arduino

#198 Mensaje por sawtech »

Manejando la termocupla max6675

Imagen

https://youtu.be/qwReFg8LzVI

Avatar de Usuario
heli
Mensajes: 1946
Registrado: Mié Sep 06, 2006 7:28 am
País: España
Ciudad: Alcalá de Henares
Ubicación: Alcala de Henares (Madrid, España)
Contactar:

Re: Mis primeros pasos con Arduino

#199 Mensaje por heli »

Yo llevo unos meses bastante liado desarrollando aplicaciones para Arduino...
En algunos proyectos me encuentro que es dificil inicalizar la EEprom del Arduino (atmega328). El IDE arduino (la version actual es 1.8.2) no genera los ficheros .eep que necesita avrdude para grabar el atmega, entonces declarar variables con EEMEM e inicializarlas en el IDE no sirve para nada.

He escrito un pequeño programa que se carga en el arduino (estoy trabajando con el UNO, pero valdría para otros) y mediante comandos por el puerto serie permite leer o escribir la EEprom y dejarla ya inicializada. Luego se carga el programa que se necesite y se encuentra las EEprom inicada con los valores adecuados.

Por si sirve de ayuda a otros...
Manual:

Código: Seleccionar todo

SetEEprom: 
Sencillo programa para borrar y leer o escribir la EEprom del ATMEGA328

Comandos (case sensitive!) puerto serie, máximo 152 caracteres

  Ver la version:
Read Version

  Borra toda la EEprom, la inicializa a 0xFF (1024 posiciones)
Write Init EEprom 

  Escribir / Leer en direccion decimal (100) una cantidad decimal(10) de bytes en hexadecimal
  Maximo 64 bytes
Write EEprom 100 10 0F0302B1421CA7485823
Read EEprom 100 10

  Escribir / Leer un byte en hexadecimal (4C) en una direccion (2)
Write ByteH 2 4C
Read ByteH 2

  Escribir / Leer un byte en decimal (123) en una direccion (3)
Write ByteD 3 123
Read ByteD 3

  Escribir / Leer una cadena de una longitud maxima (6) en una direccion (4)
    Maximo 128 caracteres
Write String 4 6 Hola Mundo
Read String 4 6
¡No es imposible, lo que pasa es que no sabes como hacerlo!
Aka: no es difícil si sabes como.
http://heli.xbot.es

Avatar de Usuario
heli
Mensajes: 1946
Registrado: Mié Sep 06, 2006 7:28 am
País: España
Ciudad: Alcalá de Henares
Ubicación: Alcala de Henares (Madrid, España)
Contactar:

Re: Mis primeros pasos con Arduino

#200 Mensaje por heli »

Y este es el programa. En un futuro haré que pueda leer / escribir ficheros .hex

Código: Seleccionar todo

/*
 SetEEprom:
 Sencillo programa para borrar y leer o escribir la EEprom del ATMEGA328
 Manualde uso: SetEEprom.txt
 
 Hardware: Arduino UNO
 
 (c) Heli Tejedor, helitp@gmail.com, Mayo 2017
 
 Este Software se distribuye bajo licencia
 Creative Commons 3.0 Reconocimiento, No Comercial, Compartir Igual (CC BY-NC-SA 3.0)
 http://creativecommons.org/licenses/by-nc-sa/3.0/deed.es_ES
 http://creativecommons.org/licenses/by-nc-sa/3.0/
 
 Puerto serie configurado a 115200 bauds 
*/

#include <EEPROM.h>                     // Para manejar la EEprom       

#define VERSION "Set EEprom V 0.1"             // Version 
#define AUTHOR  " (c) Heli Tejedor, Mayo 2017" // Autor 

 // Variables y datos para comunicaciones serie
#define MAXBYTES 64                     // Maximo 64 bytes y 64*2 caracteres
#define MAXBUFF 24+(MAXBYTES*2)         // Para poder hacer un Write EEprom de MAXBYTES
char MySerialBuffer[MAXBUFF];           // Buffer para comunicaciones serie
byte MySerialIndex = 0;                 // Indice para introducir datos

   // Variables para ParseSerialCommand 
char *SavePtr;   
const char Space[] = " \n\r";

// ===============================================================================
char GetHex (char *c)
{
  byte D = *c - '0';
  if (D > 9) D -= 7;
  c++;
  byte E = *c - '0'; 
  if (E > 9) E -= 7;
  return (D<<4|E); 
}

// ===============================================================================
void ParseHEX (uint8_t* Addr, word Len, bool Write)
{
  if (Write)
  {
    while (Len--)
    {
      eeprom_write_byte(Addr++, GetHex(SavePtr));
      SavePtr+=2;
    } 
  }
  else
  {
    while (Len--)
    {
      byte Data = eeprom_read_byte(Addr++);
      if (Data < 0x10) Serial.print('0');
      Serial.print(Data, HEX);
    } 
    Serial.println();  
  }
}

// ===============================================================================
void ParseString (uint8_t* Addr, byte Len, bool Write)
{
  if (Write)
  {
    while (Len)
    {
       Len--;
       eeprom_write_byte(Addr++, *SavePtr);
       if (*SavePtr++ == '\0') break;                // Termina con fin cadena
    }
    while (Len--) eeprom_write_byte(Addr++ , '\0');  // Rellena
  }
  else
  {
    while (Len--)
    {
      byte Data = eeprom_read_byte(Addr++);
      if (Data == '\0') break;                      // Acabar
      Serial.write((char)Data);     
    }
    Serial.println();  
  } 
}

// ===============================================================================
void ParseDEC (uint8_t* Addr, bool Write)
{
  if (Write)
    eeprom_write_byte(Addr, atoi(SavePtr) );             
  else 
    Serial.println (eeprom_read_byte(Addr));
}

// ===============================================================================
// Procesa los mensajes serie recibidos para configuracion 
// ===============================================================================
void ParseSerialCommand (void)
{
  bool WriteMode = false;
  char *Token;
  
  MySerialBuffer[MySerialIndex] = '\0'; // Convierte el bufer en cadena   
  MySerialIndex = 0;

    // Debug
  Serial.println(MySerialBuffer); 
  
    // Comprobar el password 
  Token = strtok_r(MySerialBuffer, Space, &SavePtr); 
   
    // Obtiene el primer token: Read o Write y pone flags adecuados 
  if (strcmp (Token, "Write") == 0) WriteMode = true;
  else if (strcmp (Token, "Read") != 0)   
         { Serial.println(F("Read or Write?")); return; }

    // Obtiene el Second Token: comando
  Token = strtok_r(NULL, Space, &SavePtr);
  if (strcmp (Token, "Version") == 0)
  {
     if (WriteMode); // Reservado para funciones futuras
     else Serial.println(VERSION);
  }
  else if (strcmp (Token, "Init") == 0)
  {
    if (!WriteMode) return;
    if (strcmp (strtok_r(NULL, Space, &SavePtr), "EEprom") == 0)
    {
      uint8_t* Addr = 0;
      while (Addr < (uint8_t*)1024)           // 1024 = tamaño de la eeprom del atmega328
        eeprom_write_byte(Addr++, 0xFF);  
      Serial.print(F("EEprom iniciada a 0xFF: "));
    }
  }    
    // Los siguientes comandos necesitan Src 
  int Src = atoi(strtok_r(NULL, Space, &SavePtr));
  if (strcmp (Token, "ByteH") == 0) 
  {  
    ParseHEX (Src, 1, WriteMode);  
  }    
  else if (strcmp (Token, "ByteD") == 0) 
  {  
    ParseDEC (Src, WriteMode); 
  }
    // Los siguientes comandos necesitan tambien Len 
  int Len = atoi(strtok_r(NULL, Space, &SavePtr));    
  if (strcmp (Token, "EEprom") == 0) 
  {   
    if (Len > MAXBYTES) { Serial.print(F("Demasiados bytes!")); return; }
    ParseHEX ((uint8_t*)Src, Len, WriteMode);      
  }
  else if (strcmp (Token, "String") == 0)      
  {   
    if (Len > MAXBYTES*2) { Serial.print(F("Demasiados bytes!")); return; }    
    ParseString (Src, Len, WriteMode);        
  } 
  else 
  {
    Serial.println(F("Funcion?")); 
    return;
  }
  Serial.println(F("OK"));
}
      
// ===============================================================================
void setup() 
{
  // Inicia el puerto serie a velocidad rapida
  Serial.begin(115200);
  Serial.print(F(VERSION));
  Serial.println(F(AUTHOR));  
}

// ===============================================================================
void loop() 
{                                    
    // Lee datos serie y los salva en buffer, con LF o CR los procesa 
  byte NumC = Serial.available();
  while (NumC--)
  {
    char Leido = (char)Serial.read();
    if (MySerialIndex < MAXBUFF)
    {     
      if (Leido == '\n' || Leido == '\r') 
      { if (MySerialIndex > 0 ) ParseSerialCommand(); }     
      else MySerialBuffer[MySerialIndex++] = Leido;     
    }
    else MySerialIndex = 0;
  }
}
¡No es imposible, lo que pasa es que no sabes como hacerlo!
Aka: no es difícil si sabes como.
http://heli.xbot.es

Responder

¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 0 invitados