Arduineces y otras hierbas (Monitorizar fugas de agua)

[mmcompu]

Había conceptualizado el Arduino como un proto viendo hacia arriba, con su shield encima, pero me brincaba la etiqueta, puesta en lo que yo consideraba el reverso, viéndolo así ya entiendo el porqué.
¿Los capacitores en cada entrada son solo por el tipo de aparato que le vas a conectar o son una buena práctica siempre? Te lo pregunto porque estoy armando un vending y la entrada del monedero me trae jodido, tiene un teclado matricial, un LCD I2C, un módulo de 8 relevadores y dos servos, hasta ahora ninguno me ha dado problemas, excepto el monedero, se activa en RISING, con antidebunce por software de 300 milisegundos, ya intenté con un electrolítico de 47uf entre el pin y tierra, ya puse capacitores de 2000uf en las entradas de 5v y 12v (vienen de una ATX china) pero sigue dando falsos positivos cuando toco los cables.

[Anilandro]

Estas entradas solo van conectadas a contactos de relé libres de tensión, un contacto a la entrada y el otro a masa. Y no importa si hay rebotes, porque el ciclo de exploración será lento, como de 500 mSec, y por otra parte, cada señal de entrada estará asociada a un valor de "millis()", que solamente validará el envío de un otro SMS para esta entrada si el "millis()" actual se ha incrementado al menos el equivalente a 15 segundos respecto al anterior.

...Las entradas están permanentemente puestas a "high" (+5V) con resistencias pull-up externas de 10K, y los condensadores de 5,6 nF son para filtrar posibles transitorios rápidos inducidos en los cables, o señales de RF fuertes. De igual forma he tenido bastante cuidado con las masas del circuito impreso, con pistas gruesas y cubriendo las zonas que han quedado vacías con chapa de cobre estañada. Las líneas de alimentación del Arduino y del módulo GSM están separadas con sus respectivos reguladores, he distribuido condensadores a discreción y hasta un toroide que forma un filtro en "pi" en la entrada al GSM. ...Y es que he visto ya tantos montajes electrónicos en que la teoría del circuito falla luego ante las realimentaciones indeseables, que prefiero no quedarme corto en las precauciones.

A la vez, el módulo GSM está conectado a la placa principal, pero la antena solo tiene un cable de 1,5 metros, y si no hay suficiente cobertura en la zona deberé separar el módulo y colocarlo en una cajita más hacia el exterior del edificio. Eso solo lo averiguaré cuando lo instale.

Este circuito, con muy pocas modificaciones pienso también utilizarlo para sustituir la vieja central de alarmas anti-intrusión del edificio en donde trabajo, que dejó de funcionar y llevamos algunos años sin servicio. Pero en este caso, como los cables de los sensores PIR, (unos 60) son bastante largos, voy a incluir optoacopladores entre estos y las entradas del Arduino.

Un saludo

[Anilandro]

Esta mañana he comenzado con el software para la placa "buscapersonas SMS", y lo primero ha sido comprobar las 72 entradas normales, más 3 de pulsadores y dos salidas de LED.

De las entradas normales, 56 son directas, es decir, van a pines del Arduino Mega, y las 16 restantes las crea un integrado multiplexor 74HC4067, con el que en realidad ganamos 11 entradas, ya que utiliza 1 pin para la salida de datos y 4 pines para direccionamiento.

El programa he hecho es el siguiente:

Código: Seleccionar todo

// Identificación de entradas para placa "buscapersonas SMS". Anilandro, feb 2018

// array de equivalencias entradas_placa/pines_Arduino
const byte ent_pin [74]= {0,21,20,19,18,17,16,15,14,32,34,36,38,40,42,4,5,6,
7,8,9,10,11,12,13,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,51,49,
47,45,43,41,39,37,35,33,31,29,27,25,23,70,71,72,73,74,75,76,77,78,79,80,81,
82,83,84,85} ;

void setup() {
  int f;
  Serial.begin(9600);      // Iniciamos la comunicacion serie
  delay(1000);

  for (f=1; f<73; f++)    // configurar pines de entrada, excepto multiplexor           
    {
    if (f<57) pinMode(ent_pin[f], INPUT);
    }
  pinMode(44, INPUT);      // Entrada pulsador 1
  pinMode(46, INPUT);      // Entrada pulsador 2
  pinMode(48, INPUT);      // Entrada pulsador 3
  pinMode(22, INPUT);      // Entrada multiplexor
  pinMode(24, OUTPUT);    // selección multiplexor S0
  pinMode(26, OUTPUT);    // selección multiplexor S1
  pinMode(28, OUTPUT);    // selección multiplexor S2
  pinMode(30, OUTPUT);    // selección multiplexor S3 
  pinMode(50, OUTPUT);    // Salida Led verde
  pinMode(52, OUTPUT);    // Salida Led rojo
}

//===============================================
//===============================================

void loop() {
  int f;
  int dato;
//===============================================

  for (f=1; f<73; f++)       // Explora entradas de 1 a 72
    {
    if (f<57) dato = digitalRead(ent_pin[f]);  // Lee datos entradas directas 1-56
    if (f>56)
      { 
      Multiplexor(f-57);
      dato = digitalRead(22);     // Lee datos entradas multiplexadas 57-72
      }
    
    Serial.print (f);             // Imprime en monitor nº de entrada placa
    Serial.print ("  ");
    Serial.println (dato);        // Imprime en monitor estado de la entrada
   
    }                   
  Serial.println();
  Serial.println();
    
  delay(4000);
}

//**************************************************************
// Funciones
//**************************************************************

int Multiplexor(byte selec)
{
   digitalWrite(24, bitRead(selec, 0));
   digitalWrite(26, bitRead(selec, 1));
   digitalWrite(28, bitRead(selec, 2));
   digitalWrite(30, bitRead(selec, 3));
}

En este programa no hay nada especial, salvo el array (declarado como constante) que relaciona el número de entrada de la placa, con el número de pin del Arduino Mega, lo cual es necesario para evitar confusiones, ya que por causa del montaje físico y de los pines reservados para otras funciones, la segunda secuencia no puede ser correlativa.

En cuanto a la placa, tras algunos pequeños cambios ha quedado así:




La parte del circuito no es tan elegante, claro, pero he puesto blindajes de masa en las zonas que me han parecido necesarias, y la distribución de las líneas es satisfactorio, así como el poco cableado necesario, en que he utilizado cablecillo telefónico rígido atado con hilo de coser y fijado con cianocrilato.




Continuará...

Saludos a todos

[Anilandro]

Estos días he seguido trabajando con el programa de control, y ya lo tengo bastante digerido. Funciona de forma estable y sólo precisa pequeños retoques...

Al intentar activar el módulo GSM no respondía, no solo en el envío de mensajes, si no también la monitorización de las órdenes del módulo a través de del PC. Y el caso es que con el Arduino UNO funcionaba bien, pero con el Mega no había manera...

Al final el problema fue que la librería "Serial.h", que permite disponer de otras conexiones serie aparte de la normal que va al USB, no funciona con el Mega, que en contrapartida dispone de 4 conexiones serie de origen. Al final, modificando las órdenes para utilizar la "Serial2" y cambiando los pines TX y RX desde el módulo GSM al Arduino, la cosa salió pitando...

...Otro cambio sobre la idea inicial, es que el mensaje SMS vaya a varios destinatarios, permitiendo hasta 5 teléfonos. También he cambiado la disposición de los botones, dejando uno para envìar al PC datos procedentes del módulo GSM, un botón para enviar directamente un mensaje de prueba, y el tercero para conectar y desconectar el envío de mensajes.

Bien, aquí está la última versión del código:

Código: Seleccionar todo

// Array de equivalencias entradas_placa/pines_Arduino
const byte ent_pin [74]= {0,21,20,19,18,2,3,15,14,32,34,36,38,40,42,4,5,6,7,8,9,10,11,12,13,69,68,67,66,65,64,63,62,
61,60,59,58,57,56,55,54,53,51,49,47,45,43,41,39,37,35,33,31,29,27,25,23,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85};

unsigned long hab[74][2];	        // nº habitación y millis()
unsigned long  intervalo=15;	// Intervalo en segundos entre llamadas de la misma habitación
String mensaje;			        // Contiene mensaje a enviar
int envSMS = 1;			// Permiso de envío de SMS
int f;				                // Variable de puntero de bucles      
int tab;				        // variable de tabulación

//===============================================
//===============================================

void setup() {
  int f;
  Serial.begin(9600);	        // Iniciamos la comunicación serie con el PC
  Serial2.begin(9600);	// Iniciamos la comunicación serie con el GSM
  delay(1000);		        // Pausa de 1 segundo

  for (f=1; f<73; f++)	// configurar pines de entrada, excepto multiplexor, el 0 es el pulsador de prueba           
    {
    if (f<57) pinMode(ent_pin[f], INPUT);
    }
  pinMode(44, INPUT);		// Entrada pulsador 1
  pinMode(46, INPUT);		// Entrada pulsador 2
  pinMode(48, INPUT);		// Entrada pulsador 3
  pinMode(22, INPUT);		// Entrada multiplexor
  pinMode(24, OUTPUT);		// Selección multiplexor S0
  pinMode(26, OUTPUT);		// Selección multiplexor S1
  pinMode(28, OUTPUT);		// Selección multiplexor S2
  pinMode(30, OUTPUT);		// Selección multiplexor S3 
  pinMode(50, OUTPUT);		// Salida LED VERDE
  pinMode(52, OUTPUT);		// Salida LED ROJO
  digitalWrite(50, HIGH);		// Enciende LED VERDE

  //***** OJO PROVISIONAL ****** 
  for (int f=1; f<74; f++)           // Asigna números provisionales de habitación
    {
    hab[f][0] = (f+200);  
    }
  //****************************

  for (f=1; f<74 ; f++)          	// Pone a cero valores de tiempo
    {
    hab[f][1]=0;  
    }
}

//===============================================

void loop() {
  byte f;
  byte dato;
  byte activ;
  unsigned long antes;		// millis() de última activación
  unsigned long ahora;		// millis() actuales en segundos
  unsigned long valor;

//===============================================

  for (f=1; f<73; f++)		// Explora entradas de 0 a 72 (0 es el pulsador P1)
    {
    activ=0;
 
    //========== Lectura de datos de las entradas ===========
    
    if (f<57)				// Lee datos entradas directas 1-56
      {
      dato = digitalRead(ent_pin[f]);  
      if (dato==0) activ=1;		// Indica entrada habitación activada (1-56)  
      }
    if (f>56)				// Lee datos entradas multiplexadas de 57-72
      { 
      Multiplexor(f-57);
      dato = digitalRead(22);     
      if (dato==0) activ=1;		// Indica entrada activada (57-72)
      }
        
    //=========== Si la entrada está activada ===============

    if (activ==1)				// Si la entrada nº f se ha activado
      {
      antes = hab[f][1];		// millis() de última activación
      ahora = (millis())/1000;	// millis() actuales en segundos
      hab[f][1] = ahora;		// Si está activado guarda nuevo tiempo en cada ciclo

      if (ahora>(antes+intervalo))		// intervalo mínimo entre activaciones          
        {
        valor = hab[f][0];			// nº habitación         
        if (valor<400) hab[f][0] = valor+400;	 // Si es + marca habitación como activada
        }
      } 

    //====== Impresión de valores en monitor serie ===========

    if(dato==0)                     		// Si la entrada está activada
      {
      Serial.print (f);             		// Imprime en monitor nº de entrada placa
      Serial.print (" ");
      Serial.print (dato);          		// Imprime en monitor estado de la entrada
      Serial.print (" ");
      Serial.print (hab[f][0]);     		// Imprime nº habitación y si está activada
      Serial.print (" ");
      Serial.println (hab[f][1]);   		// Imprime tiempo millis
      }
    }                             			// Fin de bucle de exploración de entradas                   
  tab = 0;
  Serial.println();
  Serial.println();

 //============ Efectuar llamadas ====================

  mensaje="";             			// Borra cualquier mensaje anterior
  
  for (f=1; f<73; f++)    			// Explora todas las habitaciones (y el pulsador de prueba)
    {
    if (hab[f][0]>400)    			// Si detecta habitación activada
      {
      hab[f][0] = (hab[f][0]) - 400;  	// Desactiva habitación 
    
      // Crea mensaje para enviar 

      mensaje = mensaje + "HABITACIO " + (hab[f][0]) + '\n' + '\r' ;
     }
   }

   if ((mensaje!="") || (digitalRead(46)==0))      // Si mensaje con texto o P1 pulsado de prueba
    {
    if (digitalRead(46)==0) mensaje = mensaje + "MENSAJE DE PRUEBA" ; // Añade linea de texto a mensaje
    Serial.print (mensaje);                         	      // Muestra por monitor serie el mensaje     
    Serial.println ("");
    Serial.println ("");   
    if (envSMS==1)
      {
      digitalWrite(52, HIGH);   	// Enciende LED ROJO
      EnviaSMS(1);              	// Envia SMS con mensaje a nº telef 1
      EnviaSMS(2);            	        // Envia SMS con mensaje a nº telef 2
      EnviaSMS(3);            	        // Envia SMS con mensaje a nº telef 3
      //EnviaSMS(4);            	// Envia SMS con mensaje a nº telef 4
      //EnviaSMS(5);            	// Envia SMS con mensaje a nº telef 5
      digitalWrite(52, LOW);    	// Apaga LED ROJO
      }
    }
   mensaje="";                  	// Mensaje ya mostrado y enviado, lo borra
   
  //************************************************************

  switch (envSMS)                   	// P3 conecta/desconecta módulo GSM
    {
    case 0:
      if (digitalRead(48)==0)
        {
        envSMS = 1;                 	// Activa permiso enviar SMS
        digitalWrite(50, HIGH);     	// Enciende LED VERDE                  
        }
      break;    
    case 1:
      if (digitalRead(48)==0)
        {
        envSMS = 0;                 	// Activa permiso enviar SMS
        digitalWrite(50, LOW);      	// Enciende LED VERDE                  
        }
      break;    
    }

  //************************************************************
  
  if (digitalRead(44)==0)           	// P1 envía a PC datos del módulo SIM800L
    {
    Serial.println("Arduino Serial OK");
    Serial2.println("AT+COPS?");		// Si está disponible
    delay(2000);                          	// Pequeña pausa
    Serial2.println("AT+CBAND?");        // Averiguamos bandas disponibles
    delay(2000);                          	// Pequeña pausa

    if (Serial2.available())              	// Si la comunicacion serie normal tiene datos
      {
      while(Serial2.available())          	// Y mientras tenga datos que mostrar
        { 
        Serial.write(Serial2.read());     	// Los sacamos por la comunicacion SoftwareSerial
        } 
      Serial.println();                   		// Enviamos un fin de linea
      }
    while (digitalRead(44)==0){}         // Si P1 pulsado, detiene programa
    Serial.println();
    }
  //************************************************************  
    
  delay(5000);                  		// Ralentizador de bucle principal de programa

}   // fin de LOOP de programa

//**************************************************************
// Funciones
//**************************************************************

void EnviaSMS(int tel)       // Funcion para el envio SMS
  {              

  Serial2.println("AT+CBAND=EGM"); 	        // Activamos banda GSM
  delay(200);                                     	// Pequeña pausa 
  Serial.print("Enviando SMS ");                  // Enviado a PC
  Serial.println(tel);                            	// Enviado a PC
  Serial2.println("AT+CMGF=1\r");              // Activamos envío SMS
  delay(200);                                     	// Pequeña pausa

  // Selecciona número al que enviar SMS xxxxxxxxxxx en formato internacional (34 + número)

  if (tel == 1) Serial2.println("AT+CMGS=\"+xxxxxxxxxxx\"");
  if (tel == 2) Serial2.println("AT+CMGS=\"+xxxxxxxxxxx\"");
  if (tel == 3) Serial2.println("AT+CMGS=\"+xxxxxxxxxxx\"");
  if (tel == 4) Serial2.println("AT+CMGS=\"+xxxxxxxxxxx\"");
  if (tel == 5) Serial2.println("AT+CMGS=\"+xxxxxxxxxxx\"");
  delay(200);                     // Pequeña pausa
  
  Serial2.print(mensaje);	// Enviamos mensaje SMS
  delay(200);			// Pequeña pausa
  Serial2.print(char(26));	// Enviamos el equivalente a Control+Z 
  delay(200);			// Pequeña pausa
  Serial2.println("");		// Enviamos un fin de linea
  delay(200);			// Pequeña pausa
  Serial2.println("ATH");	// Cuelga la llamada
  delay(5000);			// Espera para próximo envío
  Serial.println("SMS enviado");	// Enviado a PC
  }

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

int Multiplexor(byte selec)  // Función de direccionamiento del multiplexor
  {
   digitalWrite(24, bitRead(selec, 0));
   digitalWrite(26, bitRead(selec, 1));
   digitalWrite(28, bitRead(selec, 2));
   digitalWrite(30, bitRead(selec, 3));
  }

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

Un saludo a todos...

[heli]

Buenos dias Anilandro.
He estado viendo el programa, yo también estuve usando un módulo GSM (pero para FTP, no para SMS), y tengo algunos consejos:
La variable "f" hazla local a todos los bucles. En otros micros tener una variable global para bucles ahorra, en arduino lo que ahorra es hacerla local.
El array de pines lo declaras de dimensión 74 pero solo con 73 elementos, luego lo exploras en los bucles hasta menor de 73 y otras veces hasta menor de 74. Yo usaría un #define N_ELEMENTOS 73 y usaría esta definición en los bucles. Te facilitará cambiar la dimensión sin revisar todos los bucles del programa.
Deberías añadir tolerancia a fallos en la comunicación con el GPRS. Si el módulo no contesta o no tienes red no te enteras, y no puedes dar una alarma local. Deberías leer alguna contestación del módulo para detectar si esta respondiendo como esperas.

[Anilandro]

Gracias por los consejos Heli. El programa está ya operativo, pero no es definitivo, por lo cual aún tiene suelto algún gazapo. La dimensión del array es dos unidades mayor porque en las primeras versiones del programa las posiciones 0 y la 73 pensaba utilizarlas para guardar dos constantes de configuración que después he desechado. Además, normalmente me fastidia la cosa del C con los arrays que asigna el primer dato a la posición 0, lo cual luego complica la claridad de su lectura y escritura, y si bien en ambos casos se puede arreglar con un simple -1 al direccionarlo, como me sobra memoria, prefiero perderme la "casilla cero" y no complicarme. La posición 73 ya que sobra, la quitaré.

Este array tiene como puntero los pines físicos de entrada de la placa, del 1 al 72, y solo guarda el número del pin de la placa Arduino Mega que tiene asignado. Lo cual es un dato que no va a cambiar. Por este motivo lo defino como constante. El hecho que a veces explore solo partes del array tiene que ver con el distinto tratamiento de las entradas, si son directas (de la 1 a la 56), o si son multiplexadas (de la 57 a la 72).

En el segundo array "hab[ ]", que es de variables, sigue como puntero el pin de la placa y contendrá el número real de habitación (que será el dato que tiene que enviarse en el mensaje SMS), y también la última lectura de tiempo relativo "millis()" en que dicha habitación ha estado activada, para así descartar las llamadas repetitivas que vienen cada pocos segundos de las consolas de planta mientras no se anula el enclavamiento electromecánico en la habitación activada. Ahora veo que en este array puedo ahorrarme una columna, porque el número de habitación tampoco cambia, y por tanto podría pasarse al primer array de constantes.

...Y si paso el número real de habitación a constantes, otra cosa que quiero cambiar en este array es como se guarda el valor de "millis()", que por el tipo de dato necesita declarar la variable como "unsigned long". En cambio si solo guardo las diferencias de la lectura "millis()" hasta el valor de intervalo de segundos que he establecido, el número resultante nunca superará el 255, con lo cual bastará que dicho array tenga una sola columna y esté declarada como "byte". Con estos cambios (retirar una columna y reducir el tamaño del dato), la sram que utilizará será solo de 1/8 de la versión actual.

En el tema del módulo GSM, es la primera vez que lo utilizo, así que algunos de sus parámetros me vienen de nuevo, a ello se suma que en la información que encuentro por internet hay la típica disparidad de explicaciones, no siempre coincidentes ni en lo básico, con lo cual algunos parámetros AT los he tenido que seleccionar y configurar por el método de "prueba y error".

...Por ejemplo, en el comando para seleccionar la banda a utilizar ("AT+CBAND=EGM") no he encontrado el significado concreto de EGM, de hecho, al consultar mediante ("AT+CBAND?"), el tipo de banda que me devuelve es distinto, pero el módulo funciona igual, tanto con uno como con otro.
Otra función que encuentro interesante para decidir la colocación final de la antena, es la que devuelve la calidad de la señal en db, ("AT+CSQ?"), que en sus distintas opciones no he conseguido que nunca me funcione.
Los tiempos de espera entre órdenes también son una incógnita, ya que he visto ejemplos de código con valores muy dispares. A eso se ha sumado que los que van a utilizar este sistema "buscapersonas", me dijeron hace solo dos días que en realidad necesitaban que el mensaje de aviso apareciera en 3 móviles, y no en 1. Lo cual, si bien a nivel de código es simple de configurar, introduce retrasos en el envío de toda la secuencia. A este respecto, si entre cada envío sucesivo espero 5 segundos, funciona, pero con 3 segundos algo se solapa y solo envía el SMS al primer teléfono de la lista... claro, tampoco sé si este parámetro dependerá de la calidad final de la señal o de la saturación de las redes GSM, con lo cual deberé hacer pruebas "in situ" para ver como responde esta opción...

...Sobre lo de ver si el módulo GSM está activo y el mensaje se ha enviado o no... pues deberé pensarlo. Tal vez podría colocar un pequeño zumbador de alarma en la recepción del geriátrico, que está relativamente cerca del rack en que estará este dispositivo... aunque de todas formas, si el sistema deja de funcionar, las enfermeras de guardia se darán cuenta en poco tiempo, porque sobre la puerta de cada habitación se activa una luz indicadora si se ha pulsado la llamada.


Un saludo

[heli]

Gazapos no he buscado, pero siempre hay que probarlo todo extensamente. A mis alumnos siempre les digo: "un programa esta bien escrito si funciona como debe" porque les da mucha verguenza enseñarme su código fuente. La verdad es que cada programador escribe de una manera distinta, con sus propias manías, y no hay dos programas iguales aunque hagan exactamente lo mismo.

En cuanto a los comandos del módulo GSM, mira a ver que versión de firmware tiene tu SIM900. Yo estoy trabajando con un SIM900 V1.11 http://simcom.ee/documents/SIM900/SIM90 ... _V1.11.pdf y algunas veces los comandos difieren.
El comando para selecionar / consultar la red "AT+CBAND" no acepta el parámetro que comentas "EGM" sino que debe ser "EGSM_MODE" según la página 141 del manual.
Enviar ese comando posiblemente resulte en un error, pero si el módulo vienen configurado de fábrica con "ALL_BAND" , conectará bien.
El significado del mnemonico de cada banda tienes que buscarlo en un manual de telefoía GSM, pero con la wikipedia ya vale: https://en.wikipedia.org/wiki/GSM_frequency_bands
Es mejor enviar el comando "AT+CBAND=ALL_BAND" para que conecte por donde pueda.

El comando para ver el nivel de señal no es "AT+CSQ?", ese es para ver los niveles de señal y bitrates soportados, el comando para preguntar el nivel de señal es "AT+CSQ", página 81 del manual.

He observado que muchos ejemplos de inernet son para versiones viejas de firmware, o incluso contienen errores, hay que revisarlo todo bien...
Los tiempos de respuesta sí que son un problema, no hay dos que usen los mismos y no hay mucha información. Hay que experimentar.

[Anilandro]

Estos días, en el trabajo, estoy bastante atareado con diversos asuntos, y he podido dedicar poco tiempo al sistema avisador, pero después de algunos cambios en el software he conseguido que sea totalmente estable y no tenga reacciones extrañas ante eventos como llamadas simultáneas. Si todo va bien creo que la semana próxima podré comenzar a montarlo en el cuadro del sistema Honeywell.

A la vez, hoy he recibido un nuevo "gatchet" que perseguía desde hace tiempo, pero que hasta ahora no me había decidido a comprar porque todos los que había visto eran caros. Se trata de un sensor de huellas dactilares para Arduino, que se puede encontrar en Ebay sobre los 8€.




Este dispositivo funciona con tensiones entre 3,6 y 6 Volts, con un consumo de corriente de 120 mA. El tiempo de lectura de la huella es de 1 segundo, y tiene 5 niveles de seguridad, mostrando a nivel 3 unos falsos positivos de tan solo uno entre mil, y de falsos negativos de uno entre cien...




...Según entiendo de las especificaciones, cada "firma" dactilar ocupa 256 Bytes y la memoria integrada tiene capacidad para 1.000 huellas distintas. La comunicación con el Arduino (o el PC) se establece por canal serie UART entre 9600 y 57600 bps y el tamaño es de 5,6 cm de largo, por 2 cm de ancho, por 2,15 cm de alto.

Un saludo a todos

[Anilandro]

El otro día me regalaron una cámara de fotos estropeada. Se trata de una "Canon Powershot SX60 HS", una bonita cámara compacta de 16,5 Mpixels, objetivo fijo pero con un impresionante zoom hasta 65x y todas las chorraditas de las cámaras actuales.

La Canon Powershot SX60 desmontada




La cámara tiene como máximo un par de años y ultimamente al encenderse simplemente daba un mensaje de "Error en objetivo, reinicie la cámara", lo cual, en los sistemas microprocesados de hoy en día puede significar cualquier cosa, desde una rotura mecánica, a un sensor o un componente fastidiado en una parte del circuito que no tenga nada que ver con el objetivo.

...Mi esperanza era que fuese realmente un problema mecánico que pudiera repararse, porque con la electrónica de estos aparatos, por compleja e inaccesible, siempre he tenido experiencias frustrantes. Comencé a desmontar la cámara, retirando una cincuentena de mini-tornillos, todos distintos, y algunos de ellos más escondidos que la materia oscura...

Tras llegar dejar el objetivo al aire me centré en el motor que mueve el zoom, que si fallase sería un buen motivo para el mensaje de marras, y el caso, es que en la carcasa que cubre el motor y los engranajes me encontré con una especie de polvillo finísimo con aspecto de herrumbre... rarísimo...

El mecanismo de movimiento del objetivo. A la derecha se ve el motor seguido de cuatro engranajes reductores




Desmonté la carcasa y los engranajes, y después, actuando manualmente sobre la corona del objetivo, éste se movía sin problemas, con lo cual era seguro que el problema no estaba ahí.

Entonces me centré en el motor... pequeño y muy rarito de forma, no es como un motor de corriente continua y tampoco parece un paso a paso, a pesar de que en la cinta plana que llega hasta él hay cinco pistas...y eso tampoco debe ser para un sensor de giro interno, porque dicho sensor, del tipo infrarrojo, está montado en el eje del primer piñón de salida... El caso es que al encender la cámara el motor daba como medio giro y luego se paraba. Una cosa extraña fué que la parte del rotor, que era exterior, junto al engranaje, iba muy duro, costaba hacerlo girar con el dedo, como si tuviera una desmultiplicación interna que dudo mucho que cupiera en algo tan pequeño. Además, el rotor estaba mecánicamente presionado contra una parte fíja... entonces se me ocurrió ponerle una gotita de CRC para que el rozamiento no fuera tan evidente ...y sin hacerle nada más, a partir de este momento simplemente dejó de girar...

El motor, separado del soporte




Busqué un poco por el Google a ver si encontraba algo sobre este extraño motorcito... y entonces una palabra de un texto me sorprendió "ultrasonic motor" ...¿un motor ultrasónico? Confieso que no sabía de su existencia. Sé que hay actuadores ultrasónicos, y que mediante la combinación de fases consiguen mover pequeñas piezas... pero que puedan construir un motor capaz de generar un par apreciable con ultrasonidos fue una sorpresa...

A partir de aquí, en gráficos animados de Internet he visto el funcionamiento de algunos tipos de motores ultrasónicos, pero todos se basan en crear disimetrías mecánicas con piezas que se deforman de una manera determinada, pero este motor no parece tener disimetría alguna, todas las piezas son regulares. Naturalmente no hay ni bobinas ni imanes de ningún tipo. El conjunto "impulsor" es una diminuta pastilla de cerámica piezoeléctrica, pegada directamente a un cilindro metálico que acaba en un círculo perfectamente plano. Esto sería, digamos, el "estator". Mientras que el "rotor" es otro cilindro también plano en sus extremos, presionado contra el anterior por un muelle interior, un muelle que no tienen entre sus extremos ningún tipo de cojinete, a pesar que un extremo gira con respecto al otro... Tampoco pude averiguar de donde había salido el finísimo polvillo con aspecto de herrumbre, ya que el único componente oxidable era precisamente el muelle, que no tenía rastro de óxido en su superficie.

Despiece del motor ultrasónico. De derecha a izquierda: la base fija de montaje, el engranaje de salida, el muelle interior, el rotor, y la parte fija con el disco piezoeléctrico en su extremo superior




En fin, lo desmonté con mucho cuidado, limpié todas sus piezas con acetona, y lo volví a montar... pero a pesar de ir con el máximo cuidado, desde entonces no he conseguido que vuelva a andar, ni el más pequeño amago. No sé si es por alguna historia de falta de excitación por algo que decide el microcontrolador, no sé si es el propio motor, los contactos defectuosos con la pastilla cerámica, si ésta tiene o no posición angular (no lo parece), o que demonios pasa... Además, tomar medidas en circuitos tan delgados o ver que pasa con el osciloscopio resulta muy complicado...

Detalle de los contactos eléctricos superiores, y de la cerámica piezoeléctrica pegada al cilindro "estator ultrasónico"




De momento lo mantengo todo desmontado, a ver si consigo despejar incógnitas. Este motor no parecen venderlo en ningún sitio, ni vale la pena acudir a un servicio de Canon para reparar la máquina, de hecho me la regalaron porque el presupuesto que le hicieron al antiguo dueño era como del 60% del valor de la máquina nueva.

Si alguien sabe algo sobre este tema soy todo oídos... Aunque la verdad, sigo pensando que meter un "motor ultrasónico" en una cámara fotográfica, con lo bonitos y bien que van los brushless y los paso a paso, ya son ganas de complicarse la vida... Lo próximo que será ¿una batería de antimateria ...

Saludos

[baldo]

los ultrasonicos dan un posicionado mas fino que cualquier otro,

si te fijas, en el rotor parece haber huellas de la forma del estator.

hace poco, intente hacerme uno muy simple,

pastilla de zumbador piezoelectrico, de esos que son como pesetas, labre un corte en el aluminio superior, para dividir en dos la escitacion del chisme, soldar cable a cada mitad, + masa. = 3 cables,

le pegue una cuchillita pequeña sobre el canal que habia labrado.

con el arduino, le metia onda cuadrada a una mitad, y la misma desfasada 90º a la otra. a la vez iba variando la frecuencia, en la esperanza de dar con la buena.

de una lampara colgaba hilito, que aguantaba el extremo de un lapiz, el otro extremo reposaba soble la cuchillita.

la idea es que al darle caña, el zumbador zumbase antes de un lado, y con cierto retraso del otro, provocando en la cuchillita un movimiento rotatorio rapido.

NO FUNCIONO.