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

[PacoA]

Antes de empezar a deciros que hay que comprar y que programas hay que instalar para programar un driver de nuestras linternas, es mejor motivar al personal mostrando lo fácil que es programar en Arduino un microprocesador. Y con ejemplos aplicados a los drivers.

EDITO: Lo que hay que comprar y como se instala los programas está explicado aquí:
http://www.forolinternas.com/viewtopic.php?f=22&t=6630

Vamos a trabajar con el driver Nanjg 105C. ¿Por qué? Porque es un driver económico, muy utilizado en linternas, y fácilmente programable, al llevar un microprocesador Attiny13, que es soportado por Arduino.

Enlace compra en Fasttech (versión de 2.8 Amperios):
https://www.fasttech.com/products/1122302

A continuación se muestra este driver:



El chip que tiene los números 1 a 8 en amarillo es el microprocesador Attiny13.

Es importante hacer notar que el control sobre el led (cantidad de luz, posible flash) se hace con la patilla 6. A mayor salida en la patilla 6 mayor luz dará el led. En la patilla 6 se encuentra la entrada/salida digital número 1, de las varias que tiene este chip.

Código en Arduino. Un solo modo en máxima potencia.

//PROGRAMA LINTERNA SOLO MODO ALT0
//a continuación se dice al compilador que cada vez que encuentre ledpin
//lo substituya por 1. Ese valor 1 corresponde a la patilla digital número 1 del
//chip Attiny13 //que lleva el driver Nanjg 105c. La entrada/salida digital 1 
//está en la patilla 6 del circuito integrado Attiny13
#define ledpin 1

//a continuación, dentro de setup() {}, se escribe el código que se ejecuta
//al arrancar el chip, es decir, al encender la linterna. Se ejecuta
//solo una vez, solo al principio de conectar el chip / linterna.

void setup() {
 
  //la siguiente instrucción dice que la entrada/salida digital 1 se va
  //a utilizar como salida. Con este salida se controlan los chips
  //AMC7135 que dan coriente al led. Según la potencia del driver hay más
  //o menos cantidad de chips AMC7135
  
  pinMode(ledpin, OUTPUT); //ledpin, que es 1, es salida digital

} //fin setup()

// todo lo que esté dentro de loop() {} se ejecutará una y otra vez
void loop() {

  //a contonuación decimos que la salida que controla el led está
  //al máximo, 255 Es decir, la linterna está siempre en modo alto o high.
  //los valores posible son 0 (apagado el led) hasta 255.
analogWrite(ledpin, 255);
}//fin loop()

La imagen anterior muestra el programa más simple para controlar una linterna. No tiene modos, no tiene memoria, solo enciende la linterna a la máxima potencia que tenga el driver.

A continuación figura una imagen del mismo código en el compilador de Arduino, Arduino IDE. Así quedaría el código en el compilador. Como ves, es el mismo aspecto del código de antes. Observa abajo del todo que la cantidad de memoria utilizada es 438 bytes, de total de 1024 que tiene el Attiny13.



El programa está comentado y leyendo esos comentarios es muy sencillo de entender. Como lo que se repite siempre, sin parar, al estar dentro de loop(), es analogWrite(ledpin, 255) la linterna recibe siempre ordenes de estar en modo máximo, puesto que el valor máximo de salida es 255. Así pues, la patilla 6 está indicando al driver que de toda la potencia que pueda.

El código, sin comentarios, para que se vea lo sencillo que es:

//PROGRAMA LINTERNA SOLO MODO ALT0

#define ledpin 1


void setup() {
  
  pinMode(ledpin, OUTPUT); //ledpin, que es 1, es salida digital

}


void loop() {

analogWrite(ledpin, 255);
}

Código en Arduino. Un solo modo con flash a media potencia.

Supongamos ahora que queremos que la linterna tenga un solo modo intermitente, a media potencia. Queremos 1 segundo encendido y medio segundo apagado. Y que sea siempre así. Un solo modo intermitente a media potencia. El código siguiente muestra ahora como se haría:

//PROGRAMA CON UN SOLO MODO CON  FLASH

#define ledpin 1


void setup() {

  pinMode(ledpin, OUTPUT); //led como salida digital

}//fin setup()

// todo lo que esté dentro de loop() {} se ejecutará una y otra vez
void loop() {

  //encendemos el led a mitad de corriente, 127 es aprox. la mitad de 255
analogWrite(ledpin, 127);
//lo dejamos encendiddo un segundo, 1000 milisegundos
delay(1000);
//apagamos el led. Salida = 0. También podría ser digitalWrite(led, LOW)
analogWrite(ledpin, 0);
//esperamos medio segundo, 500 ms
delay(500);
// y ahora se repetiría el ciclo porque está dentro de loop()
}//fin loop()

Como vemos, ahora a analogWrite se le ha puesto un valor 127 que es aproximadamente la mitad de 255, que es el valor máximo. Solo se pueden utilizar enteros. Por tanto, el driver proporcionará la mitad de la corriente máxima para la que está diseñado. Si es un driver de 2.8 amperios, dará unos 1.4 amperios. Ojo, no quiere decir que la cantidad de luz sea la mitad, porque el ojo humano funciona de forma no lineal, y porque el led no tiene porque dar la mitad de luz a mitad de corriente.

Aquí una tabla que nos puede ayudar a elegir el valor para analogWrite en el caso de un XM-L T6. Recuerda que el ojo no siente el doble de lúmenes como el doble de luz.
XM-L T6 a 2800 mA:
Flux(LM) mA analogWrite
629 2790 255
315 1127 103
157 527 48
79 256 23
39 126 12
19.7 63 6
9.8 31 3


Después de encender el led a media potencia lo deja encendido un segundo, delay(1000), apaga el led, analogWrite(ledpin, 0), espera medio segundo, delay(500), y como todo lo que está dentro de loop() se ejecuta una y otra vez, se repite el ciclo. Por tanto, el led parpadea. Así de fácil es programar en Arduino.

El código sin comentarios:

//PROGRAMA CON UN SOLO MODO CON  FLASH

#define ledpin 1


void setup() {

  pinMode(ledpin, OUTPUT); //led como salida digital

}


void loop() {

analogWrite(ledpin, 127);
delay(1000);
analogWrite(ledpin, 0);
delay(500);
}

Este código ocupa 476 bytes de los 1024 disponibles.

[PacoA]

Código en Arduino. Varios modos con memoria.

Ahora el siguiente paso es que el driver tenga varios modos. Como sabemos, en algunas de nuestras linternas el cambio de modo ocurre de la siguiente forma. Si apagamos y encendemos rápido, la linterna pasa al siguiente modo. Si dejamos la linterna encendida en un modo más de un determinado tiempo, ese modo queda memorizado para la próxima vez.

Por tanto, debemos guardar el modo en el que se debe encender la linterna en una memoria no volátil, que no se borre al perder la alimentación el chip (apagar la linterna). Esa memoria se llama EEPROM. Y, por tanto, la palabra EEPROM aparecerá en el código de Arduino cuando escribamos o leamos la memoria EEPROM.
En Arduino escribir y leer en la memoria EEPROM es muy fácil:

EEPROM.write(posición_memoria, nombre_variable) guarda en la posición de memoria “posición_memoria” la variable ”nombre_variable”.
El Attiny13 tiene 64 posiciones de memoria. En cada una de ellas puede grabar un byte. Es decir, un valor entre 0 y 255.

EEPROM.read(posición_memoria) lee el valor que hay (de 0 a 255) en la posición “posición_memoria”

Con estas dos instrucciones puedes entender el código que sigue, más complejo que los anteriores, pero ya tenemos un programa REAL para un driver. Un poco de esfuerzo que vale la pena... insisto que lo que sigue es ya un programa como los que llevan los drivers que compramos.

Vamos a mostrar el código para un driver con tres modos: alto, medio y flash. Con memoria del último modo, si lleva más de time_memory milisegundos en ese modo.

El código sigue a continuación:

//PROGRAMA CON TRES MODOS Y MEMORIA ÚLTIMO MODO

#include  //incluye una librería para poder escribir leer en EEPROM
#define ledpin 1
#define time_memory 3000 //esto es el tiempo en milisegundos que está encendida
//la linterna para que se guarde el modo actual. Si la apagas antes de ese tiempo, 
//se encenderá en el modo siguiente

//la siguiente variable, mode,  es el modo en el que está la linterna: alto = 1, medio = 2, ...
byte mode;

//el valor mínimo de mode es 1, el máximo es maxmodereal
#define maxmodereal  3 //indicamos aquí que hay 3 modos. Cambiar si hya más o menos

//la siguiente variable, guardamode, indica que modo de los que hay se guarda en EEPROM
//puede ser el modo siguiente (si han pasado menos de time_memory milisegundos)
//o el actual en caso contrario
byte guardamode; //modo a guardar en la memoria EEPEOM

boolean primer1 = false; //variable false/true para grabar en EEPROM. Empieza siendo false.
boolean primer2 = false; //variable false/true para grabar en EEPROM. Empieza siendo false.
unsigned long int time_on; //time_on es el tiempo em milisengundos cuando se enciende linterna
unsigned long int time_now; //time_now tiempo en milisendos actual, para grabar o no el modo actual


void setup() { //solo se hace al principio de encender la linterna

 pinMode(ledpin, OUTPUT); //indicamos que el control del led esta en salida digital número 1

 time_on = millis(); //guarda el tiempo en milisegundos cuando se enciende la linterna
 
 mode = EEPROM.read(1); // antes de encender la linterna lee modo a utilizar desde memoria
// y lo guarda en variable mode.


if (mode == 0) {mode = 1;} //la primera vez que utilicemos la linterna después
//de haber programado el driver, el contenido de la toda la EEPROM está a cero. 
//Esta línea solo hace falta esa pimera vez.
//En ese caso, como es cero lo convertimos a uno, para que empiece en el primer modo
//si no se enciende, no hay mode 0. 
//Otra solución es que el primer modo sea el 0.

 }//fin setup()


//a continuación lo que se repite una y otra vez
void loop() {
  
   if (primer1 == false) {//lo siguiente sólo se hace una vez, cuando primer1 == false.
     guardamode = mode +1; //en principio se guardará en memoria el
 //sigiente modo, modo+1, salvo que pasen time_memory milisegundos, entonces se
 //guardaría el modo actual. Eso se hace al final de este código
 
  if (guardamode > maxmodereal) {guardamode = 1;}
 //Como cada vez que apagumeos y encendeamos rápido aumenta el valor de guardamode,
 //al final nos pasaremos del límite. En ese caso, empezamos otra vez desde el modo 1
   
    EEPROM.write(1, guardamode); //guarda el mode siguiente al actual.
    //Por tanto, la próxima vez que encendamos la linterna estará en el siguiente modo
    primer1 = true;} //una vez hecho, ya no hay que hacerlo más. Hacemos primer1 = true
  
  
  //siguen la descripción de los modos
 if (mode == 1) {digitalWrite(ledpin, 255);} //modo 1 es alto, high.
 
 if (mode == 2) {analogWrite(ledpin, 127);} //modo medio, 50% amperaje
 
 if (mode == 3) //flash a un tercio de la potencia, amperaje
 { analogWrite(ledpin, 85); delay(500); analogWrite(ledpin, 0); delay(500); }


//a continuación se guarda el modo actual, NO EL SIGUIENTE, si han pasado más de  
//time_memory milisegundos
if (primer2 == false) {//sólo se va a ejecutar una vez pasados los time_memory milisegundos
    time_now = millis(); //hora actual en milisegundos
    if ((time_now - time_on) > time_memory) //si han pasado más de time_memory milisegundos
        {EEPROM.write(1, mode); //escribe en la posicion 1 el modo actual (no el siguiente)
        //sobre escribimos lo que antes habíamos escrito, que era mode+1
         primer2 = true;} // ya no se hace más esta parte del código, para que no repita
    }
}

El programa está bastante comentado y es fácil seguir lo que hace y está pensado para que cualquiera pueda ajustarlo a sus necesidades.

Lo que se puede cambiar muy fácilmente es:

* Valor de maxmodereal. Está puesto a 3 porque hay tres modos. Si pones más o menos modos hay que cambiarlo.
* Valor de time_memory. Tiempo sin cambiar de modo para que se guarde en memoria. Está en el código fijado a 3 segundos.
* La definición de los tres modos.


Si eres capaz de entender ese programa, enhorabuena, ya podrás diseñar tus programas. Si no entiendes algo, ¡pregunta!

El código sin comentarios:

//PROGRAMA CON TRES MODOS Y MEMORIA ÚLTIMO MODO

#include 

#define ledpin 1
#define time_memory 3000 
byte mode;
#define maxmodereal  3 

byte guardamode;

boolean primer1 = false;
boolean primer2 = false;
unsigned long int time_on;
unsigned long int time_now;


void setup() {

pinMode(ledpin, OUTPUT);
time_on = millis();
mode = EEPROM.read(1);
if (mode == 0) {mode = 1;}
}


void loop() {
  
   if (primer1 == false) {
       guardamode = mode +1; 
        if (guardamode > maxmodereal) {guardamode = 1;}
         EEPROM.write(1, guardamode);
        primer1 = true;}
  
 if (mode == 1) {digitalWrite(ledpin, 255);}
 
 if (mode == 2) {analogWrite(ledpin, 127);}
 
 if (mode == 3)
 { analogWrite(ledpin, 85); delay(500); analogWrite(ledpin, 0); delay(500); }


if (primer2 == false) {
    time_now = millis();
    if ((time_now - time_on) > time_memory)
        {EEPROM.write(1, mode);
         primer2 = true;}
    }
}

Este código se compila en 818 bytes, de los 1024 disponibles.

[PacoA]

Ahora vamos a explicar como funciona un modo programable.

En un modo modo programable, el usuario elige la cantidad de luz que quiere tener en ese modo. Si has aprendido como se usa la memoria EEPROM te será muy fácil entenderlo. Si has llegado hasta aquí sin haberte "estudiado" los ejemplos anteriores, no lo vas a entender, pero no te desanimes que es fácil si primero aprendes lo anterior.

Lo que vamos a hacer es lo siguiente. Encendemos la linterna. A los tres segundos la linterna hace un parpadeo. En ese momento, si apagamos la linterna, la próxima vez que la encendamos la podremos programar.

En este vídeo se ve como funciona:



En un momento ponemos el código completo. Pero antes, la parte principal a entender es el siguiente bucle for:

for (byte valor=1; valor <= 255; valor= valor+3){
analogWrite(1, valor);
EEPROM.write(4,valor); delay(300); }
}

Lo que tenemos es un bucle que empieza con la variable valor = 1 y termina con valor = 255, que es la cantidad máxima de luz que hace la linterna. Los incrementos en el nivel de luz son de 3 en 3 (valor = valor + 3). Por lo que tendremos 1, 4, 7, 10, ... 255.

Se enciende la linterna con el nivel de luz = valor, con la instrucción analogWrite(ledpin, valor). Y la variable valor se guarda en la posición de memoria 4 de la EEPROM. Así que se puede recuperar la variable valor la próxima vez que encendamos la linterna.

A continuación espera delay(300), 0.3 segundos, y sigue el bucle. Así pues, si apagamos la linterna mientras hace el bucle, tendremos guardado el nivel de luz que queramos. Así de fácil es un modo programable gracias a la memoria no volátil EEPROM y a Arduino.

[PacoA]

Aquí el código completo de una linterna con un modo programable, muy comentado:

//PROGRAMA LINTERNA SOLO CON UN MODO, PERO PROGRAMABLE
#include

#define ledpin 1

byte programar; //si programar = 0 no se programa el único modo que hay.
//si programar = 1 se haría la programación del modo, es decir, el usuario elige
//la cantidad de luz que quiere.

boolean hecho = false; //solo una vez el usuario puede elegir si quiere programar la linterna.
//Esto ocurre a los tres segundos de encender la linterna. Ver en el código el delay(3000)
//Hace falta esta variable para que se haga solo una vez. 

byte nivel_luz; //valor de 0 a 255 que fija la cantida de luz que tendrá la linterna. Es
//un valor programable por el usuario


void setup() {
  
pinMode(ledpin, OUTPUT);
nivel_luz = EEPROM.read(4); //lee nivel de cantidad de luz, dese la posición 4 (memoria número 4)

if (nivel_luz == 0) {nivel_luz = 30;} //esta linea solo sirve la primera vez que se utilice
//la linterna despues de programarla. La primera vez despues de la programación toda la memoria eeprom
//vale 0, incluida la posición 4. Por tanto, la linterna no daría luz esa primera vez, nivel = 0.
//Para evitarlo fijamos un valor de salida igual a 30 si la memoria = 0.

programar = EEPROM.read(3); //lee si hay que programar la cantidad de luz desde la memoria número 3.
//Si el valor es 0 no hay que programar. //Si el valor es 1 el usuario elige la cantidad de luz

} // fin setup()


void loop() {

  if (programar == 1) {//si programar = 1 entonces empieza la programación
     EEPROM.write(3, 0); //No hay que programar proxima vez se encienda. Guarda programar = 0 en posición 3
     
     //y ahora empieza el bucle FOR tal y como hemos epxlicado antes, el bucle sigue hasta apagar linterna
     for (byte valor=1; valor <= 255; valor= valor+3){
      analogWrite(1, valor);
      EEPROM.write(4,valor); delay(300); }
        }
else {
//si hemos llegado hasta aquí es porque no había que programar la linterna.
//así que ahora se enciende con el nivel porgramado

analogWrite(ledpin, nivel_luz); //enciende la linterna con el nivel_luz leído de la eeprom, memoria 3
 
if (hecho == false) {// esto solo se hace una vez, cuando hecho = false
      delay(3000); //espera 3 segundos
      hecho = true; // ya no lo hará más
      
      //a continuación, después de tres segundos, apaga la linterna durante dos décimas.
      // es decir, hace un parpadeo.
      analogWrite(ledpin, 0); delay(200); analogWrite(ledpin, nivel_luz);
      
      EEPROM.write(3, 1);//guarda hay que programar proxima vez. Guarda 1 en la posición 4
      //si ahora apagamos la linterna, quedaría grabado que hay que programarla
       delay(1500);
       
       //pero después de 1.5 segundos, si no la hemos apagado, ahora guarda el valor 0, es decir
       //guarda que no hay que programarla proxima vez se encienda.
       //Es decir, tienes 1.5 segundos desde el parpadeo para apagarla si quieres programarla
       
      EEPROM.write(3, 0);//guarda no hay que programar proxima vez que enciendas
           
         }// fin hecho == false
   }//fin else
}//fin loop()
 

Si tienes dudas pregunta

[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.

[PacoA]

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. Aquí se ve en 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;}

    }
    
}
            
   

Ocupa 1014 bytes

Brujeria


Pero esta muy interesante, solo hay una cosa que no me gusta, igual que cuando manredu hizo su driver artesanal, y es que deba estar encendida un cierto tiempo para memorizar el modo, y eso no es lo que hacen todos los drivers, la mayoria memoriza pasando un tiempo apagado, ese es el tipo de memoria preferido por todos lo usuarios, ya que con el otro como ya se comento en su momento es muy incomodo tener que esperar con la linterna encendida para poder apagarla con el modo memorizado (cuando lo que quieres es un fogonazo rapido y apagar), y ademas para cambiar de modo deberas dar dos toques, uno para volver al modo memorizado y otro antes de que se ejecute el tiempo de memorizado, tengo dos drivers asi y es lo que no me gusta nada de ellos.

Igualmente, excelente trabajo

Muy jugoso...

Spoiler

j...r vaya nivel,

que nivelón y que curro te estarás dando.

Por cierto como poseedor de uno de los famosos dirvers de manredu, tengo que partir una lanza a favor de ese sistema de memoria. El mio es un einstein y fija la posición a los 200 ms, creo recordar, y así puedo apagarla y encenderla sin preocupaciones porque para que cambie de modo tengo que hacer 2 pulsaciones muy rápidas.

[PacoA]

Brujeria


Pero esta muy interesante, solo hay una cosa que no me gusta, igual que cuando manredu hizo su driver artesanal, y es que deba estar encendida un cierto tiempo para memorizar el modo, y eso no es lo que hacen todos los drivers, la mayoria memoriza pasando un tiempo apagado, ese es el tipo de memoria preferido por todos lo usuarios, ya que con el otro como ya se comento en su momento es muy incomodo tener que esperar con la linterna encendida para poder apagarla con el modo memorizado (cuando lo que quieres es un fogonazo rapido y apagar), y ademas para cambiar de modo deberas dar dos toques, uno para volver al modo memorizado y otro antes de que se ejecute el tiempo de memorizado, tengo dos drivers asi y es lo que no me gusta nada de ellos.

Igualmente, excelente trabajo

ese tipo de memoria es posible, pero modificando el driver. añadiendo un condensador para que mantenga la corriente por un tiempo. sin embargo, esa modificación requiere muy buena habilidad soldadora.

la idea es que cualquiera pueda programar su driver. un driver barato, fácil de encontrar y muy presente en las linternas.

ya os contaré la parte física, como se programa. lo primero es que veais lo simple que es el código

pregunta...

¿que hay que cambiar para que la linterna arranque siempre en el mismo modo, por ejemplo en el modo alto?

pista... solo hay que cambiar una cosa muy pequeña. es fácil...

por cierto, ya pondré más códigos... por ejemplo modos ocultos, modo programable... todo eso cabe en la memoria del Attiny13

... ya pondré más códigos... por ejemplo modos ocultos, modo programable... todo eso cabe en la memoria del Attiny13

Sí por favor. Me he suscrito al hilo. Me parece interesantísimo lo que estás haciendo.
Gracias.

... ya pondré más códigos... por ejemplo modos ocultos, modo programable... todo eso cabe en la memoria del Attiny13

Sí por favor. Me he suscrito al hilo. Me parece interesantísimo lo que estás haciendo.
Gracias.

pues vamos responde a la pregunta de antes

también es posible aviso de batería baja

Pero si un driver ya incorpora la memoria tras un tiempo apagada, igualmente se puede reprogramar a tu gusto conservando esa memoria, pues ya lleva ese condensador, ¿no? el 105C que tipo de memoria tiene, ¿memoriza encendida, o apagada?

if (mode == 0) {mode = 0;} 

Eso???

De esa manera encenderá siempre como si tuviera la EEPROM vacía ¿no?

...
ya os contaré la parte física, como se programa. lo primero es que veais lo simple que es el código

Justo eso... Iba a preguntar: cómo se enchufa para programar (para meterle el código)?

Se te veían maneras...

Me parece genial el aporte sobre todo para los analfabetos como yo en programación y más teniendo en cuenta que muchos, como bien dices, utilizamos ese driver. Seguiré el hilo muy atentamente.