Arduino

TextWrangler para editar scripts Arduino

0

Sigo con mi linea de los post breves pero útiles

El IDE de Arduino esta muy bueno, es muy útil para subir nuestros programas al Arduino; pero al momento de revisar un programa para ver si alguna linea de programación anda fallando es algo tediosa la ventanita del IDE.

Existen programas especializados para escribir código, TextWrangler es una opción genial (y gratuita) de los creadores de BBedit, puede identificar el lenguaje en el que escribes y formatearlo para mayor comodidad, ya sea C+, HTML, PHP, etc.

Lamentablemente no viene por default el lenguaje de Arduino, pero eso no ha sido impedimento para que aprovechando la capacidad modular del TextWrangler, se le puedan agregar lenguajes de programación extras.

Agregar el lenguaje al TextWrangler (o BBEdit si lo tienes) es de lo mas sencillo, abrimos nuestro Finder y vamos a la carpeta

~/Library/Application Support/TextWrangler/Language Modules/

y copiamos los 3 archivos plist que descargamos de esta pagina

https://github.com/carlynorama/Arduino-BBEdit

Ahora al abrir TextWrangler, podemos seleccionar el lenguaje de programación en una pestañita que esta en la parte inferior

Abrimos un script de Arduino y vemos como se formatea el código y se separan en bloques el código (los void, el setup, loop), muy útil para agrupar y revisar mas comodo

Se pueden colapsar bloques de código para cuando tengamos un script muy largo, podamos simplificar la pantalla y así revisar mas rápido

Salvamos y el script esta listo para cargarlo mediante el IDE oficial

Bateria LiPo para Arduino: Deporte extremo?

0

?

Ya diseñamos nuestro súper proyecto en Arduino, el código funciona genial, lo presumimos y enseñamos a todo mundo (aunque la mayoría no tenga ni idea de que hablamos); el siguiente paso natural: volverlo potable, no estar atado a una fuente de alimentación grande.

Dependiendo de nuestro proyecto será la necesidad de cierto tipo de baterías, si usamos un simple chip AtTiny85 podemos usar una pila de reloj (2032, 2025, etc) si usamos la placa Arduino UNO necesitamos mas poder (hasta 12V).

Investigando un poco, me topé con las pilas LiPo (Polimero de Litio), una variante de las muy usadas pilas Li-Ion que se usan en teléfonos inalámbricos, celulares, lo que sea. Las pilas LiPo son muy usadas en aparatos de radio control (helicópteros, carros, etc) ya que la relación tamaño / potencia es impresionante; una pila pequeña puede llegar a dar unos 20 Ampers que los motores eléctricos son felices de devorar.

Aunque todo tiene su precio…

Los materiales con los que se hace una pila LiPo son altamente inflamables, a la recarga, al abuso en el uso, son sensibles a la luz, al calor, a las caídas, a la presión (infinidad de chistes misóginos podrían aplicarse aquí); lo que las convierte en un elemento muy peligroso. Para cargarlas hace falta ponerlas en una bolsa especial no flamable, recargarlas siempre a la vista y controlando temperatura; definitivamente las carga el diablo.

Pero vale la pena tanto peligro?

Depende para lo que la usemos, si el tamaño es importante, vale la pena tener una pila que dé tanto poder y pese y mida casi nada.

Hagamos una comparación en precio, suponiendo que usamos proveedores con ojos rasgados y envíos gratuitos; suponiendo que nuestro proyecto Arduino consume 70mAh (unos cuantos leds, un buzzer y un LM35)

Una pila cuadrada NiMH de 9V y unos 400mAh cuesta unos 74 pesos, nos durará 5.71 horas (400/70) unos 12.95 pesos de energía por hora.

Una pila LiPo de 11.1V 20C y unos 850mAh cuesta unos 77 pesos y nos va a durar 12.14 horas a 6.34 pesos la hora de nervio que vaya a explotar la pila.

A parte de ser el doble de cara una pila cuadrada de 9V (en termino de tiempo de uso), solo podemos usarla en proyectos que no pasen de 400mAh de consumo, en cambio la pila LiPo 20C nos puede dar hasta 17A (.850*20), así que podemos usar una pila de estas para encender LEDs súper brillantes (yo he usado una pila LiPo para prender 110 LEDs y es impresionante, claro se consume la pila en 2 minutos).

GPS Datalogger v2 – MicroSD Shield + Arduino + Holux M1000B

1

Hace unos días agarré una caja de Altoids y le metí un Arduino UNO SMD Edition, un adaptador MicroSD soldado a unos pin headers y unos cuantos cables para tener un aparato que pudiera leer datos NMEA de un GPS Holux y guardarlos en un archivo de texto

Funcionaba genial, sin ningún problema podía leer los datos del GPS ademas del look genialmente geek que le da la caja de Altoids, pero parte de esto de la onda cositas es ir evolucionando, así que pedí un MicroSD Shield y es totalmente genial.

Dato importante del Shield, por default trae el pin 4 digital como Pin Select en vez del 10 que es el default en el Arduino, pero en la parte de atras tiene unos pequeños jumpers que soldando y desoldando hacen el truco y asignamos al pin de nuestra preferencia

El Shield trae unas perforaciones para agregar diferentes componentes, yo no las he usado porque estoy en la disyuntiva de seguir usando mi GPS Bluetooth o pedir un modulo GPS, que seria MKT ya que las opciones SIRF están muy limitadas y caras.

arduino gps logger

La próxima versión tendrá un LCD Shield para mostrar información, como coordenadas, hora, temperatura (vía un LM35), quizá una lectura de la pila LiPo, la distancia que falta para un punto puesto en la memoria y lo que den 32Kb de memoria en el Atmel 328 del Arduino UNO

Post básicamente para presumir mis fotos de producto ;)

Control IR para cámaras Nikon – intervalometro, trigger y con Arduino

0

Este será uno de los post mas breves y sencillos de este blog, pero súper útil para los viciosos de la foto y la onda DIY.

Hay unos disparadores infrarrojos de Nikon (el ML-L3)que sirven para tomar fotos solamente y cuestan unos 6 usd y están los intervalometros para estas cámaras (que son usualmente por cable) y cuestan unos 20 usd en Ebay (nada mal el precio de hecho)

Pero qué tal gastarnos unos 4 usd en total para tener ambos aparatos en uno solo y programable a nuestro gusto, expansible, memorable y lo mejor Open Source, nada mal, no?

Asi que para armar este juguetito DIY mega geek necesitaremos:

  • Micro AtTiny85
  • Resistencia 100 ohms
  • tijeras de punta chatita
  • LED infrarrojo con filtro de dia
  • Arduino UNO preparado para ser usado como ISP
  • Lo mejor de todo es que al ser tan sencillo el micro podemos usar una pila de reloj 2032 para alimentar el circuito o 2 pilas AA o como uds gusten

    Voy a suponer que ya leyeron mi súper post de como usar el Arduino como ISP y como programar el AtTiny85 con reloj de 8Mhz internos, si no, manden mensaje.

    El montaje es de lo mas sencillo, acá esta un ejemplo para usarlo de intervalometro sin botones de inicio o fin, lo mas básico de lo básico, de ahí podemos agregar botones (el AtTiny tiene 3 puertos Analogicos así que podemos usar uno con botones, o pulsadores para mis cuates hispanos, y unas resistencias de diferente valor para obtener lecturas distintas y así saber cuando disparar, enfocar, comenzar el intervalo, etc etc)

    ir trigger nikon

    El script es de lo mas simple y me lo fusilé de la siempre útil pagina de la ladyada de Adafruit (juro que tendré que comprar algo de esa pagina algún día, bueno cuando Sparkfun deje de tener cosas tan interesantes y rojas).

    El código es bastante sencillo y lo adapte para usarlo con el AtTiny85

    
    // This sketch will send out a Nikon D50 trigger signal (probably works with most Nikons)
    // See the full tutorial at http://www.ladyada.net/learn/sensors/ir.html
    // this code is public domain, please enjoy!
     
    int IRledPin =  3;    // LED connected to digital pin 3
     
    // The setup() method runs once, when the sketch starts
     
    void setup()   {                
      // initialize the IR digital pin as an output:
      pinMode(IRledPin, OUTPUT);      
     
    }
     
    void loop()                     
    {
     
      SendNikonCode();
     
      delay(60*1000);  // wait one minute (60 seconds * 1000 milliseconds)
    }
     
    // This procedure sends a 38KHz pulse to the IRledPin 
    // for a certain # of microseconds. We'll use this whenever we need to send codes
    void pulseIR(long microsecs) {
      // we'll count down from the number of microseconds we are told to wait
     
      cli();  // this turns off any background interrupts
     
      while (microsecs > 0) {
        // 38 kHz is about 13 microseconds high and 13 microseconds low
       digitalWrite(IRledPin, HIGH);  // this takes about 3 microseconds to happen
       delayMicroseconds(10);         // hang out for 10 microseconds
       digitalWrite(IRledPin, LOW);   // this also takes about 3 microseconds
       delayMicroseconds(10);         // hang out for 10 microseconds
     
       // so 26 microseconds altogether
       microsecs -= 26;
      }
     
      sei();  // this turns them back on
    }
     
    void SendNikonCode() {
      // This is the code for my particular Nikon, for others use the tutorial
      // to 'grab' the proper code from the remote
     
      pulseIR(2080);
      delay(27);
      pulseIR(440);
      delayMicroseconds(1500);
      pulseIR(460);
      delayMicroseconds(3440);
      pulseIR(480);
     
     
      delay(65); // wait 65 milliseconds before sending it again
     
      pulseIR(2000);
      delay(27);
      pulseIR(440);
      delayMicroseconds(1500);
      pulseIR(460);
      delayMicroseconds(3440);
      pulseIR(480);
    }
    
    

    Con este código tendremos fotos cada minuto mientras este prendido el AtTiny, ya podemos agregar nuestro código para tomar determinado numero de fotos y cada cierto tiempo; también podemos agregar un potenciometro para un poco de interactividad y aumentar o disminuir el numero de fotos y la frecuencia, que se yo, el cielo (y 8K de memoria del AtTiny85 son el limite).

    Guardando logs GPS con Arduino – La forma divertida y artesanal

    0

    Tengo la peor memoria que existe, recuerdo que fui a x lado pero no exactamente donde es.

    Ahora esta de moda que la cámara traiga de todo, mi Nikon P7000 tiene un nivel electrónico para poner las fotos derechas (nunca lo uso, me gustan las fotos chuecas), hay unas que tienen wifi, pantallas enfrente y atrás, claro también están con GPS, para poner en un mapa donde tomamos las fotos, cosa bastante útil en algunas ocasiones (búsqueda de locaciones para fotos y para saber donde anduvimos después de una noche de copas).

    Pero que hacemos si no tenemos una cámara con GPS y los modelos que existen no son lo suficientemente interesantes como para invertir en ellos solo por el GPS, pues bueno recurrimos al buen Arduino para que nos salve el día, manos a la obra.

    Esto del Arduino es un poco enviciante, terminas queriendo hacer todo con este pequeño cacharrito electrónico. Pero esto es por una buena causa.

    Tomamos una caja de Altoids, son la elección por excelencia de los proyectos electrónicos DIY, en este caso hice hoyos para colocar mi primer Arduino UNO SMD que le cambie el puerto USB.

    DSCN2432

    Existen varias alternativas para hacer un GPS con arduino, podemos usar Shields especiales y módulos GPS que conectamos al shield y listo, de pe a pa un GPS DIY; en este caso usare mi gran Holux M1000B (como me ha salido útil) aprovechando que tiene la capacidad de enviar datos seriales a través del mini USB.

    Compré un shield micro SD, pero como soy desesperado, empece a hacer pruebas conectando un adaptador micro SD a SD directamente a unos pins y de ahí al Arduino.

    Y como debe ser, empece todo usando un breadboard para jugar a la piñata electrónica (pegas palos por todos lados esperando atinarle)

    DSCN2418

    En cuanto al código, no esta nada simple, busqué varias librerías que me permitieran escribir al SD, pero unas muy complicadas para mi nivel kinder en electrónica, otras que de plano no funcionaban en la versión del IDE; pero la librería que me funcionó al final es SdFat y TinyGPS para el GPS.

    AL final, todo en la caja de Altoids, aunque cuando llegue el shield supongo que no cabrá en la caja, a ver que invento. Le adapte una pila LiPo de 11.1V y amarrado con una liga de caucho, ahora a salir a probar este data logger.

    DSCN2425

    Librerias en Arduino – Como y por donde

    4

    Arduino Llegara un momento en que al usar Arduino tengamos que echar mano a las famosas librerias, esos pedazos de software que programaron unos super geeks y nos permiten a los mortales usar facilmente hardware especializado.

    Digamos que queremos usar un control infrarrojo, ya sea que tenemos la súper idea de controlar nuestra tele con el Arduino o que queremos manejar la cámara, todo es valido para usar un aparato de 40 usd (el Arduino) hecho por nosotros en vez de usar un control infrarrojo de 5 usd para la cámara; no importa el que lo hayamos fabricado y programado es mas importante, o no?

    Pues si usamos una Mac para correr el buen Arduino IDE 1 la cosa se complica un poco, no tenemos esa carpeta fea llena de carpetas como los de Windows, así que donde ponemos nuestra librería?

    Hay 2 opciones, podemos abrir el Arduino.app y copiar la librería en el folder libraries, para eso vamos a Aplicaciones y con el botón derecho (o haciendo control + clic) y seleccionamos Mostrar contenido del paquete

    Arduino Libraries

    O bien un método menos laborioso, vamos al folder donde tengamos nuestros sketches (usualmente ~/Documents/Arduino/ ) y creamos un folder llamado libraries ahí copiamos la librería, nada difícil.

    Ya que tenemos nuestra librería viene otro pequeño problema: Si usamos la versión 1 del Arduino IDE, al tratar de compilar el sketch nos sale error, que no puede encontrar el WProgram.h

    Free Image Hosting at www.ImageShack.us

    Y es que a los del Arduino team les dio por cambiar algunas cosas para el lanzamiento de la versión 1 del IDE, entre ellas renombrar la librería WProgram.h a Arduino.h

    La solución es obvia, vamos a abrir el archivo .h de nuestra librería, buscamos WProgram.h y lo sustituimos por Arduino.h y listo.

    Un post muy sin chiste, pero siempre es bueno tener este tip a mano

    Proyecto de Ocio – LM35 otro sensor de temperatura

    2

    En un post anterior hablaba del Dallas DS18B20 un sensor de temperatura que podemos usar con Arduino, pues ahora me acaba de llegar mi nuevo National LM35 DZ, un sensor muy parecido pero mucho mas simple de usar, sin protocolos ni nada, simplemente conectamos un pin a la entrada análoga del Arduino y listo estamos leyendo temperatura en grados centígrados.

    En mi gran elefante blanco aka LED Headlight necesitaba algo para controlar la temperatura de mi pila LiPo (viendo vídeos de como explotan estas pilas ni loco las uso sin triple precaución). Asi que el LM35 me viene genial, no usa una entrada digital (que empieza a ser un factor en mi proyecto).

    Pero veamos como funciona.

    Los 3 pins del LM35 son muy simples: tierra, voltaje de entrada y voltaje de salida, justo como esta gráfica.

    Free Image Hosting at www.ImageShack.us

    Para conectarlo al Arduino pues solo necesitamos una entrada análoga y alimentarlo con unos 5v.

    Free Image Hosting at www.ImageShack.us

    El código no podía ser mas simple, solo damos de alta los pines, leemos la entrada análoga y listo.

    
    // 
    
    
    
    float temp;
    int tempPin = A0;
    
    void setup()
    {
    Serial.begin(9600); 
    
    }
    
    void loop()
    
    {
    temp = analogRead(tempPin);           
    temp = (5.0 * temp * 100.0)/1024.0;  // pasamos de 8 bits a Volts
    Serial.println(temp);            
    delay(1000);                           
    
    }
    
    
    
    

    Bastante mas simple que el Dallas, en cuanto a precisión tendré que hacer un mano a mano

    74HC595 shift register para controlar display de 7 elementos

    5

    74HC595 shift register + arduino

    En un post anterior hablaba de como usar 8 puertos del Arduino para controlar un display de 7 elementos, es una manera rápida pero poco practica de controlar estos elementos.

    Y es ocupar 8 salidas en el Arduino nos reduce la posibilidad de hacer otras cosas, nos deja 6 salidas libres.

    Podemos usar un chip 74HC595 que nos sirve para controlar 8 salidas digitales mediante 3 salidas del Arduino, ademas se puede encadenar, por lo que podemos controlar bastantes salidas y tener libres 11 salidas del Arduino para agregarle cosas.

    Antes de seguir, he de aclarar que este post y los demás relacionados son los menos técnicos, los menos formales y son solamente mis descubrimientos (no estudie nada relacionado a la electrónica o programación), pero hay que compartír lo que uno aprende, quizá haya personas como yo que no queremos ser ingenieros en algo para hacer algún aparato útil.

    Hay una guía muy interesante aquí sobre como usar un 74HC595 con un Arduino para controlar LEDs, de hecho hay muchos otros tipos de shift register, pero usemos este (y aprovechando que me hice de 25 de estos a un súper precio).

    El chip 74HC595 tiene 16 pins, 8 de ellos para controlar mismo numero de salidas, 3 para control 1 salida de datos (para conectar otros 74HC595)

    Para conectarlo seguimos la recomendación de la pagina de Arduino

    PinConectar a
    15, 1-7salidas digitales, leds, display
    8, 13GND
    9al pin 14 del segundo 74HC595
    10, 165V
    11Arduino D12
    12Arduino D8
    14Arduino D11

    Y aquí esta la imagen de dos 74HC595 conectados a 2 displays de 7 segmentos, el orden de los pins es sencillo, el pin-disp quedaria: 15-A, 1-B, 2-C, 3-D, 4-Dp, 5-E, 6-F, 7-G

    Free Image Hosting at www.ImageShack.us

    Hasta aquí todo bien, pero empezamos con los problemas

    Mis display son de Anodo común, lo que significa que un segmento se enciende al apagarse un pin del 74HC595, cual es el problema? pues tenemos que cambiar el modo en que enviamos los datos

    para desplegar un 0 usando un display de cátodo común enviaríamos un byte 01101111 desde arduino, este encendería esos segmentos y tenemos un lindo 0; pero en uno de ánodo común tendríamos que enviar un byte 10010000 para que deje apagados (y por ende enciendan en el AC)

    Ademas, claro, el byte depende de como hayamos hecho la conexión entre display y el 74HC595; así que si elegimos otro orden en los pins pues habrá que cambiar el byte de control. Lo que hace esto en poco standard y no podemos robarnos usar código de otras personas que hayan publicado.

    Ya estando en el IDE de Arduino controlar el shift register es de lo mas fácil, muy pocas lineas de programación, ya que hay una instrucción que hace todo el trabajo por nosotros: shiftOut

    
    /* Ejemplo de uso de un display de 7 segmentos ánodo común 
     usando un shift register 74HC595
    
    Ivan Capdeville - ivan@darkapple.org
    
    */
    
    
    
    const int latchPin = 8;
    const int clockPin = 12;
    const int dataPin = 11;
    
    
    void setup() {
      
      pinMode(latchPin, OUTPUT);
      pinMode(dataPin, OUTPUT);  
      pinMode(clockPin, OUTPUT);
      
    
    }
    
    void loop() {
      
    
      digitalWrite(latchPin,LOW);
      shiftOut(dataPin, clockPin, LSBFIRST, *);  // * caracter del segundo display
      shiftOut(dataPin, clockPin, LSBFIRST, *);  // * caracter del primer display
      digitalWrite(latchPin, HIGH);
      
    
    

    el código es simple, declaramos las salidas del arduino que conectamos al 74HC595, las configuramos como salidas digitales y vamos a usar esta secuencia para activar los caracteres

    
    digitalWrite(latchPin,LOW);
    
    

    cuando el latchPin se apaga el shift register se prepara para recibir nuevos datos

    
    shiftOut(dataPin, clockPin, LSBFIRST, *);
    
    

    Esta parte es quizá la mas interesante y complicada de dominar al inicio, hay que elegir como va leer el byte de entrada, si de derecha a izquierda (LSBFIRST) o de izquierda a derecha (MSBFIRST) y en que nos afecta esto? pues determina como vamos a confeccionar los caracteres, si usamos MSBFIRST usaremos el byte 10010000 para mostrar un 0, si usamos LSBFIRST usaremos el byte 00001001

    ya que elegimos que segmentos vamos a querer, ponemos una linea por cada display (en orden inverso) ponemos esta linea para prender el latchPin y que se genere la instrucción

    
    digitalWrite(latchPin,HIGH);
    
    

    Afortunadamente para los que no queremos meternos tanto en rollos técnicos, resulta que podemos usar caracteres decimales para mostrar segmentos (aquí viene la rechifla después de leer tanto sobre números binarios)

    Podemos usar números del 0 al 255 para controlar los segmentos a desplegar, pero no es tan sencillo como poner un 5 para desplegar un 5, pues no, tienen su representación, así que usamos, por ejemplo, el 14 para desplegar el numero 3 y el 156 para el numero 4. Aquí es donde usar binarios se vuelve mas simple (8 caracteres fijos y un 1 o un 0 para elegir si se muestra o no el segmento, así que todos los segmentos prendidos en un display de ánodo común seria un byte 00000000 (0) todos apagados 11111111 (256))

    Esto hace mucho mas fácil el elegir que segmentos se prenderán (o en una matriz de leds lo mismo) se vuelve mas gráfico el elegir, usando números decimales aun no veo una relación o secuencia (quizá la haya pero ya después buscare)

    Al final de tanto rollo, mi recomendación es usar LSBFIRST si usamos un display de anodo comun y byte binario, si usamos numeros decimales y el anodo comun hay que usar MSBFIRST y la conversion a decimal del byte

    Digito en displayByte binarioDecimal
    0100100009
    111111001159
    20101010042
    30111000014
    400111001156
    50011001076
    60001001072
    70111100031
    8000100008
    90011000012
    .00010000247

    Y sigue el vicio – Arduino con termómetro Dallas DS18B20

    1

    Este es un post rápido

    Mis camaradas del foro Infojardin me preguntaron como diablos se podría usar el Arduino para controlar humedad, temperatura y demás cuestiones en los invernaderos

    Asi que aprovechando que llego mi termómetro Dallas DS18B20 (parece un transistor normal pero esta interesante, hasta protocolo de comunicación propietario tiene, el OneWire de Dallas (ahora Maxim)), vamos armando algo para leer temperatura y de acuerdo a un rango emita alguna señal, puede ser activando un ventilador y con eso bajando temperatura en el invernadero, que se yo.

    Pero empecemos por lo fácil y sencillo, ponerlo a trabajar y obtener mediciones.

    Aquí esta el cableado, muy sencillo pero con un cambio respecto a otros sensores, la lectura no se realiza a través de un puerto análogo, mas bien un puerto digital y la resistencia de 4.7K ohms va del pin 3 al 2.

    Free Image Hosting at www.ImageShack.us

    El código para iniciarlo esta bastante complejo, trate de usar la librería OneWire para Arduino pero en mi Mac no funciona muy bien, me salen errores al compilar (ademas que según leí en la versión 1 del IDE de Arduino cambiaron nombres de librerías que hacen referencia otras, todo un relajo).

    Me encontré este código que no usa la librería, así que ahí le echan un ojo.

    
    
    #define TEMP_PIN  7 
    
    void OneWireReset(int Pin);
    void OneWireOutByte(int Pin, byte d);
    byte OneWireInByte(int Pin);
    
    void setup() {
        digitalWrite(TEMP_PIN, LOW);
        pinMode(TEMP_PIN, INPUT);     
    Serial.begin(9600);
    
        delay(100);
        Serial.print("temperatura:\n");
    }
    
    void loop(){
      int HighByte, LowByte, TReading, SignBit, Tc_100, Whole, Fract;
    
      OneWireReset(TEMP_PIN);
      OneWireOutByte(TEMP_PIN, 0xcc);
      OneWireOutByte(TEMP_PIN, 0x44); 
      OneWireReset(TEMP_PIN);
      OneWireOutByte(TEMP_PIN, 0xcc);
      OneWireOutByte(TEMP_PIN, 0xbe);
    
      LowByte = OneWireInByte(TEMP_PIN);
      HighByte = OneWireInByte(TEMP_PIN);
      TReading = (HighByte << 8 ) + LowByte;
      SignBit = TReading & 0x8000;  // test most sig bit
      if (SignBit) // negative
      {
        TReading = (TReading ^ 0xffff) + 1; // 2's comp
      }
      Tc_100 = (6 * TReading) + TReading / 4;    // multiply by (100 * 0.0625) or 6.25
    
      Whole = Tc_100 / 100;  // separate off the whole and fractional portions
      Fract = Tc_100 % 100;
    
    
      if (SignBit) // If its negative
      {
         Serial.print("-");
      }
      Serial.print(Whole);
      Serial.print(".");
      if (Fract < 10)
      {
         Serial.print("0");
      }
    
      Serial.print(Fract);
    
          Serial.print("\n");
      delay(5000);      // 5 second delay.  Adjust as necessary
    }
    
    void OneWireReset(int Pin) // reset.  Should improve to act as a presence pulse
    {
         digitalWrite(Pin, LOW);
         pinMode(Pin, OUTPUT); // bring low for 500 us
         delayMicroseconds(500);
         pinMode(Pin, INPUT);
         delayMicroseconds(500);
    }
    
    void OneWireOutByte(int Pin, byte d) // output byte d (least sig bit first).
    {
       byte n;
    
       for(n=8; n!=0; n--)
       {
          if ((d & 0x01) == 1)  // test least sig bit
          {
             digitalWrite(Pin, LOW);
             pinMode(Pin, OUTPUT);
             delayMicroseconds(5);
             pinMode(Pin, INPUT);
             delayMicroseconds(60);
          }
          else
          {
             digitalWrite(Pin, LOW);
             pinMode(Pin, OUTPUT);
             delayMicroseconds(60);
             pinMode(Pin, INPUT);
          }
    
          d=d>>1; // now the next bit is in the least sig bit position.
       }
    
    }
    
    byte OneWireInByte(int Pin) // read byte, least sig byte first
    {
        byte d, n, b;
    
        for (n=0; n<8; n++)
        {
            digitalWrite(Pin, LOW);
            pinMode(Pin, OUTPUT);
            delayMicroseconds(5);
            pinMode(Pin, INPUT);
            delayMicroseconds(5);
            b = digitalRead(Pin);
            delayMicroseconds(50);
            d = (d >> 1) | (b<<7); // shift d to right and insert b in most sig bit position
        }
        return(d);
    }
    
    

    El dia que termine mi headlight quiza inicie un proyecto para controlar cosas de estas, ya sea una pecera o algun invernadero o plantas con riego programado

    Proyecto de ocio – LED Headlight – LDR o photodiode ?

    0

    photoresistor LDR

    El otro día me encontré los restos de un flash YN-460 (son tan buenos hasta que truenan), al desarmarlo para quitarle los LEDs SMD para un experimento que tengo en mente para luces (ingenuo que pensé que podía desoldar componentes SMD sin problema) me tope con algo muy interesante, un photodiode, un foto diodo? bueno no conozco el nombre en español, así que espero los insultos comentarios de los entendidos.

    Asi que se me ocurrió comparar el funcionamiento de mi LDR (foto resistencia) contra el photodiodo del yn460, el juez? obviamente mi tullido Arduino (tiene malas soldaduras y demás).

    Cuales serian los puntos a comparar? rango de sensibilidad, velocidad de captura (refresco?) y algo muy importante, compatibilidad con el headlight que ando armando.

    El funcionamiento es radicalmente diferente, como comparar una resistencia con un diodo si funcionan muy diferente; pues simplemente viendo como afectan la respuesta del Arduino con mis LEDs.

    Un LDR es una resistencia sensible a la luz, entre menos luz mas resistencia presenta al paso de corriente, si hay mucha luz casi es un circuito abierto (casi).

    Un foto diodo es una compuerta de corriente (esa imaginación mía) que dependiendo de sus características deja pasar corriente al otro lado (en este caso dependiendo de la luz recibida)

    Claro esto muy a grosso modo, para información mas precisa vayan a san Google.

    Nuestro buen Arduino tiene una sensibilidad de 10 bits, lo que es lo mismo a 1024 niveles de entrada análoga (del 0 al 1023) mas que suficientes para armar un bonito rango de aplicaciones (luz de día, luz de tarde, penumbra, amanecer, etc etc).

    El LDR (fotoresistencia) no es consistente, cosa que no esta mal ya que la luz no es continua, nuestros ojos se adaptan increíble, pero hay muchas variaciones en la luz; al probar su respuesta con diferentes fuentes de luz, no hubo ningún rango estable, pasaba de 300 a 400 con el mismo tipo de luz, lo que nos obliga a programar con mas cuidado estos umbrales.

    El fotodiodo en cambio, parece que toma como referencia la luz que incide sobre el sensor al recibir corriente y de ahí empieza a medir los cambios, así que el nivel 0 en el fotodiodo siempre será la luz ambiente que tengamos al iniciar la aplicación y de ahí pa arriba.

    El ganador?

    El fotodiodo, parece estar diseñado para fotografía, seleccionamos un umbral (midiendo la luz de un flash externo) y con eso tenemos asegurado su funcionamiento adecuado para activar lo que queramos en nuestro Arduino.

    El LDR no es malo, podemos usarlo en otros proyectos y es mucho mas accesible (por mas que he buscado no he encontrado donde vendan foto diodos como el del YN 460)

    Ir arriba