TODOPIC

Simuladores, editores de PCB, etc => Fabricación de placas PCB => Mensaje iniciado por: Picuino en 30 de Agosto de 2015, 06:14:05

Título: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 06:14:05
Hola a todos,
Acabo de terminar la primera aplicación para dos plaquitas de control que vengo desarrollando desde hace unos meses: control para insoladora.

La primera placa (arriba en la foto) es una controladora con:
   placa Arduino Nano
   entradas/salidas protegidas por resistencias de 100 ohm
   zócalos de pines de entrada salida con pines de alimentación
   conversor DC/DC de 2 amperios. En esta placa está ajustado para suministrar 12Voltios y controlado por el Arduino

La segunda placa (abajo en la foto) es un panel de control con:
   Microcontrolador Attiny88
   Display 7 segmentos y 4 dígitos
   6 leds (uno RGB)
   6 pushbutton
   Zumbador

Las dos placas se comunican por I2C.
El control de la insoladora se realiza en la primera placa, programando el Arduino.
El control de display, teclado y buzzer se realiza en la segunda placa.


La insoladora está basada en tiras de led UV pegadas en el fondo de una caja.
Cuando ví la caja violeta en la tienda, no pude resistirme  :D.

Un saludo.
Título: Re: Controladora para insoladora
Publicado por: KILLERJC en 30 de Agosto de 2015, 06:23:39
Te quedo estupenda la caja  ((:-)) , y por fin vemos la placa :). Veo que decidiste irte por un atmega para la plaquita.

Yo intente comprar leds al exterior pero no lo logre (Aduana lo mas seguro). Asi que voy a ver si por ahi venden tiras de leds de estas para hacerme la mia.
Título: Re: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 07:10:14
Muchas Gracias.

El micro es un Attiny88, más pequeño y barato que un Atmega. Me gustó porque tiene mucha memoria y muchos pines con un precio muy económico:
http://www.mouser.es/search/ProductDetail.aspx?Atmel%2fATTINY88-AU%2f&qs=K8BHR703ZXgMtg%2fwrGHtcw%3d%3d
   10 micros = 0.98 Euros/micro (con iva)
  100 micros = 0.70 Euros/micro (con iva)

Características del Attiny-88:
  1.8 ... 5.5V
  12 MHz externos (8MHz internos) (la mayoría de las instrucciones se ejecutan en un sólo ciclo)
  8 kb programa
  512 bytes ram
  64 bytes eeprom
  TQFP-32 (28 I/O)
  SPI / I2C (sin UART)
  2 salidas PWM asociadas a un timer
  2 Timer
  Compilador GNU C++ gratuito, open source, totalmente optimizado y mantenido por Atmel (casi libre de bugs)

La placa del panel visualizador me está costando mucho ponerla en marcha porque lleva un sistema operativo que se encarga de controlar todo en tiempo real (cada milisegundo se actualiza la lectura de teclado, leds, display, buzzer, etc) además de manejar por interrupciones todas las comunicaciones I2C, conversiones ADC, etc. y realizar cálculos (filtro de pulsación en teclas, contadores de tiempo para teclas, parpadeos, etc)

Por otro lado tengo la librería de interface con Arduino, para comunicarle con la placa visualizadora.

El resultado final es que se puede hacer un control de insoladora sin preocuparse de detalles de bajo nivel.
Este es el programa provisional para Arduino:

Código: C
  1. /***************************************************************************
  2.    TEMPORIZADOR
  3.  ***************************************************************************/
  4. #include <Wire.h>
  5. #include <pc42.h>
  6. #include <EEPROM.h>
  7.  
  8. #define TONE_ERR     Si1         // 59 Hz Simón original
  9. #define TONE_ALARM   Do6
  10. #define MAX_SECONDS  9999
  11. #define EEPROM_ADDR_SECONDS  4
  12.  
  13. /***************************************************************************
  14.    DATOS GLOBALES
  15.  ***************************************************************************/
  16. typedef struct {
  17.    int total_time;
  18.    int countdown;
  19.    int count_millis;
  20.    long millis;
  21.    long millis_old;
  22.    struct {
  23.      unsigned state:3;
  24.      unsigned alarm:3;
  25.    };
  26. } tempo_t;
  27.  
  28. tempo_t tempo;
  29.  
  30. enum {INIT_STOP, STOP, INIT_COUNTDOWN, COUNTDOWN, INIT_ALARM, ALARM};
  31. enum {OFF, ON };
  32.  
  33.  
  34. /***************************************************************************
  35.    SETUP Y BUCLE PRINCIPAL
  36.  ***************************************************************************/
  37.  
  38. void setup() {
  39.   pc.begin();
  40.   tempo_init();
  41. }
  42.  
  43.  
  44. void loop() {
  45.  
  46.   // Dispatcher
  47.   switch(tempo.state) {
  48.  
  49.   case INIT_STOP:  
  50.     pc.ledBegin();
  51.     pc.ledWrite(1, HIGH);
  52.     power_off();
  53.     tempo.state = STOP;
  54.     break;
  55.  
  56.   case STOP:
  57.     pc.dispNum(tempo.countdown);
  58.     tempo_stop();
  59.     break;
  60.  
  61.   case INIT_COUNTDOWN:
  62.     if (tempo.countdown > 0) {
  63.       pc.ledBegin();
  64.       pc.ledWrite(4, HIGH);
  65.       tempo.millis_old = millis();
  66.       tempo.state = COUNTDOWN;
  67.     }
  68.     else {
  69.       tempo.state = INIT_STOP;
  70.     }
  71.     break;
  72.  
  73.   case COUNTDOWN:  
  74.     tempo_countdown();
  75.     break;
  76.  
  77.   case INIT_ALARM:
  78.     power_off();  
  79.     pc.ledBegin();
  80.     pc.ledWrite(3, HIGH);
  81.     tempo.millis = millis();
  82.     tempo.alarm = 0;
  83.     tempo.state = ALARM;
  84.     break;
  85.  
  86.   case ALARM:
  87.     alarm();
  88.     break;
  89.    
  90.   default:
  91.      tempo.state = INIT_STOP;
  92.   }
  93. }
  94.  
  95.  
  96. /***************************************************************************
  97.    FUNCIONES
  98.  ***************************************************************************/
  99.  
  100. //
  101. // STOP
  102. //
  103. void tempo_stop(void) {
  104.   char keys;
  105.   pc.dispDots(0);
  106.  
  107.   keys = pc.keyCount(KEY_DOWN);
  108.   tempo.countdown -= keys;
  109.   if (tempo.countdown < 0)
  110.     tempo.countdown += MAX_SECONDS + 1;
  111.  
  112.   keys = pc.keyCount(KEY_UP);
  113.   tempo.countdown += keys;
  114.   if (tempo.countdown > MAX_SECONDS)
  115.     tempo.countdown -= MAX_SECONDS + 1;
  116.  
  117.   if (pc.keyPressed(KEY_UP) && pc.keyPressed(KEY_DOWN)) {
  118.      tempo.countdown = tempo.total_time;
  119.      tempo.count_millis = 0;
  120.   }
  121.    
  122.   if (pc.keyEvents(KEY_RIGHT) & 2) {
  123.     tempo.total_time = tempo.countdown;
  124.     pc.dispWrite(0,0,0,0);
  125.     eeprom_write16(EEPROM_ADDR_SECONDS, tempo.total_time);
  126.     delay(100);
  127.   }
  128.  
  129.   if (pc.keyEvents(KEY_ENTER) & 1) {
  130.     tempo.state = INIT_COUNTDOWN;
  131.   }
  132.  
  133.   pc.dispNum(tempo.countdown);
  134. }
  135.  
  136.  
  137. //
  138. // COUNTDOWN
  139. //
  140. void tempo_countdown(void) {
  141.  
  142.   // Activar la salida de potencia
  143.   power_on();
  144.  
  145.   // Actualizar la cuenta atrás
  146.   tempo.millis = millis();
  147.   tempo.count_millis += tempo.millis - tempo.millis_old;
  148.   tempo.millis_old = tempo.millis;
  149.  
  150.   while (tempo.count_millis >= 1000) {
  151.     tempo.countdown--;
  152.     pc.dispNum(tempo.countdown);
  153.     tempo.count_millis -= 1000;
  154.     if (tempo.countdown == 0) break;
  155.   }
  156.  
  157.   if (tempo.count_millis < 500)
  158.     pc.dispDots(0);
  159.   else
  160.     pc.dispDots(1);
  161.  
  162.   if (tempo.countdown == 0) {
  163.     power_off();
  164.     tempo.state = INIT_ALARM;
  165.   }
  166.  
  167.   if (pc.keyEvents(KEY_ENTER) & 1) {
  168.     tempo.state = INIT_STOP;
  169.   }  
  170. }
  171.  
  172.  
  173. //
  174. // ALARM
  175. //
  176. void alarm(void) {
  177.   pc.dispWrite(SS_E, SS_n, SS_d, SS_SP);
  178.  
  179.   switch(tempo.alarm) {
  180.   case 0:
  181.     alarm_sound();
  182.     tempo.alarm = 1;
  183.     break;
  184.   case 1:
  185.     if (millis() > tempo.millis + 1000) {
  186.       alarm_sound();
  187.       tempo.millis += 1000;
  188.       tempo.alarm = 2;
  189.     }
  190.     break;
  191.   case 2:
  192.     if (millis() > tempo.millis + 4000) {
  193.       tempo.millis += 4000;
  194.       pc.buzzPlay(TONE_ALARM, 16);
  195.       pc.buzzPlay(0, 16);
  196.     }
  197.     break;
  198.   }
  199.  
  200.   if (pc.keyEvents(KEY_ENTER) & 1) {
  201.     pc.buzzBegin();
  202.     tempo.countdown = tempo.total_time;
  203.     tempo.count_millis = 0;
  204.     tempo.state = INIT_STOP;
  205.   }
  206. }
  207.  
  208.  
  209. //
  210. // Read integer data from EEPROM
  211. //
  212. int eeprom_read16(int addr) {
  213.   return (EEPROM.read(addr + 1) << 8) | EEPROM.read(addr);
  214. }
  215.  
  216. //
  217. // Write integer data to EEPROM
  218. //
  219. int eeprom_write16(int addr, int data) {
  220.   EEPROM.write(EEPROM_ADDR_SECONDS, tempo.total_time);
  221.   EEPROM.write(EEPROM_ADDR_SECONDS+1, tempo.total_time>>8);
  222. }
  223.  
  224. //
  225. // Inicializar datos del temporizador
  226. //
  227. void tempo_init(void) {
  228.   tempo.total_time = eeprom_read16(EEPROM_ADDR_SECONDS);
  229.   tempo.state = INIT_STOP;  
  230.   tempo.alarm = OFF;
  231.  
  232.   tempo.millis = 0;
  233.   tempo.millis_old = 0;
  234.  
  235.   tempo.countdown = tempo.total_time;
  236.   tempo.count_millis = 0;
  237. }
  238.  
  239. //
  240. // Sound Alarm
  241. //
  242. void alarm_sound(void) {
  243.   pc.buzzPlay(TONE_ALARM, 62);
  244.   pc.buzzPlay(0, 62);
  245.   pc.buzzPlay(TONE_ALARM, 62);
  246.   pc.buzzPlay(0, 62);
  247.   pc.buzzPlay(TONE_ALARM, 62);
  248.   pc.buzzPlay(0, 62);
  249.   pc.buzzPlay(TONE_ALARM, 62);
  250.   pc.buzzPlay(0, 62);
  251. }
  252.  
  253.  
  254. //
  255. // Encender la fuente de alimentación
  256. //
  257. void power_on(void) {
  258.   // Desactivar la salida de potencia
  259.   pinMode(10, OUTPUT);
  260.   digitalWrite(10, HIGH);
  261. }
  262.  
  263.  
  264. //
  265. // Apagar la fuente de alimentación
  266. //
  267. void power_off(void) {
  268.   // Desactivar la salida de potencia
  269.   digitalWrite(10, LOW);
  270.   pinMode(10, INPUT);
  271. }

Me falta añadir control de tensiones de alimentación y corriente de suministro a la insoladora.

Un saludo.
Título: Re: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 07:20:30
Lo más parecido en PIC al Attiny88 es:
PIC16F1516-I/SS que cuesta 1.44 Euros para 10 unidades y tiene capsula ssop-28, más grande.
PIC16LF1906-I/MV que cuesta 1.50 Euros para 10 unidades con cápsula UQFN-28

Además el compilador optimizado es bastante caro. Cuando hay que aprovechar 8kb al máximo, esto cuenta.
Un saludo.
 
Título: Re: Controladora para insoladora
Publicado por: KILLERJC en 30 de Agosto de 2015, 07:56:13
un tercio del precio del PIC y terminas haciendo las cosas mas rapido.
Hace un tiempo estuve viendo el tema de los atmega, ahi tratando de ayudar a una persona en la parte de DMX, el cual le pase el codigo de ASM a C.
Bastante simple el ASM. Ami que me gusta tanto, asi que ahi me interiorize con respecto a como funcionan
 
http://www.atmel.com/Images/doc42055.pdf

Citar
La placa del panel visualizador me está costando mucho ponerla en marcha porque lleva un sistema operativo que se encarga de controlar todo en tiempo real (cada milisegundo se actualiza la lectura de teclado, leds, display, buzzer, etc) además de manejar por interrupciones todas las comunicaciones I2C, conversiones ADC, etc. y realizar cálculos (filtro de pulsación en teclas, contadores de tiempo para teclas, parpadeos, etc)

Y te da para hacer todo eso en 1ms ?

Ya que por ejemplo el teclado 10ms y no habria problema al ser un proceso "lento", eso tambien te resuelve el rebote. O decidiste ir por el milisegundo?
Título: Re: Controladora para insoladora
Publicado por: juaperser1 en 30 de Agosto de 2015, 09:02:27
Hola picuino, una pregunta, porque dos placas y no una? Tienes pensado reutilizar hardware? Hacerlo modular?


Yo estoy trabajando en un hardware modular con microprocesador (actualmente parado por estudios). Pero la idea es hacer un SoM general y placas genéricas para enchufar con formato y apariencia como las memorias RAM. Es algo así de modular tu idea?


Por cierto buen trabajo, a simple vista se ve un buen rutado.

Un saludo.
Título: Re: Controladora para insoladora
Publicado por: stk500 en 30 de Agosto de 2015, 09:09:35
pues yo me alegro que hay moderadores que use Atmel  ya :D :D y le encuentren el gustillo!!!!
Yo me reforme´una insoladora de Florecente con alimentacion Digitales y un control de tiempo con un Atmega8 muy simple y todavia no me he hecho una placa,soy muy vago para hacer placa  :x por el rollo de los liquidos, no naci para ser Quimico  :D

Saludos
Título: Re: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 10:01:48
Y te da para hacer todo eso en 1ms ?

Ya que por ejemplo el teclado 10ms y no habria problema al ser un proceso "lento", eso tambien te resuelve el rebote. O decidiste ir por el milisegundo?

El teclado es mucho más rápido de lo que parece.

Si intentas conseguir con un cronómetro digital que marque 0.50 segundos (pulsando start-stop), verás lo fácil que es. No cuesta mucho afinar y repetir siempre la misma lectura.
La placa quiero que sirva para jugar. Un tipo de juegos divertidos intenta que pulses la tecla justo en un momento determinado (por ejemplo sincronizado con una música o con una secuencia de leds). Si quieres diferenciar puntuación entre dos jugadores buenos no tienes más remedio que medir milisegundos.

Otra aplicación de los milisegundos es conseguir números aleatorios. Si pulsas una tecla con cierta cadencia y mides en centésimas, verás que hay una cadencia que se repite mucho, con pocas variaciones. Midiendo en milisegundos consigues más variaciones, más ruido, que te sirve como base para generar un número aleatorio.
Esto es util por ejemplo para simular un dado electrónico con números aleatorios de verdad, no pseudoaleatorios.

Con el Attiny a 8Mhz, se ejecutan unas 7500 instrucciones por milisegundo. Con 2000 a 4000 me sobran para gestionar todo.

Uno de los problemas que tengo es dejar las interrupciones con un programa mínimo y sincronizar el tratamiento de datos con otro programa fuera de la interrupción.

Saludos.
Título: Re: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 10:09:33
Hola picuino, una pregunta, porque dos placas y no una? Tienes pensado reutilizar hardware? Hacerlo modular?

En efecto, quiero hacerlo muy modular y muy rápido de montar.

Las placas no están dedicadas a la insoladora. La idea es montar el circuito cada vez que quiera insolar. Si te fijas, sólo hay que conectar dos cables y alimentación.
Luego cargas el programa y listo.

Cuando acabas, lo desmontas hasta la siguiente vez.

La idea es que varias placas te sirvan para realizar muchos montajes lo suficientemente rápido como para montarles en 2 minutos.

El montaje modular se conecta mediante cables, de esta forma es más sencillo y modular que mediante shields. Las placas pueden ser más pequeñas.
La placa Arduino puede manejar 8 o 9 placas alrededor, unidas por cables estandar.

Uno de los temas con el que estoy ahora es estandarizar las conexiones para que resulten lo más sencillas y potentes que se pueda.

Un saludo.
Título: Re: Controladora para insoladora
Publicado por: juaperser1 en 30 de Agosto de 2015, 11:03:57
Las placas prototipos también las suelo usar con cables los típicos que comprar en eBay que te vienen 80 por 2 euros, pueden ser machos, hembras o mixtos.
Vienen en paralelo para que los dejes así o para que tu los sueltes. Pero cuidado, estos cables no estan, polarizados y es posible equivocarse al conectarlos, hay que tenerlo en cuenta si buscas una estandarización para tus productos,  yo buscaria unos cables para bus con conexión polarizada para que sea imposible equivocarse. Es una ventaja de las shield que es difícil equivocarse al conectar eso.

Yo pensaría en i2c, como bien has puesto o bus can, mas libre de errores,  mas concretamente el flexcan mucho mejor y mas rapido pero para eso deberías ir a freescale o poner integrados a parte.

El spi no estandarizaría nada y limitaría por los cables, el rs485 es muy flexible y es mucho juego pero claro, debes meter ic y no creo que merezca la pena.

También pensaría, la conexión del bus en serie o en paralelo, en paralelo la placa madre deberá tener muchas conexiones  pero los cables pueden ser de pequeño calibre, en serie deberás colocar unos cables de alimentación junto con los del bus pensador para soportar, la intensidad si metes micros (unos 20 mA de media) mas display mas integrados etc etc.

Yo en un aparato que hice de 49 microcontroladores (mas circuitos adyacentes) en serie consumían unos 2,3 amperios y tuve que tenerlo en cuenta porque la caída de tensión al final de la pista en el primer prototipo era considerable, no tanto como para afectar gravemente pero me cure en salud y tuve que arreglarlo.

Un saludo, espero te sirva de ayuda.
Título: Re: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 13:58:56
La polaridad de los pines es un problema importante.

La mejor solución que he encontrado hasta ahora para cables polarizados es el conector Molex:

MOLEX:
  (http://i00.i.aliimg.com/photo/v0/555953962/Molex_2510_7_Pin_Connector.jpg)

  Pros:
  Mantiene polaridad
  Conexión y desconexión sencilla
  Tiene baja resistencia de conexión. Sirve para alta corriente.
  Conectores baratos.

  Contras:
  Cable caro o hay que construirlo a mano.
  Ocupa más espacio en la placa que los simples pines macho/hembra
  Obliga a que el PCB tenga pines macho.
  Es difícil intercambiar el orden de los pines


Lo que he hecho por ahora es proteger la conexión I2C
La placa visualizadora tiene un Mosfet que sólo conecta la tensión si la polaridad es correcta.
La ventaja frente al diodo es que en el mosfet casi no cae tensión, no se calienta y el encapsulado es más pequeño.
Las entradas/salidas tienen una resistencia de protección. En caso de conectarlas a alimentación, los diodos de clamp del uC protegerían a este.

La conexión I2C es ideal. Barata, casi todos los micros la tienen, sencilla de manejar, pocos cables, sin circuitos añadidos, robusta, maneja hasta 128 dispositivos en la misma línea.

En principio esta controladora es para conectar ctos en estrella (y alguno más complejo en linea con el bus I2C)
Si tuviese que alimentar muchas placas en línea, me plantearía una alimentación de mayor tensión y algún tipo de regulador en cada cto. Tiene la ventaja de desacoplar interferencias.
Utilizando 7 voltios en Vcc y un regulador barato (http://www.mouser.es/ProductDetail/NJR/NJM2866F05-TE1/?qs=sGAEpiMZZMsGz1a6aV8DcH3OXID0CKTzUemL%252bNQ8lO0%3d) por ejemplo.


Un saludo.
Título: Re: Controladora para insoladora
Publicado por: juaperser1 en 30 de Agosto de 2015, 14:31:51
lo malo de los molex es que son bastante grades y engorrosos, pero parece la mejor solucion, una vez vi unos conectores a medida que eran ideales, cable flexible y se unian con una simple pestañita, similares a los conectores de circuito flexible, pero no los he encontrado por ningún lado por eso supongo que serán a medida:

el aparato del que te hable antes en bus eran 49 circuitos en I2C y cada uno tenia su regulador, a 3V3 desde una fuente conmutada de 5 Amperios con 7 voltios, pero los dos cables del I2C iban a pelo y esa era la que no me gustaba que tuviera caida de tensión, era una placa madre como un folio de grande con los modulos soldados directamente como hibridos y algunas pistas eran bastante largas, por que lo que tuve que tener en cuenta bastantes cosas, para que tuviera fallos de comunicación.

en cuanto a proteger el circuito con un mosfet, siendo curiosidad podrias ponerlo, o enviarmelo por privado, no es para copiarte nada ni mucho menos es para aprender de la gente con experiencia, y si no quieres hacerlo lo comprendo perfectamente, y no pasa nada.

yo en la maquina esta que te comento, la alimentación de cada modulo la controlaba el maestro, mediante un limitador de intensidad e interruptor que hice con transistores BJT, y el modulo solo se habilitaba si el maestro se lo permitía y bajo ningún concepto podía demandar mas intensidad de la permitida, ya que estos módulos comprobaban unos circuitos que podían tener cortos y circular una corriente excesiva, por lo tanto si se detectaba una corriente inusual se desabilitaba el modulo y el maestro informaba a la aplicación visual que en ese modulo estaba comprobando una placa cortocircuitada y era desabilitado.

un saludo

Título: Re: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 14:40:34
El circuito con mosfet no es complicado:

(https://hackadaycom.files.wordpress.com/2011/12/p-fet-reverse-voltage-protection1-e1416351493179.png?w=470)

En mi caso utilizo un mosfet de 20Vgs y no necesita resistencia ni zener. Un sólo mosfet y entrada protegida  ;-)

Saludos.
Título: Re: Controladora para insoladora
Publicado por: juaperser1 en 30 de Agosto de 2015, 14:48:28
a entiendo un simple mosfet en serie, claro es muy simple si lo conectas al reves no funciona, me habia imaginado otra cosa bastante mas complicada cuando has dicho un diodo mosfet de protección jeje

gracias un saludo ;-)
Título: Re: Controladora para insoladora
Publicado por: Picuino en 30 de Agosto de 2015, 15:02:38
Cambio diodo mosfet por mosfet en el mensaje.
Lo del "diodo mosfet" viene bien para saber la orientación del mosfet (al contrario de lo habitual)

Saludos.