Tú puedes programar muy fácilmente tu driver con Arduino

[PacoA]

Y aquí os pongo un driver programado con 4 modos. Alto, medio, programable y un modo para bicicleta en ciudad.



Aquí el código:

//CÓDIGO PARA 4 MODOS. UNO DE ELLOS PROGRAMABLE Y OTRO FLASH LENTO
//PARA IR EN BICI POR CIUDAD

#include 

#define ledpin 1

byte mode; //el modo en el que funciona la linterna (alto = 1,
//medio = 2, ...) valor mínimo es 1, máximo es maxmodereal
byte programar = 0;

#define maxmodereal 4 //decimos que hay 4 modos.
byte guardamode; //modo a guardar en la memoria EEPEOM

boolean primer1 = false; //necesario para memoria modo
boolean primer2 = false; //necesario para memoria modo
unsigned long int time; //tiempo en milisegundos cuando se
//conecta la linterna
unsigned long int time2; //tiempo en milisegundos actual

boolean done_low = false;

byte nivel_low;
#define tiempo_memoria 3000

void setup() {

 
  pinMode(1, OUTPUT); //led como salida digital en pin 1

 time = millis(); //hora a la que se enciende linterna
//ahora leemos si está activado el modo oculto

 
mode = EEPROM.read(1); //lee modo desde memoria

if (mode == 0) {mode = 1;} //solo primer uso

nivel_low = EEPROM.read(4); //lee nivel de low o tercer modo
if (nivel_low maxmodereal) {guardamode = 1;}
  //No existe modo con número superior al maxmodereal. pasamos al mode = 1
    EEPROM.write(1, guardamode);
    primer1 = true;} //para que se se guarde solo una vez
  
  //siguen los modos
 if (mode == 1) {analogWrite(ledpin, 255);} //modo alto
    
 if (mode == 2) {analogWrite(ledpin, 100);} //modo nedio
 
  
 if (mode == 3) { //modo programable
    analogWrite(ledpin, nivel_low);
    if (done_low == false) {
      delay(3000);
      done_low = true;
      EEPROM.write(1, 3); //guarda el modo
      analogWrite(ledpin, 0); delay(200); analogWrite(ledpin, nivel_low);
      EEPROM.write(3, 1);//guarda hay que programar
       delay(1500);
      EEPROM.write(3, 0);//guarda no hay que programar
               
         }
 }
  
  if (mode == 4){//bicicleta
 analogWrite(ledpin, 35); delay(250); digitalWrite(ledpin, LOW); delay(120);
  }


if (primer2 == false) {
    time2 = millis(); //hora actual en milisegundos
//si han pasado más de 3 segundos se guarda el modo actual, no el
//siguiente,
    if ((time2 - time) > tiempo_memoria)
        {{EEPROM.write(1, mode);} //guarda modo actual
         primer2 = true;}
                    }

}// no programar
 }// fin loop
    

Este ocupa 1010 bytes. Queda sitio para otro modo, si es un modo sencillo.

si os gusta dentro de poco ya explico como se hace la programación física y que hay que comprar e instalar.

si os gusta dentro de poco ya explico como se hace la programación física y que hay que comprar e instalar.

Me gusta lo que estás haciendo!!!
Muchas gracias

si os gusta dentro de poco ya explico como se hace la programación física y que hay que comprar e instalar.

Esssso... Esssso... Los enchufes y los cables...

si os gusta dentro de poco ya explico como se hace la programación física y que hay que comprar e instalar.

Esssso... Esssso... Los enchufes y los cables...

lo estoy escribiendo. no es fácil de hacer, pero difícil de contar.

Mientras tanto sigo poniendo códigos. para que queden todos en este hilo. Aquí está el código para tener tres modos visibles, y uno oculto, que se puede hacer visible igual que lo hace el 105c de serie:

vas a modo bajo, esperas al guiño y entonces apagas la linterna. el modo oculto pasa a ser visible.

para hacerlo invisible es hacer lo mismo otra vez. Luego subo el video. Aquí el código, que se entiende fácil si se han entendido los códigos anteriores

//CÓDIGO CON 3 MODOS NO OCULTOS Y UN MODO OCULTO. CON MEMORIA
#include 

#define ledpin 1
#define time_memory 3000
#define nivel_bajo 25

byte mode; //el modo en el que funciona la linterna (alto = 1,
//medio = 2, ...) valor mínimo es 1, máximo es maxmodereal


byte maxmodereal; //variable que guarda el numero total de modos
byte guardamode; //modo a guardar en la memoria EEPEOM

boolean primer1 = false; //necesario para memoria modo
boolean primer2 = false; //necesario para memoria modo
unsigned long int time; //tiempo en milisegundos cuando se
//conecta la linterna
unsigned long int time2; //tiempo en milisegundos actual

boolean done_low = false;
byte memooculto = 0; //si es cero modo oculto no disponible
//si es 1 es disponible. programable por el usuario
#define tiempo_memoria 3000  //tiempo para memorizar modo actual

void setup() {

 
  pinMode(1, OUTPUT); //led como salida digital en pin 1

 time = millis();
memooculto = EEPROM.read(0); //se lee desde posición 0 si el modo ocuto está disponible o no.
// si memooculto = 1, está disponible. Si es 0 no lo está.
 if (memooculto == 1) { maxmodereal = 4;} //es 4 porque hay 3 no ocultos y el oculto disponible. 3 + 1 = 4
 else {maxmodereal = 3;} // si oculto no disponible hay 3 modos a utilizar
 
mode = EEPROM.read(1); //lee modo desde memoria número 1 el modo a utilizar
if (mode == 0) {mode = 1;} //esto solo se utiliza primera vez después de programarlo, ciuando
//todas las memorias eeprom son 0

 }


void loop() {
   

  if (primer1 == false) {
     guardamode = mode +1; //en principio se guarda el
 //sigiente modo, salvo que pasen 3 segundos, entonces se
 //guarda el modo actual
  if (guardamode > maxmodereal) {guardamode = 1;}
  //No existe modo con número superior al maxmodereal. pasamos al mode = 1
    EEPROM.write(1, guardamode);
    primer1 = true;} //para que se se guarde solo una vez
  
  //siguen los modos
 if (mode == 1) {analogWrite(ledpin, 255);} //modo alto
    
 if (mode == 2) {analogWrite(ledpin, 80);} //modo medio
 
  
 if (mode == 3) { //modo bajo con activación/desactivación modos ocultos
    analogWrite(ledpin, nivel_bajo);
    if (done_low == false) {
      delay(3000);
      done_low = true;
      //ahora hace un guiño. Tienes tres segundos para apagar linterna
      digitalWrite(ledpin, 0); delay(200); analogWrite(ledpin, nivel_bajo);
      
      //si el modo oculto estaba visible, deja de estarlo. O al revés
      if (memooculto == 1){EEPROM.write(0, 0);
                memooculto = 0;}//guarda oculto desactivado
        else {EEPROM.write(0, 1);
                memooculto = 1;}//guarda oculto activado
    
      EEPROM.write(ledpin, 3); //guarda memoria del modo low porque
        //han pasado tres segundos. esto se puede quitar
      delay(1500);
      if (memooculto == 1){EEPROM.write(0, 0);
                memooculto = 0;}//guarda oculto desactivado
        else {EEPROM.write(0, 1);
                memooculto = 1;}//guarda oculto activado
               }
               
         }
  
  if (mode == 4){//puese estar oculto.en este caso he puesto un strobe a max. potencia
 analogWrite(ledpin, 255); delay(50); analogWrite(ledpin, 0); delay(50);
  }




if (primer2 == false) {
    time2 = millis();
    if ((time2 - time) > tiempo_memoria)
        {{EEPROM.write(1, mode);} //guarada modo actual. si pones un numero
       //la linterna arrancará siempre en el modo con número que hayas puesto
      //despues de time_memory milisegundos
         primer2 = true;}

    }
    
}

aquí el video, con modo oculto:

//PROGRAMA LINTERNA SOLO CON UN MODO, PERO PROGRAMABLE
     
    
     for (byte valor=1; valor =1; valor= valor-3){
      analogWrite(1, valor);
      EEPROM.write(4,valor); delay(300); }
        }

Bueno una prueba antes de usar el programa, con el comando añadido después del punto y coma al bucle que tu das, una vez que llega a la máxima intensidad haría otro bucle bajando desde la máxima hasta la mínima?

Otra cosa pensando en algún uso alternativo o para un frontal he mirado la forma de acoplar un potenciometro para conseguir regular la intensidad de luz o la velocidad de parpadeo. Por ahora tengo, si no me he equivocado, que el potenciometro habría que conectarlo a la patilla 2 ó 7 (PB3, PB2), y luego añadir una linea en el programa para definir la entrada. Algo de lo que se me ha ocurrido va por buen camino?

//PROGRAMA LINTERNA SOLO CON UN MODO, PERO PROGRAMABLE
     
    
     for (byte valor=1; valor =1; valor= valor-3){
      analogWrite(1, valor);
      EEPROM.write(4,valor); delay(300); }
        }

Bueno una prueba antes de usar el programa, con el comando añadido después del punto y coma al bucle que tu das, una vez que llega a la máxima intensidad haría otro bucle bajando desde la máxima hasta la mínima?

Otra cosa pensando en algún uso alternativo o para un frontal he mirado la forma de acoplar un potenciometro para conseguir regular la intensidad de luz o la velocidad de parpadeo. Por ahora tengo, si no me he equivocado, que el potenciometro habría que conectarlo a la patilla 2 ó 7 (PB3, PB2), y luego añadir una linea en el programa para definir la entrada. Algo de lo que se me ha ocurrido va por buen camino?

ten en cuenta que el bucle para programar está dentro de loop() y dentro de loop() se hace el bucle si programar == 1.

Por tanto, como programar ==1, y lo seguirá siendo, y está dentro de loop(), hará el bucle una y otra vez hasta que apagues la linterna. Es decir, después de llegar al máximo vuelve a empezar desde valor = 0. Sin embargo, la próxima vez que lea el valor de programar será 0 y ya no se hará el bucle.

Con respecto al potenciómetro, sí se puede hacer. Hay una instrucción en Arduino que es analogRead(numero_entrada). Lee un valor de voltaje aplicado a una patilla del chip (si es una entrada analógica) y que puedes variar con un potenciómetro (o podría ser una cédula fotoeléctrica) Es uno de los ejemplos típicos de Arduino que se ponen para aprender.

De hecho, es el ejemplo que se utiliza en la pagina oficial para explicar analogRead():

http://arduino.cc/en/Reference/AnalogRead

Aquí el ejemplo que ponen:

int analogPin = 3; // potentiometer wiper (middle terminal) connected to analog pin 3
// outside leads to ground and +5V
int val = 0; // variable to store the value read

void setup()
{
Serial.begin(9600); // setup serial
}

void loop()
{
val = analogRead(analogPin); // read the input pin
Serial.println(val); // debug value
}


Ese programa te imprime en el ordenador el valor que ha leído y que varías con el potenciómetro. El valor lo manda al ordenador mediante Serial.print, con una placa Arduino, ya que tienen conexión USB y por ahí se comunica con el ordenador.

En nuestro caso, es un valor que utilizas en tu programa, pero no lo puedes ver ya que no hay conexión USB.

Si quieres te ayudo más adelante con el código... que ahora me tengo que ir. Pero que sepas que es muy fácil de hacer. Es justo el ejemplo que ponen para aprender

El único problema es no pasarse de 1024 bytes. Si quieres hacer algo muy complejo... como algo que tengo en desarrollo, hay que desoldar el Attiny13 y soldar el Attiny85. Con el Attiny85 puedes hacer virguerías, tiene 8 veces más capacidad.... lástima que los cabrones de Nanjg, por ahorrarse unos céntimos, no lo pongan de serie.

Coño, me olvidaba que también hay página oficial en español:

http://arduino.cc/es/Reference/AnalogRead

Muchas gracias por esa gran explicación, te he preguntado precisamente porque lo que he encontrado es referido al attiny85 y yo estaba pensando en algo sencillito... si haces algún montaje espero verlo

Donde consigo ese driver en México? Felicitaciones por tus aportaciones.

Donde consigo ese driver en México? Felicitaciones por tus aportaciones.

no lo puedes comprar en Fasttech?

Y aquí como es el proceso de programación con la pinza. Es un vídeo que también he puesto en el otro hilo, en el describe lo que hay que comprar:

Guau, esto suena como Ciberchamanismo aplicado a las linternas

Me recuerda a mis viejos tiempos en que programaba en Turbo Pascal, Clipper, Cobol (y algo de Fortran también)

Felicitaciones, PacoA, por abrir este hilo tan informativo, a ver si un día me animo a descolgar los guantes programísticos y le meto mano a los drivers.

Saludos.

Bueno ya he puesto el programa y parece que todo ha ido bien...solo me falta el resto

Bueno ya he puesto el programa y parece que todo ha ido bien...solo me falta el resto

pero te da error de compilación. No reconoce el código, seguramente porque no está bien instalado el boards.txt

es importante que te salga bien, porque si hay alguna laguna en el tuto, hay que corregirlo.

Creo que he podido meter la pata al explicarlo. hazme un favor. Copia el fichero boards.txt que tienes a la carpeta:

C:\Users\Francisco\Documents\Carpeta Mágica\Arduino\arduino-1.0.1\hardware\tiny

o lo equivalente que tengas tú.

Te aparecerá todo dos veces en Menú Herramientas / tarjeta el attiny13. Escoge uno de los Attiny13. Compila, primer icono de la izquierda en forma de v. Si da error, escoge el otro Attiny13 que te aparece y compila.

Si con uno de los dos funciona, compila sin error, me lo dices... entonces hay que mejorar las instrucciones.

Ok luego invetigo un poco y pongo eso.

Bueno he reinstalado todo y he probado el mismo programa pero en vez de usar en de atinny13 he usado arduino y no da fallo así el error lo cometo al añadir el attiny13. Sigo los pasos que das, saco board al excritorio, lo abro con wordpad y añado esto a la última linea.


##############################################################

attiny13.name=Attiny 13A standalone
attiny13.upload.using=arduino:arduinoisp
attiny13.upload.maximum_size=1024
attiny13.upload.speed=19200
attiny13.bootloader.low_fuses=0x7a
attiny13.bootloader.high_fuses=0xff
attiny13.bootloader.path=empty
attiny13.bootloader.file=empty
attiny13.bootloader.unlock_bits=0xFF
attiny13.bootloader.lock_bits=0xFF
attiny13.build.mcu=attiny13
attiny13.build.f_cpu=9600000
attiny13.build.core=core13

Luego vuelvo a probar pero da fallo.

Una pregunta PacoA, ¿ se prodrian programar otros driver distintos del nang 105 c ? por ejemplo un driver de la sipik sk68 o de la ultrafire c3, por poner dos ejemplos de linterna muy populares.

Desde luego este aporte es enorme de bueno, gracias por exponerlo en el foro.

Bueno he reinstalado todo y he probado el mismo programa pero en vez de usar en de atinny13 he usado arduino y no da fallo así el error lo cometo al añadir el attiny13. Sigo los pasos que das, saco board al excritorio, lo abro con wordpad y añado esto a la última linea.


##############################################################

attiny13.name=Attiny 13A standalone
attiny13.upload.using=arduino:arduinoisp
attiny13.upload.maximum_size=1024
attiny13.upload.speed=19200
attiny13.bootloader.low_fuses=0x7a
attiny13.bootloader.high_fuses=0xff
attiny13.bootloader.path=empty
attiny13.bootloader.file=empty
attiny13.bootloader.unlock_bits=0xFF
attiny13.bootloader.lock_bits=0xFF
attiny13.build.mcu=attiny13
attiny13.build.f_cpu=9600000
attiny13.build.core=core13

Luego vuelvo a probar pero da fallo.

lo resolvemos por privado