mmmhhhh que bonitos regalos, le voy a pasar mi dire, al santa, a ver si este año si me cumple mis deseos, saludos. Atte Eduardo Bado. tarwars:
Pues si , llego santa: Super bien empaquetado y muy seguro para que llegue intacto Dos fuentes meanwell ELN 6048P oses qeu dimean por pulsos . El thypon: No resisti la tentacion de conectarlo: En estos dias No One y yo nos daremos a la tarea de conectarlos y ver que tal el desempeño. Respecto al servicio de BoostLED, que mas les puedo decir , de lo mejor siempre te contestan los mails y en verdad que hacen lo posible porque la compra sea una grata experiencia, cien por ciento recomendables.
que excelente que ya esten probando el TYPON este minusculo aparato funciona de lo mejor la verdad que es un sistema de licencia habierta yo ya actualice 1 a la version mas moderna del sketch que no tiene mayores ventajas pero todo el desarrollo del mismo esta en reef central es facil de contruir, incluso se puede hacer en casa. y funciona muy bien para su tamaño, de todas formas no creo que sea necesario comparar 2 de estos ya que solo uno controla 4 canales diferentes y en cada canal se pueden conectar por lo menos 4 driver, osea podrian en teoria conectar 16 driver con 1 solo typon, la division por cnales es simplemente para poder hacer amaneceres y atardeceres en forma natural que el sol sale de un lado y se oculta del otro asi se puede encender el acuario en forma escalonada de izquierda a derecha o viceversa y es espectacular ver esto. saludos
Bueno se compraron 2 unidades porque una va a estar en mi tanque en Puebla y la otra en el tanque del Pepe en la Ciudad de Mexico. Comentas en el tema de badstraw En la pagina de boostled comenta que solo sirve para algunos tipos de meanwell. Pero no indican que sirva para la serie D... ¿nos podrias indicar donde viste esta información?
dejame buscar una imagen en un post de reef central (lo tengo bloqueado aca en el trabajo) y alli con un simple transistor hacen funcionar un D siempre se coloca el potenciometro y a la tierra va el transistor con una resistencia. Hoy por la noche lo busco y lo pongo por aca ok
Pero entonces no es que el Typhon sirva para fuentes tipo D, mas bien es que necesitas algo extra para que funcione... eso que comentas se llama convertir la salida PWM a voltaje y se puede hacer de varias maneras, la mas sencilla y economica es usar una resistencia y un capacitor. Una recomendacion... y espero no me lo tomes a mal, cuando hagamos un comentario es mejor decir por ejemplo. El Typhon sirve para fuentes Meanwell tipo P y aumentando un circuito extra puede servir para fuentes tipo D. Y mencionar info acerca del circuito y como hacerlo... imaginate si no hacemos la aclaración se puede dar el caso que compañeros que tengan fuentes tipo D adquieran un Typhon y se den cuenta que asi como viene... pues no sirve para ese tipo de fuentes.
Desde el dia domingo 25 estuvimos haciendo pruebas con el Typhon, aqui les dejo una breve reseña Al principio es un poco confuso entenderle a la logica de la interfaz (si es que se le puede llamar asi)... pantalla y botones. Es facil de conectar pero un poco dificil de programar. Tiene 4 botones con los que se programa. - Menu - Select - Incrementar valor - Disminuir valor Tiene 4 modos TIMER Este modo desde mi punto de vista es el mas importante y el que a todos nos interesa ya que nos permite programar cuando se va a prender/apagar y tambien nos permite programar los efectos de amanecer/atardecer (FADE). ALL CHANELS ON Este modo lo que hace es prender todos los canales, aqui mi opinion es que le falto un poco mas de programacion... algo asi como prender/apagar cada canal por separado. ALL CHANNELS OFF Este modo apaga todos los canales... insisto como que falto algo de programacion. Respecto a los modos ALL CHANNELS ON/OFF me hubiera gustado que la programacion hubiera sido ciclica, es decir presiono 1 vez... se prende un canal, 2 veces... el canal 2, 3 veces... el canal 3, 4 veces.... el canal 4, 5 veces... todos los canales, 6 veces se apagan todos los canales. O algo por el estilo. CUSTOM % En este modo se pone el valor (en %) al cual desea uno que prendan todos los canales (¿?)... cosa curiosa se prenden todos los canales a x% de intensidad, si quiere uno que se apaguen tiene que ser de forma manual o cambiando de modo. La verdad no le veo ninguna utilidad a este modo. Cosa curiosa, al programar la hora nos permite hacerlo por separado... es decir programa minutos, se presiona un boton y se programan las horas. Pero para programar la hora de encendido, la hora de apagado y el tiempo en que hace la variacion de intensidad solo permite hacerlo por minuto, es decir si el programa inicial dice que encienda a las 12:00 y quieren programarlo para las 9:00 preparense a quedarse un buen rato presionando el boton hasta llegar al valor deseado ya que sube o baja solamente por minuto. Al programar el FADE (que es lo que permite hacer efectos de amanecer/anochecer) nos permite indicarle cual va a ser la intensidad maxima de cada canal, cuando se va a prender, cuando se va a apagar y en cuantos minutos va a hacer el FADE. TYPHON determina los intervalos de porcentaje, por ejemplo si le ponemos 10 minutos para el FADE y la intensidad maxima es de 100% cada minuto hara incrementos del 10%. En terminos generales mi opinion es que es un producto que vale la pena... es relativamente economico y facil de instalar y programar (una vez que se le entiende a la logica de la interfaz). Comentario aparte como esta basado en ARDUINO y el codigo es del dominio publico, es muy sencillo (aja si...) modificar el codigo y en teoria hacer que el TYPHON haga lo que uno quiera... como lo que comente de los canales. Aun no lo monto en mi tanque, espero esta semana hacerlo y poder tomar un video para que vean como funciona.
que bueno que ya lo lograron hacer funcionar, en realidad hay que familiarizarse con los terminos de la interface, pero en general es un buen producto. Claro es bueno solo para luces ya que es relativamente complicado si se quiere hacer alguna expansion, aunque ya se esta trabajando en modulos para luz de noche y control de temperatura o wave makers. el codigo es facil de modificar lo que sucede es que hay que estar empapado de los codigos del arduino es mas parte de mi codigo en el controlador de mi reef tome ideas del codigo del typon para implementar por ejemplo los menu que los controla en forma sencilla y muy eficiente. incluso los componentes del typon son de facil reemplazo ya que no tiene componentes de superficie. yo por ejemplo repare uno que quemaron el micro atmega y solo fue de reemplazarlo e instalarle de nuevo el programa y listo funciono al 100%
¿Y que paso con la liga de reefcentral que nos ibas a compartir? Tambien si fuera posible me gustaria ver una copia del sketch que usaste para tu programacion. Saludos
claro ya sabes mucho trabajo. el link con la información de arduino es este, aca hay ejemplos de como conectar los componentes básicos al arduino, de esta liga se desarrollo el typon que es un desarrollo mas sencillo y sin mucha complicación. http://www.reefcentral.com/forums/showthread.php?t=1987110&highlight=arduino el tema de desarrollo del typon lo podes ver acá este también incluye los planos para hacer el PBC y los componentes que se usan y como armarlo, al final del post tambien poder ver los modulos de expansión que todavía están en desarrollo. http://www.reefcentral.com/forums/showthread.php?t=1847680&highlight=arduino ahora la forma mas sencilla de trabajar un driver meanwell tipo D es con una conexion de un simple transistor con una resistencia, que no le veo lo complejo por ninguna parte, en este sistema pueden usar un transistor NTE 123AP que tiene un costo de 1 o 2 pesos la resistencia unos cuantos centavos. Esta es la forma mas sencilla de hacerlo aunque tambien es posible hacerlo con un amplificador operacional, pero esto si requiere un montaje bastante mas elaborado. En otro punto les puedo mostrar mi sketch actual este tiene implementados 4 drivers hechos por mi persona con chips CAT4101 2 sensores de temperatura (que estoy calibrando ahorita) un wave maker con 2 koralias, que expandiré a 4 tomas este mes para poder contrar el skimer y un reactor, para poder controlar los tiempos de comida automaticamente. tambien controla los ventiladores de la lampara led y la luz de noche con fase lunar. Por el momento esto tengo implementado, estoy esperando que pasen los gastos de el principio de año para poder pedir mi sonda de PH y agregarla al sistema Código://Setup GLCD #include <glcd.h> #include <glcd_Buildinfo.h> #include <glcd_Config.h> #include "fonts/Arial14.h" // proportional font #include "fonts/SystemFont5x7.h" // system font #include "bitmaps/allBitmaps.h" // Set up RTC #include "Wire.h" #define DS1307_I2C_ADDRESS 0x68 // RTC variables byte second, rtcMins, oldMins, rtcHrs, oldHrs, dayOfWeek, dayOfMonth, month, year, psecond; byte bluePins[] = { 2, 3}; // pwm pins for blues byte whitePins[] = { 4, 5}; // pwm pins for whites byte blueChannels = 2; // how many PWMs for blues (count from above) byte whiteChannels = 2; // how many PWMs for whites (count from above) int channelDelay = 10; // this sets the delay in minutes between strings // of the same color for simulating directional light. // 0 means all will ramp up at the same time. int blueStartMins = 740; // minute to start blues. Change this to the number of minutes past // midnight you want the blues to start. int whiteStartMins = 758; // minute to start whites. Same as above. int bluePhotoPeriod = 680; // 540 photoperiod in minutes, blues. Change this to alter the total // photoperiod for blues. int whitePhotoPeriod = 660; // 510 photoperiod in minutes, whites. Same as above. int fadeDuration = 60; // duration of the fade on and off for sunrise and sunset. Change // this to alter how long the fade lasts. byte blueMax = 255; // max intensity for blues. Change if you want to limit max intensity. byte whiteMax = 225; // max intensity for whites. Same as above. byte nigthligthpin = 6; // nigthligth output. byte fanspin = 53; // fans pin. boolean fanstatus; //Fan status byte nigthstatus; //nigth ligth intensity byte blueVal; //Value of blue leds to display GLCD. byte whiteVal; //Value of white leds to display GLCD. //*******************Back GLCD Ligth ******************************** //******************************************************************** byte backLigthPin = 7; //PWM Pin for LCD back ligth. int backLigthStart; // int backLigthTime = 15; //Time to turn-off the back ligth. //*******************Display Sleep************************************ //******************************************************************** boolean onScreen = HIGH; //Screen state. int startDisplay = 0; //Time when star display. int displayOnTime = 4; //minutes to sleep screen. //******************cursor keyboard asignmet variables***************** //**********************Menu varibles********************************** byte buttons [5] = {50, 46, 52, 48, 44}; byte up = 50; // up button. byte down = 46; // down button. byte left = 52; // left button. byte rigth = 48; // rigth button. byte enter = 44; // center button. //menu variables byte menuMap = 0; // map of menu positions byte subMenuCounter = 0; // counter for submenus boolean secElapsed = HIGH; // flag to display each second; //*****************************debounce variables*********************** int buttonState; byte reading; boolean keyPressed; //***********************intensity of the moon trough all month********** int moonVals[31] = {0, 0, 3, 5, 6, 9, 10, 15, 20, 30, 40, 60, 80, 130, 80, 60, 30, 20, 15, 10, 6, 5, 4, 3, 3, 2, 1, 1, 1, 1, }; //***********************Wave Maker Variables******************** byte kora1 = 49; //Digital pin for koralia #1 byte kora2 = 51; //Digital pin for koralia #2 int fullWave = 240; //minute to start the full movement in the acuarium. int sleepWave = 1400; //minute to start the nigth wave movement. byte j = 0; //control cicling variable. byte waveTimes[] = {1,1,20,20}; //Time of each configuration 0=kora1 1=kora2 2=boot kora 3=boot kora. int startTime = 1; //Time of start time of each cicle boolean kora1Status = HIGH; boolean kora2Status = HIGH; boolean koraAllStatus= HIGH; //Status of koralia system fullwave or sleepwave boolean koraNigthTurn = HIGH; //turn of each koralia in the sleep time. //*******FOOD TIME************* boolean foodTime = LOW; //food time option. int foodStart = 0; //food time start. byte ftd = 8; //food time duration. //***********************Temperature read Variables******************** unsigned int tempRead = 0; //Read of the analog input. int tempAcum = 0; //Acumulator for temp reading. unsigned int temperature[] = {0,0}; //temperature reading by sensor 1 and 2. byte tempPin[] = {0,1}; //Pins were connected the 2 lm35. // Other variables. These control the behavior of lighting. Change these to customize behavior int minCounter = 0; // counter that resets at midnight. Don't change this. /****** LED Functions ******/ /***************************/ //function to set LED brightness according to time of day //function has three equal phases - ramp up, hold, and ramp down byte setLed(int mins, // current time in minutes byte ledPin, // pin for this channel of LEDs int start, // start time for this channel of LEDs int period, // photoperiod for this channel of LEDs int fade, // fade duration for this channel of LEDs byte ledMax // max value for this channel ) { byte ledVal = 0; if (mins <= start || mins > start + period) { //this is when the LEDs are off, thus ledVal is 0; ledVal = 0; fanstatus = LOW; nigthstatus = moonVals[dayOfMonth-1]; } if (mins > start && mins <= start + fade) { //this is sunrise ledVal = map(mins - start, 0, fade, 0, ledMax); fanstatus = HIGH; nigthstatus = moonVals[dayOfMonth-1]; } if (mins > start + fade && mins <= start + period - fade) { //this is when the lights are on max (between sunrise and sunset) ledVal = ledMax; fanstatus = HIGH; nigthstatus = 255; } if (mins > start + period - fade && mins <= start + period) { //this is the sunset. ledVal = map(mins - start - period + fade, 0, fade, ledMax, 0); fanstatus = HIGH; nigthstatus = moonVals[dayOfMonth-1]; } analogWrite(ledPin, ledVal); //Serial.print("Fan status: "); //debugger //Serial.println(fanstatus, BIN); //Serial.print("Nigth ligts: "); //Serial.println(nigthstatus, DEC); return ledVal; } //********Led Functions call*********** //************************************* void update_leds( void ){ int i; byte ledVal; for (i = 0; i < blueChannels; i++){ ledVal = setLed(minCounter, bluePins[i], blueStartMins + channelDelay*i, bluePhotoPeriod, fadeDuration, blueMax); //Serial.print("Valor LED Azul: "); //debugger //Serial.println(ledVal, DEC); blueVal=map(ledVal,0,blueMax,0,100); //information to display GLCD } for (i = 0; i < whiteChannels; i++){ ledVal = setLed(minCounter, whitePins[i], whiteStartMins + channelDelay*i, whitePhotoPeriod, fadeDuration, whiteMax); //Serial.print("Valor LED Blanco: "); //debugger //Serial.println(ledVal, DEC); whiteVal=map(ledVal,0,whiteMax,0,100); //Information to display GLCD } } /***** RTC Functions *******/ /***************************/ // Convert normal decimal numbers to binary coded decimal byte decToBcd(byte val) { return ( (val/10*16) + (val%10) ); } // Convert binary coded decimal to normal decimal numbers byte bcdToDec(byte val) { return ( (val/16*10) + (val%16) ); } // 1) Sets the date and time on the ds1307 // 2) Starts the clock // 3) Sets hour mode to 24 hour clock // Assumes you're passing in valid numbers. //void setDateDs1307(byte second, // 0-59 // byte minute, // 0-59 // byte hour, // 1-23 // byte dayOfWeek, // 1-7 // byte dayOfMonth, // 1-28/29/30/31 // byte month, // 1-12 // byte year) // 0-99 //{ // Wire.beginTransmission(DS1307_I2C_ADDRESS); // Wire.send(0); // Wire.send(decToBcd(second)); // Wire.send(decToBcd(minute)); // Wire.send(decToBcd(hour)); // Wire.send(decToBcd(dayOfWeek)); // Wire.send(decToBcd(dayOfMonth)); // Wire.send(decToBcd(month)); // Wire.send(decToBcd(year)); // Wire.endTransmission(); //} // Gets the date and time from the ds1307 void getDateDs1307(byte *second, byte *minute, byte *hour, byte *dayOfWeek, byte *dayOfMonth, byte *month, byte *year) { Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.send(0); Wire.endTransmission(); Wire.requestFrom(DS1307_I2C_ADDRESS, 7); *second = bcdToDec(Wire.receive() & 0x7f); *minute = bcdToDec(Wire.receive()); *hour = bcdToDec(Wire.receive() & 0x3f); *dayOfWeek = bcdToDec(Wire.receive()); *dayOfMonth = bcdToDec(Wire.receive()); *month = bcdToDec(Wire.receive()); *year = bcdToDec(Wire.receive()); } //**********************BUTTON PROCEDURES************************ //*************************************************************** void checkbut() { keyPressed = LOW; buttonState = 0; for ( byte i = 0; i < 5; i++) { byte debounce = 0; reading = 0; reading = digitalRead(buttons[i]); //reading button. //Serial.print("Lectura del boton"); //Serial.println(reading, DEC); if (reading == 1) { delay(5); debounce = digitalRead(buttons[i]); //Serial.print("Boton debounce: "); //Serial.println(debounce, DEC); if (debounce == reading) { keyPressed = HIGH; buttonState = buttons[i]; //GLCD.CursorTo(15,7); //GLCD.print("true"); Serial.print("boton precionado: "); Serial.println(buttonState); } } } } //****************Wave Maker procedure****************** //****************************************************** //**Procedure to control 2 koralia circulation pumps*** void waveMaker(int minCounter2) { Serial.print("minutos actuales: "); Serial.println(minCounter2); //Serial.print("full wave: "); //Serial.println(fullWave); //Serial.print("sleepwave: "); //Serial.println(sleepWave); //Serial.print("Tiempo del cambio ciclo: "); //Serial.println(startTime+waveTimes[j]); if (minCounter2 > fullWave && minCounter2 <= sleepWave ) //full wave time { //pumps activation in full wave time. if (j == 0) { digitalWrite(kora1,HIGH); digitalWrite(kora2,LOW); kora1Status = HIGH; kora2Status = LOW; //Serial.println("ciclo uno, kora 1 on, kora2 off"); } if (j == 2) { digitalWrite(kora1,LOW); digitalWrite(kora2,HIGH); kora1Status = LOW; kora2Status = HIGH; //Serial.println("ciclo dos, kora 1 off kora2 on"); } if (j == 3 || j == 1) { digitalWrite(kora1,HIGH); digitalWrite(kora2,HIGH); kora1Status = HIGH; kora2Status = HIGH; //Serial.println("ciclo tres, kora 1 on, kora2 on"); } //Time and cicle definition for koralia cicle in full wave time. if (minCounter2 >= startTime + waveTimes[j]) { startTime = minCounter2; j = j++; if (j == 4) {j = 0;} } koraAllStatus = HIGH; } if (minCounter2 > sleepWave) //sleep time only use 1 koralia from sleepwave to midnight. { if (koraNigthTurn == HIGH) //Check which koralia use tonight. { digitalWrite(kora1, HIGH); digitalWrite(kora2, LOW); kora1Status = HIGH; kora2Status = LOW; } else { digitalWrite(kora1, LOW); digitalWrite(kora2, HIGH); kora1Status = LOW; kora2Status = HIGH; } //Serial.println("bombas inicio sleep"); koraAllStatus = LOW; } if (minCounter2 <= fullWave) //sleep time only use 1 koralia from midnight to fullwave. is the oposite to previus option. { if (koraNigthTurn == HIGH) //Check which koralia use tonight. { digitalWrite(kora1, LOW); digitalWrite(kora2, HIGH); kora1Status = LOW; kora2Status = HIGH; } else { digitalWrite(kora1, HIGH); digitalWrite(kora2, LOW); kora1Status = HIGH; kora2Status = LOW; } //Serial.println("bombas final sleep"); koraAllStatus = LOW; } if ( rtcHrs == 12 && rtcMins == 1 && second == 1) { koraNigthTurn = ~koraNigthTurn; } } //***********TEMP sensors read procedures**************** //******************************************************* void lectTemp() { temperature[0] = 0; temperature[1] = 0; tempRead=0; tempRead = analogRead(0); delay(20); tempRead=0; tempRead = analogRead(0); //Serial.print("Lectura de pin analogo 0: "); //Serial.println(tempRead); temperature[0] = (5 * 100 * tempRead)/1024; // Serial.print("Resultado de conversion: "); //Serial.println(temperature[0],DEC); //Serial.print("contador minutos Temperatura1: "); //Serial.println(minCounter); /*for (byte i=0; i <=1; i++) { tempRead = 0; analogRead(tempPin[i]); delay(30); //Serial.print("contador minutos temperatura ciclo i: "); //Serial.println(minCounter); for (byte k=0; k <= 5; k++) { tempRead = tempRead + analogRead(tempPin[i]); //Serial.print("contador minutos temperatura ciclo k: "); //Serial.println(minCounter); } tempRead = tempRead / 6; Serial.print("Lectura de pin analogo "); Serial.print(tempPin[i],DEC); Serial.print(":"); Serial.println(tempRead); temperature[i] = (5 * tempRead * 100) / 1024; Serial.print("Resultado de operacion pin "); Serial.print(tempPin[i],DEC); Serial.print(": "); Serial.println(temperature[i]); //Serial.print("contador minutos despues division: "); //Serial.println(minCounter); } */ } //********************************GLCD Display procedures************************** //********************************************************************************* void printMins(byte mins) // format a number of minutes into a readable time { if (mins < 10) { GLCD.print("0"); } GLCD.print(mins, DEC); } void printHMS (byte hr, // format a number of hour into a readable. byte mn, byte sec ) { if ( hr < 10) { GLCD.print("0"); } GLCD.print(hr, DEC); GLCD.print(":"); printMins(mn); GLCD.print(":"); if (sec < 10) { GLCD.print("0"); } GLCD.print(sec, DEC); } //*****************MENU 1***************************** void menu1() //Idle screen { Serial.println("enter menu 1"); GLCD.ClearScreen(); // Day time status graph if (minCounter >= blueStartMins && minCounter < whiteStartMins + fadeDuration) //This is sunrise. { GLCD.DrawBitmap(sunR24x24 , 95, 10); } if (minCounter > whiteStartMins + fadeDuration && minCounter < whiteStartMins + whitePhotoPeriod - fadeDuration) //This is full sun. { GLCD.DrawBitmap(sun24x24 , 95, 10); } if (minCounter >= whiteStartMins + whitePhotoPeriod - fadeDuration && minCounter < whiteStartMins + whitePhotoPeriod) //This is sunset. //This is sunset. { GLCD.DrawBitmap(sunS24x24 , 95, 10); } if (minCounter > whiteStartMins + whitePhotoPeriod || minCounter < blueStartMins) //This is night. { GLCD.DrawBitmap(moon24x24 , 95, 10); } GLCD.CursorTo(0, 0); // set cursor to top left of LCD (uses character coordinates GLCD.print("CRISAGUILAR"); // sends strings to LCD. Does not wrap to next line! GLCD.CursorTo(0, 1); GLCD.print("White LED :"); GLCD.print(whiteVal, DEC); GLCD.print(" %"); GLCD.CursorTo(0, 2); GLCD.print("Blue LED :"); GLCD.print(blueVal, DEC); GLCD.print(" %"); GLCD.CursorTo(13, 0); printHMS(rtcHrs, rtcMins, second); //print hour into screen GLCD.CursorTo(0, 3); GLCD.print("Temp 1: "); GLCD.print(temperature[0]); GLCD.CursorTo(0,4); GLCD.print("Temp 2: "); GLCD.print(temperature[1]); GLCD.CursorTo(0, 5); GLCD.print("KORA1 KORA2 FAN NIGHT"); //GLCD Print Information GLCD.CursorTo(16, 6); GLCD.print(map(nigthstatus,0,255,0,100), DEC); GLCD.print(" %"); if (fanstatus == HIGH) //Graph print part { GLCD.DrawBitmap(fanON17x17, 72, 46); } else { GLCD.DrawBitmap(fanOFF17x17, 72, 46); } if ( kora1Status == HIGH) { GLCD.DrawBitmap(koraON17X17, 5, 46); } else { GLCD.DrawBitmap(koraOFF17X17, 5, 46); } if ( kora2Status == HIGH) { GLCD.DrawBitmap(koraON17X17, 43, 46); } else { GLCD.DrawBitmap(koraOFF17X17, 43, 46); } if ( koraAllStatus == HIGH) { GLCD.DrawBitmap(koraRec, 27, 48); } else { GLCD.DrawBitmap(koraSleep, 25, 48); } } //*******************MENU 2*********************************** void menu2(byte subMenuC) { GLCD.ClearScreen(); GLCD.DrawBitmap(fish , 0, 0); GLCD.DrawBitmap(Up10X19 , 70,5); GLCD.DrawBitmap(Down10X19 , 70,52); GLCD.CursorTo(12, 0); GLCD.print("MENU"); GLCD.CursorTo(10, 3); if (subMenuC == 2 ){ GLCD.print("Hora Comida"); } if (subMenuC == 3 ){ GLCD.print("Cont Luces"); } if (subMenuC == 4 ){ GLCD.print("Bombas"); } if (subMenuC == 1 ){ GLCD.print("Hrs y Fecha"); } GLCD.CursorTo(10, 5); if (subMenuC == 3 ){ GLCD.print("Hora Comida"); } if (subMenuC == 4 ){ GLCD.print("Cont Luces"); } if (subMenuC == 1 ){ GLCD.print("Bombas"); } if (subMenuC == 2 ){ GLCD.print("Hrs y Fecha"); } GLCD.SelectFont(Arial14); GLCD.CursorTo(5, 2); if (subMenuC == 1 ){ GLCD.print("Hora Comida"); } if (subMenuC == 2 ){ GLCD.print("Cont Luces"); } if (subMenuC == 3 ){ GLCD.print("Bombas"); } if (subMenuC == 4 ){ GLCD.print("Hrs y Fecha"); } GLCD.SelectFont(System5x7); GLCD.CursorTo(2, 7); printHMS(rtcHrs, rtcMins, second); //print hour into screen } //*******************MENU 3*********************************** //*** Food Time idle*** void menu3() { GLCD.ClearScreen(); GLCD.SelectFont(Arial14); GLCD.CursorTo(1, 0); GLCD.print("Hora_de_Comida"); GLCD.SelectFont(System5x7); GLCD.CursorTo(0, 2); GLCD.print(" Para iniciar el"); GLCD.CursorTo(0, 3); GLCD.print(" tiempo de comida"); GLCD.CursorTo(0, 4); GLCD.print(" presiona intro"); GLCD.CursorTo(0, 5); GLCD.print(" Duracion de "); GLCD.print(ftd, DEC); GLCD.print(" min"); GLCD.CursorTo(7, 7); printHMS(rtcHrs, rtcMins, second); } //*******************MENU 4*********************************** //*** Food Time counter*** void menu4(int mincrono) { if (mincrono <= foodStart + ftd) { digitalWrite(kora1, LOW); digitalWrite(kora2, LOW); kora1Status = LOW; kora2Status = LOW; foodTime = HIGH; GLCD.ClearScreen(); GLCD.SelectFont(Arial14); GLCD.CursorTo(0, 0); GLCD.print("Hora_de_Comida"); GLCD.SelectFont(System5x7); GLCD.DrawBitmap(Pezbit2 , 59, 11); GLCD.CursorTo(0, 2); GLCD.print(" TIEMPO"); GLCD.CursorTo(0, 3); GLCD.print("RESTANTE"); GLCD.CursorTo(0, 4); printHMS(0, foodStart + ftd - mincrono, 60 - second); GLCD.CursorTo(0, 5); GLCD.print("KORA1 KORA2"); //GLCD Print Information GLCD.DrawBitmap(koraOFF17X17, 9, 48); GLCD.DrawBitmap(koraOFF17X17, 44, 48); GLCD.CursorTo(14, 6); GLCD.print("HORA"); //GLCD Print Information GLCD.CursorTo(13, 7); printHMS(rtcHrs, rtcMins, second); //print hour into screen } else { foodTime = LOW; menuMap = 1; subMenuCounter = 1; GLCD.ClearScreen(); GLCD.DrawBitmap(pezen1, 15, 0); GLCD.CursorTo(3, 0); GLCD.print("Fin Hora Comida"); digitalWrite(kora1, HIGH); digitalWrite(kora2, LOW); kora1Status = HIGH; kora2Status = LOW; delay(20000); } } //****************GLCD Back Ligth procedures**************** //******************************************************* void backLigth(int minCounter3) { if (minCounter3 >= backLigthStart+backLigthTime) { analogWrite(backLigthPin,10); menuMap=0; //Serial.println("back ligth off"); } else { analogWrite(backLigthPin,255); //Serial.println("back ligth on"); } } void setup() { // init I2C Serial.begin(9600); Wire.begin(); // init GLCD GLCD.Init(NON_INVERTED); // initialise the library, non inverted writes pixels onto a clear screen GLCD.ClearScreen(); GLCD.SelectFont(System5x7); // switch to fixed width system font // init KEYBOARD assign pins input for (byte i=0; i<5 ; i++) { pinMode(buttons[i],INPUT); } pinMode(kora1,OUTPUT); pinMode(kora2,OUTPUT); pinMode(fanspin,OUTPUT); analogReference(DEFAULT); } /*********************************** Main Loop ***********************************************/ /*********************************************************************************************/ /*********************************************************************************************/ void loop(){ getDateDs1307(&second, &rtcMins, &rtcHrs, &dayOfWeek, &dayOfMonth, &month, &year); if (psecond != second){ //check if the time change psecond = second; secElapsed = HIGH; minCounter = rtcHrs * 60 + rtcMins; //conversion from hours to minutes. //Serial.print("Minutos Transcurridos: "); //Serial.println(minCounter); update_leds(); analogWrite(nigthligthpin,nigthstatus); //nigth ligths digitalWrite(fanspin, fanstatus); //Fans //***************SCREENSAVER****************** //******************************************** if (minCounter == 0) { backLigthStart = 0; startDisplay = 0;} //midnight reset if (minCounter >= startDisplay+displayOnTime) { onScreen = ~onScreen; startDisplay = minCounter; } if (onScreen == HIGH) { GLCD.SetDisplayMode(NON_INVERTED); } else { GLCD.SetDisplayMode(INVERTED); } Serial.print("contador minutos: "); //debugg mensage Serial.println(minCounter); //******Wave Maker****** if (foodTime == LOW) { waveMaker(minCounter); } lectTemp(); } //***************Test several times each second********** //*********************BUTTON READ************** checkbut(); backLigth(minCounter); if (keyPressed == HIGH) { startDisplay = minCounter; //restart screensaver counter GLCD.SetDisplayMode(NON_INVERTED); //set non inverted screen onScreen = HIGH; //set screen mode non inverted backLigthStart = minCounter; //set back ligth glcd time if (buttonState != enter && menuMap == 0) { menuMap = 1; } if (buttonState == enter) { if (menuMap == 3) //Enter to food time { menuMap ++; subMenuCounter = 1; } if (menuMap == 2) //Rotate throug menu options { menuMap = menuMap + subMenuCounter; } if (menuMap == 0 || menuMap == 1) //Enter to main menu screen { menuMap ++; subMenuCounter = 1; } if (menuMap == 4) { foodStart = minCounter; } } if (buttonState == up) { if (subMenuCounter > 1) // Max submenu options { subMenuCounter --; } else { subMenuCounter = 4; } } if (buttonState == down) { if (subMenuCounter < 4) // Min submenu options { subMenuCounter ++; } else { subMenuCounter = 1; } } if (buttonState == left) { menuMap = 1; subMenuCounter = 1; foodTime = LOW; } } //*************MENU DISPLAY************************************* //**********only 1 time each second***************************** Serial.print("Numero de menu actual:"); Serial.println(menuMap, DEC); Serial.print("Submenu: "); Serial.println(subMenuCounter, DEC); if ( secElapsed == HIGH) { secElapsed = LOW; if (menuMap == 0 || menuMap == 1) { menu1(); } if (menuMap == 2) { menu2(subMenuCounter); } if (menuMap == 3) { menu3(); } if (menuMap == 4) { menu4(minCounter); } } if (keyPressed == HIGH) {delay (300);} } // End of program
Muy interesante todo, pero... No veo donde con un simple transistor conectan una fuente tipo D a un typhon... podrias postear un diagrama o una imagen de como lo hacen. Gracias
alli esta la imagen del arduino es lo mismo solo que en lugar de usar la salida numero 2 del arduino lo conectas a la salida del Typon y la tierra la misma de la salida del TYPON te voy a poner un typon en el dibujo pero mas tarde por que tengo trabajo ahorita ok
Ok ya voy entendiendo, pero entonces no es un simple transistor... es un transistor dos resistencias y un potenciometro. ¿correcto? ¿Ahora para que necesito un potenciometro?, no se supone que el Typhon hace el dimeo por medio de la funcion FADE o la funcion CUSTOM que trae integrada.
Bueno aca te dejo la imagen para que tengas una mejor idea de como se conectaria al sistema de dimeo original del driver tipo D La fuente de 10v. la tenes que tener por que es la que necesitas para hacer funcionar el meanwell (la sección de 10 v. del typon no la podrías usar), luego de esto tendrías que usar el potenciometro que te puede servir como un limitador del máxima intensidad de tu tira de leds. Este potenciometro también lo deberías tener ya que este sirve para el control de dimeo original del driver. La idea es esta: Si ya tenes tu sistema de leds funcionando pero con un sistema de driver meanwell tipo D y quieren cambiar a un sistema de encendido y apagado automatizado con efectos de amanecer y anochecer. Pues si se puede comprando un typon o comprando un arduino, lo unico que tienen que compar extra es un transistor NTE123AP y 1 resistencia de 1k ohm para 1/8W y listo ya pueden controlar su driver sin problema. Todo lo demas de la imagen ya deberia estar instalado en su sistema original, el meanwell, la fuente de 10v, el potenciometro, y los led. pero con esta conexion ya pueden hacer fucionar su antiguo sistema sin problemas. Ahora si estan comprando el sistema completo por que no comparar de una vez un driver tipo P y asi se evitan todo el dolor de cabeza de hacer todas las conexiones. Y si creen que es muy dificil bla bla bla pues es mucho mejor que opten por un sistema ya armado por que todo tiene su complicacion y el hacer sistemas DIY implica trabajo investigación y esfuerzo. Les envio el diagrama de la conexion con el typon. Saludos
Pues sigo sin entender... la verdad y siendo prácticos no le veo el caso a tratar de controlar una fuente tipo D con un Typhon. Es bueno que se comenten este tipo de detalles ya que si algún compañero quiere controlar sus LEDs con un Typhon es mejor que de inicio compre una fuente que sea compatible y no andar parchando para ver si funciona o no, es mas si ya tiene una fuente que no sea compatible lo mejor desde mi punto de vista es que adquiera una que si lo sea, vaya para que tratar de inventar el hilo negro si ya existe. De hecho en ningún foro (reefcentral, reef2reef, ultimatereef... por mencionar algunos) han mencionado que se pueda hacer o que sea conveniente hacer este tipo de "parches". Cris la verdad se nota que sabes de electrónica y sabes bastante... pero recuerda que la gran mayoría de nosotros no conocemos ni siquiera el concepto de circuito, mucho menos podemos experimentar ni exponernos a quemar arduinos, fuentes y LEDs o de comprar componentes que después de probar y probar conexiones... al final no nos va a dar el resultado deseado. Te agradezco mucho tu participación en este tema y espero puedas ahondar un poco mas en tus explicaciones, como te comente somos neófitos en electrónica y necesitamos (al menos yo) que se nos explique con diagramas sencillos y paso por paso. Me gustaría me dieras tu opinión de este articulo y me comentaras si es mas sencillo y viable que el conexionado que nos compartiste en respuestas anteriores. http://provideyourown.com/2011/analogwrite-convert-pwm-to-voltage/ Saludos
del dia que hicimos las pruebas: el modulo: la patrona vigilando: esperamos poner pronto las de la lampara final...
Como ya explique en mi comentario hay muchas personas que comparon en un inicio driver tipo D y ahora ya no desean estar ajustando la intensidad con un potenciometro y a la vez desean tener efectos de amaneceres y anocheceres en forma automatica, para ellos sirve esta conexion. En lugar de gastar 50,100,150 dolares en cambiar todos los driver de su sistema, simplemente gastan unos 4 o 5 pesos por driver y los pueden controlar sin problema y sin modificar toda su instalación. Obiamente como ya comente si se arma una nueva lampara desde 0 es mucho mas logico usar un driver tipo P desde el incio. Como te comente en inicio esa imagen esta extraida de reefcentral en donde se trato todo este tema desde mucho puntos de vista. si te tomaras un tiempo de leer los hilos que coloque alli hay un post como de 80 paginas en donde estan todos los detales de las multiples conexiones que tienen conectados muchos miembros, incluyendome. No me los invente yo pero si los comprobe personalmente. Si las personas no realizaran estos "PARCHES" no se podrian desarrollar muchas cosas que tenemos actualmente en nuestos sistemas, es mas veo que no leiste el post en donde esta todo el desarrollo del controlador que estan usando, osea que si no se hicieran esos "parches" no tendrian los controladores que tienen en la mano ustesdes ahorita. ya que son los mismos parches pero ya maquillados para que sean mas faciles de usar. Pero creo tambien que hay en este foro hay miles de usuarios que ingresan a todos los temas y yo podria apostar mi brazo derecho a que esta información le sirve a mas de alguno, el hecho que varios no comprendan a fondo los comentarios no indica que nadie los comprende y si en realidad se quiere cubrir el tema de los LED se debe estar abierto a muchas opciones que nos da esta tecnologia y yo se que mas de alguno construirá su controlador electrónico en base a arduino y esta información le puede ayudar y espero que así sea. Al final te comento que muchas veces si dan los resultados deseados y a veces sobrepasan las expectativas. Ok mi idea es poder tener las referencias muy buenas que se tienen en otros foros mucho mas grandes, y en nuestro idioma sin necesidad de traducciones complejas, por ejemplo yo no tengo problemas con el ingles, pero si unos amigos de mi pais y ellos me pidieron ayuda y ya montamos 4 lamparas que están funcionando muy bien, a mi me gusta ayudar y demostrar que en nuestro medio también se pueden lograr las cosas que vemos en EEUU a pesar de las dificultades de encontrar los materiales o piezas si se puede hacer. Y tengo entendido que este tema tiene ese espíritu. Creo que las imágenes son bastante explicitas, no se que otra explicación dar, incluso cambie la foto del arduino con la del typon para mayor entendimiento. El procedimiento es sencillo. Y si doy una explicación mas técnica pues confundiré mas. En referencia a la opinon de el circuito que colocaste tiene un detalle que haria imposible su uso con TYPON, y es simplemente que el arduino solamente entrega 5v. en su salida pwm. y esto hace que el máximo voltaje que se logre con ese filtro es 5v. osea puede entregar de 0 a 5v. y el driver meanwell utiliza un voltaje de 0 a 10 volts. En realidad el sistema que propuse funciona prácticamente igual al que colocaste, solo que con la diferencia que controla un voltaje de 10v y esto hace que controle el driver en forma correcta. La salida del TYPON de 10v. esta controlada por un transistor igual al que yo coloque en la conexion discutida y esto hace que colocar un capacitor y una resistencia a la salida no entregue el efecto deseado, o si podría hacerse pero agregando otros componentes extras y creo que seria mas complejo y menos práctico. Como ultimo comentario les comparto que los que necesiten ayuda con sus led pues estoy a las ordenes, si tienen dudas pues no lo se todo pero en mas de algo les ayudo o por lo menos puedo dar ideas. Cero que ya no vale la pena seguir con el tema de la conexión de los dirver, por que se desvia el tema por completo y no deja apreciar el trabajo que los compañeros están realizando en sus lamparas. si cualquiera quiere profundizar el en tema del arduino, Typon, drivers, conexiones, controladores, etc, etc. me pueden enviar un MP y si desean puedo abrir un tema por aparte para discutir todo esto sin desviar este tema. Saludos a todos y 10000000 disculpas si mis comentarios ofenden a alguien mi intención es al 100% de ayudar y hacer mas diversa nuestra pasión por los acuarios marinos. Cristyan Aguilar
Cristian sería muy muy bueno que pudieras aportar tu conocimiento en un tema por aparte, la verdad es que el tema siempre se desvió al DIY, comenzaron con diagramas, debates y ahí quedó, me parece que esa no era la intención de dpavon que fué quien tuvo la iniciativa de realizar este tema, el primero y no el último en méxico. Entonces por qué no pones uno donde compartas tu conocimiento, es más que bienvenido. Un saludo
