Invernadero de hongos.

[David Met]

Por primera vez, voy a encarar un proyecto con un amigo que toca de oído a la electrónica y programa GAMBA; y yo que toco de oído a la electrónica y soy sordo en programación de PC. :titanic :titanic
Pero como ambos tenemos Fe, sabemos que tendremos un muy buen fin.

Lo que estamos haciendo, es un invernadero para hongos (aptos para el consumo humano) que será capaz de controlarse por internet. La manera en que decidimos encarar el proyecto fue, tomar un PIC con USB, un PC dedicada a supervisar al PIC y que esté conectado a Internet.
Del lado de la PC, como es de esperar, se programa en Gambas y del lado del PIC en Jalv2.

La forma de cultivar los hongos, es relativamente sencilla. Los hongos se cultivan en un vaso de plástico que lleva un "papel" con sustrato. Este sustrato es para alimentar al hongo. El vaso de plástico, lleva una tapa y un peso. Este peso es para mantener la tapa apoyada en el vaso para que se cree presión. Esta presión se genera, porque el hongo, a medida que va creciendo, emana un gas. Una vez que el hongo tiene la fuerza para levantar la tapa, sale por el rededor del vaso. El alimento del hongo, se hace una sola vez, por lo que no necesita supervisión.

Para garantizar una buen cultivo, hay que controlar a la temperatura, la humedad y la luz. Es aquí donde entra en juego el PIC. El PIC censa la humedad y la temperatura; y controla a los mismos con calefactor, refrigeración, ventilación, humificador y una fuente de luz. Esto quiere decir que, por cada vaso de plástico, se necesitan 7 dispositivos de los cuales 2 son censores y 5 son dispositivos generales. Esto parece muy poco pero si en vez de un solo vaso colocamos más, tendremos un invernadero grande y será tan grande como los dispositivos generales son capaces de soportar.

El proyecto, aún está en desarrollo y va lento.
Les muestro el hardware a utilizar en la versión 1.0 Si ven algo raro, por favor diganmelo:



También lo subo en pdf, porque me parece que se ve mejor.

[YO]

Hola David Met!!

Lindo proyecto encaraste!! 

Lo que no veo son los conectores para los sensores de luz.

En la medida en que pueda ayudarte, contá conmigo aunque más no sea para ponerle la tapita al vaso jejejeje 

Estoy seguro que  lograrás el objetivo muy satisfactoriamente 

[David Met]

Hola Yovani. Gracias por el aliento.

A la luz no la censamos, aunque no es mala la idea. La idea de que no la implementamos, es que se decidió hacerla crecer rápido. Solo tendrá algunas horas de noche. La encenderemos con el horario y no con falta de luz. Si durante el día tiene poca luz porque llueve, o está nublado, los hongos tendrán un poco de descanso que no les vendrá mal; pero bueno, también tendremos que experimentar con esto.

[HJ]

Hola David, tengo muchas preguntas... 

Esos vasos de los que hablas ¿de que tamaño son?
¿Que tamaño tendría en sí el invernadero? para ver que tipo de conexión podría llegar ha hacerse.
¿de cuantos "vasos" estamos hablando? por el mismo motivo que la pregunta anterior

¿No se justificaría ponerle un micro chico a cada uno y un micro concentrador que establezca la comunicación entre ellos a, modo de Master?

Saludos

[David Met]

Le hago la pregunta a Martiniano y te contesto. La verdad que eso se está encargando él.

[HJ]

Te hago esas preguntas, ya que es necesario saber de que estamos hablando para no tirar ideas al vicio, o encarar soluciones que después no van ha servir.

Saludos

[Ricber]

Muy interesante, cualquier cosa que necesites estaremos para
ayudar.
Veo un reloj, cual seria la funcion?

[David Met]

Gracias Ricardo. En la versión 1 no va a estar, es solo para la compatibilidad con la versión 2. En la versión 2, el objetivo sera que el PIC tome todas las deciciones por si solo, sin intervención de la PC

[David Met]

Te hago esas preguntas, ya que es necesario saber de que estamos hablando para no tirar ideas al vicio, o encarar soluciones que después no van ha servir.

Saludos

Ni bien tenga las medidas las paso. De todas maneras, los vasos no son grandes (del tamaño de una vaso de vidrio aprox.) y se agruparán según reunamos los dispositivos de refrigeración y calefacción. Según las frigorías y las calorías de cada equipo, nos dará la cantidad de hongo a cultivar.

[HJ]

Entonces vas ha tener que llenar de sensores... va ha ser un cablerío bárbaro, por decirlo de alguna manera. Creo que si o si vas ha tener que poner un micro para un grupo de vasos que trabaje en forma independiente y en todo caso utilizar algún tipo de protocolo "industrial" para interconectarlos.

En una de esas estoy entendiendo mal las cosas...

saludos

[Ricber]

Gracias Ricardo. En la versión 1 no va a estar, es solo para la compatibilidad con la versión 2. En la versión 2, el objetivo sera que el PIC tome todas las deciciones por si solo, sin intervención de la PC

Me imaginaba, se hace mas interesante con la posibilidad de que el micro atienda el proceso
autonomamente.

[YO]

Yo no creo que la solución pase por Hacer grupos de vasos, porque también se multiplicaría la cantidád de sistemas de balanceo térmico.

Lo ideal sería determinar cantidades para ensayos, y si no se tiene muy claro todavía el proceso y la cosa es por ahora experimentál, se podría usar una heladera en desuso y una estufa dentro de ella tipo caloventor, para proporcionar temperatura homogénea.

De ésta manera dejando siempre el ventilador del caloventor encendido (o cualquier ventilador al mínimo) se debería alternar entre encender el motor de la heladera o la resistencia del calefactor.

Esto es muy simple de hacer con el microcontrolador y se podría tener una colonia de hongos importante en función del tamaño de la heladera.

La iluminación no sería tampoco problema, y en algun lado ví que se utilizan longitudes de onda tipo ultravioleta para acelerar el proceso.

La NASA hace éstos ensayos con invernaderos como lo que mencioné de la heladera  y con una atmósfera simulada en su interior para ver la posibilidád de utilizar la superficie de Marte para sembradío.

¿Cual sería la temperatura de estabilización de las muestras?

En la semana pasada preparé un programa en Jal que justamente controla calor y frio en función de un setpoint, lo tengo terminado, cuando llegue a casa lo subo para ver si te sirve para probar y ya lo tendrias resuelto.  la semana próxima llego de viaje y publico las fotos del control o un video.     jejejejeje nos metimos de caveza en tu proyecto  espero que los hongos no terminen siendo venenosos con tanta electrónica 

[HJ]

Hola Yo (suena como saludarse solo  ) muy buena idea eso de la heladera.
Tiro un par de ideas al respecto, lo haría tipo cámara frigorífica, es decir, utilizando un forzador de aire pen funcionamiento permanente y como elemento calefactor una de esas resistencias que se utilizan en la estufas de cuarzo. También se debería controlar, por lo visto, la humedad, pero que es factible.
En las incubadoras de huevos, la humedad se controla con recipientes de agua que son calentados por las mismas resistencias que generan el calor y el exceso es retirado mediante extractores (ventiladores sacando aire).

Y sí, nos hemos metido todos con los hongos electrónicos  .

Saludos

[YO]

Claro, lo del calefactor de cuarzo tambien sirve hace el mismo efecto 

Y lo de la humedád tambien se podría  resolver así como dices controlando un goteo.

Solo por si sirve para algo (auque creo que David ya lo tiene cocinado) les dejo mi programa de control de temperatura, falta el control de la humedad pero no sería problema agregarleselo.



Uploaded with ImageShack.us

Lo probé con un Pirómetro marca Jumo (Aleman) nuevo y parece que dicen lo mismo.

Acá les dejo el programa

-- PROGRAMA: TERMOCONTROL (versión 01)

-- DESCRIPCIÓN:
-- Este programa mide y controla la temperatura desde -40ºC a 125ºC
-- El sensor utilizado es un TC1047 conectado a un amp.op que multiplica
-- por dos la salida del sensor, ingresando al ADC de un PIC 16f877A.
-- El ADC está configurado en 8 bits, por lo tanto la resoluciòn serà de
-- 1ºC, teniendo la posibilidád de medir y controlar temperaturas tanto
-- negativas como positivas.
-- Se podrá modificar el setpoint mediante las teclas de PGM, MAS y MENOS,
-- en todo el rango de medición, tanto en la pantalla de "espera" como en
-- la pantalla de "trabajo", retornando siempre al lugar desde donde se
-- pidió cambiar el setpoint.
-- Para recorrer rápidamente el rango de SP se agregó la función de
-- programar primero las unidades, pero si la tecla de incremento o la
-- de decremento se mantiene oprimida por más de 9 cambios, se comenzará
-- a modificar las decenas, al soltar la tecla, vuelve a modificar las
-- unidades si ésta se vuelve a oprimir.
-- El valor de SP queda guardado en EEPROM, por lo tanto, cada vez que se
-- conecte la alimentación, tomará el último valor utilizado.
-- El contról es de dos salidas, tipo on/off, una activa antes de alcanzar el
-- set y la otra, al superarlo.
-- El estado de las salidas se verá en la pantalla de trabajo
-- Al momento de energizarlo, queda en "espera" hasta que se habilita la
-- medición por medio de la tecla RUN, si mientras que está en la "pantalla
-- de  trabajo" se vuelve a oprimir ésta tecla, volverá al modo de "espera".
   
-- IMPORTANTE:

-- Este código fué creado como "ejercicio de programación en JAL v2"
-- y tal como está funciona correctamente.
-- Se autoriza su publicación con fines didacticos a los foros de:
-- Meteorología Fácil y uControl.
-- Toda modificación o uso del mismo, implicará notificarlo a los
-- respectivos Foros, publicando las mejoras, código modificado y comentarios.
-- Como complemento de éste ejercicio, se podría incluír una rutina en la
-- que mientras se esté programando, simultáneamente el contról esté activo.



-- Programa creado por Juan (Yovani - (YO)) 07/08/011 --

-- Incluimos la librería del pic 16F877A
include 16f877a

             
pragma target OSC HS   -- Usamos un cristal...
pragma target clock 4_000_000 -- de 4 Mhz.
pragma target WDT  disabled  -- No Perro guardian
pragma target LVP  disabled  -- No programar en baja tensión

----------------------- Configuro los pines de E/S --------------------------

enable_digital_io()      -- Todos los pines como I/O digitales


    alias Run  is pin_C0        -- Tecla Run será equivalente al pin 15 (RC0)   
    alias Pgm is pin_C1         -- Tecla Pgm será equivalente al pin 16 (RC1)   
    alias Mas  is pin_C2        -- Tecla Mas será equivalente al pin 17 (RC2)     
    alias Menos is pin_C3       -- Tecla Menos será equivalente al pin 18 (RC3)
   alias Calefactor is pin_C4  -- El calefactor será equivalente al pin 19 (RC4)
   alias Ventilador is pin_C5  -- El Ventilador será equivalente al pin 20 (RC5)

   alias Run_direction is pin_c0_direction
   alias Pgm_direction is pin_c1_direction
   alias Mas_direction is pin_c2_direction
   alias Menos_direction is pin_c3_direction
   alias Calefactor_direction is pin_c4_direction
   alias Ventilador_direction is pin_c5_direction

   Run_direction = input
   Pgm_direction = input
   Mas_direction = input
   Menos_direction = input

   Calefactor_direction = output
   Ventilador_direction = output

   
------- Declaro las constantes y variables a utilizar en el programa --------

var dword sumatoria
var dword medicion
var sdword SPv
var  byte SPK
var sdword temperatura
var byte   Iniciar
var byte   Programar
var byte   Retomar
var sdword temp
var byte c_1 = 0
var byte c_2 = 0


include delay     
include format
include pic_data_eeprom





----------------------- Configuro el LCD -------------------------------------

const byte LCD_ROWS    =  2        -- LCD de 2 lineas
const byte LCD_CHARS   =  20       -- y 20 caracteres por linea

     alias  lcd_en        is  pin_D7       -- Pin E del LCD
     alias  lcd_rs        is  pin_D6       -- Pin RS del LCD
     alias  lcd_dataport  is  portB_low    -- 4 data pins
portb_direction = 0x00         -- Todo el puerto B como salidas
portD_direction   = all_output     -- Todo el puerto D como salidas

                                    -- (B0 al pin 11 del LCD, DB4)
                                           -- (B1 al pin 12 del LCD, DB5)
                                           -- (B2 al pin 13 del LCD, DB6)
                                           -- (B3 al pin 14 del LCD, DB7)



-- --------------------------------------------------------------------------
-- Incluyo librerias e inicializo LCD:
-- --------------------------------------------------------------------------
include lcd_hd44780_4                 -- Incluyo la libreria del LCD
lcd_init()                            -- e inicializo el controlador del LCD
include print                         -- Rutinas para mostrar valores en el LCD 

------------------ Cadenas a mostrar (Mensajes) ----------------

var byte line1[LCD_CHARS] = "Termo control       "  -- Mensaje de arranque                       
var byte line2[LCD_CHARS] = "en espera           "
var byte line3[LCD_CHARS] = "Programar set point "
var byte line4[LCD_CHARS] = "SP:                 "                                                     
var byte line5[LCD_CHARS] = "Iniciando           "
var byte line6[LCD_CHARS] = "Medicion            "                                       
var byte line7[LCD_CHARS] = "Temperatura:        "
var byte line8[LCD_CHARS] = "Set:      out1=  2= "


-- -------- Rutina para mostrar el símbolo de grado ----------
-- ------------ creada por el Maestro FELIXIS ----------------

const byte signogrado[] =     
{ 
   0b_00001100,
   0b_00010010,
   0b_00010010,
   0b_00001100,
   0b_00000000,
   0b_00000000,
   0b_00000000,
   0b_00000000
}

lcd_define(0, signogrado)

-- -------------------------------------------------------------
-- -------------------------------------------------------------
   
-- -------------------- Configuramos el ADC ------------------------
-- Utilizamos el modo de baja resolución (8 bits)

const bit ADC_HIGH_RESOLUTION = false        -- ADC en 8 bits

const byte ADC_NCHANNEL = 1      -- Usamos un solo canal de entrada

-- No utilizamos la referencia externa

const byte ADC_NVREF = ADC_NO_EXT_VREF -- Como volt referencia usamos
                                       -- la tension de la fuente
 
include adc      -- Incluímos la librería de control

adc_init()      -- Inicializamos el adc




-- --------------------------------------------------------------------
-- -------- Declaramos los procedimientos que realizaremos ------------

procedure Pantalla_Espera () is -- Procedimiento de pantalla de espera
      
   forever loop

         if Programar == 1 then
            exit loop
          end if

      Calefactor = off
      Ventilador = off

         Retomar = 0

        lcd_clear_screen()             -- Borro la pantalla

   lcd_cursor_position(0,0)    -- Coloco el cursor para centrar el mensaje
   print_string(lcd, line1)    -- Escribo el mensaje (Termo control)
   lcd_cursor_position(1,0)    -- Coloco el cursor para centrar el mensaje
   print_string(lcd, line2)    -- Escribo el mensaje (en espera)

        delay_100ms(1)       -- Retardo para ver mensaje

   if Run == 0 then      
         
          while (Run == 0 ) loop
            Iniciar = 1   
        end loop
      exit loop
    end if

   if PGM == 0 then
       
         while (PGM == 0 ) loop
            Programar = 1
            Retomar = 1
        end loop
      exit loop
    end if

              
  end loop
   

end procedure
-- -----------------------------------------------------------------------
-- -----------------------------------------------------------------------
procedure Pantalla_Comienzo () is      -- Procedimiento de pantalla de comienzo

   if Iniciar == 1 then

      Calefactor = off
      Ventilador = off

         lcd_clear_screen()             -- Borro la pantalla

   lcd_cursor_position(0,0)    -- Coloco el cursor para centrar el mensaje
   print_string(lcd, line5)   -- Escribo el mensaje (Iniciando)
   lcd_cursor_position(1,0)    -- Coloco el cursor para centrar el mensaje
   print_string(lcd, line6)   -- Escribo el mensaje (Medicion)

         delay_100ms(30)          -- espero 3 segundos...

      end if
   Iniciar = 0   
   

end procedure

-- --------------------------------------------------------------------------
-- --------------------------------------------------------------------------
procedure Pantalla_Trabajo () is     -- Procedimiento de pantalla de trabajo

       temperatura = 0 
     
     forever loop                    --Bucle principal

      if Retomar == 1 then
            exit loop
          end if

         Retomar = 0

--    ---- Ahora tomamos la mediciòn del canal 0 del ADC ----
--    -------    255 veces y hacemos un promedio    ---------


      for 255 loop   
            
        medicion = adc_read_low_res(0)     -- Tomamos el valor de la medición
                                        -- en el canal 0
      sumatoria = sumatoria + medicion     -- Sumamos las muestras.....
   end loop

   sumatoria = sumatoria / 255         -- y terminamos el promedio, el
   medicion = sumatoria            -- resultado queda en mediciòn
    
   delay_100ms(7)           -- Hacemos un retardo para que se vean los
                       -- cambios de lectura antes de borrar la pantalla

   temperatura = (medicion * 196)/10        -- convertimos el valor del adc a volt
   temperatura = (temperatura /2)+2

   temperatura = (temperatura - 500)/10      -- lo pasamos a temperatura
   temp = temperatura
   
         lcd_clear_screen()             -- Borramos la pantalla

   lcd_cursor_position(0,0)    -- Colocamos el cursor para centrar el mensaje
   print_string(lcd, line7)   -- Escribimos el mensaje (Iniciando)
   lcd_cursor_position(1,0)    -- Colocamos el cursor para centrar el mensaje
   print_string(lcd, line8)   -- Escribimos el mensaje (Medicion)

    lcd_cursor_position(0,11)        -- Colocamos el cursor para ubicar la medición
    format_sdword_dec(lcd, temp,4,0) -- y lo mostramos sin decimales
   lcd = 0                     -- Agregamos el símbolo de grado
   lcd = "C"               -- y el prefijo de centígrado

   SPv = SPK       
   SPv = (((SPv * 196)/10)/2)-500        -- convertimos el valor de la eeprom a volt
   SPv = SPv/10
   
   lcd_cursor_position(1,3)        -- Colocamos el cursor para ubicar el setpoint
   format_sdword_dec(lcd, SPv,4,0) -- y lo mostramos sin decimales
   lcd = 0
   lcd = "C"

         delay_100ms(1)      -- Retardo para ver mensaje

       if Run == 0 then        -- Acá avisamos que queremos dejar de medir         
          while (Run ==0 ) loop   
        end loop
          Iniciar = 0          
           exit loop         -- salimos del loop
         Pantalla_Espera ()

        end if

    if PGM == 0 then          -- Acá avisamos que queremos modificar el setpoint
         while (PGM == 0 ) loop
            Programar = 1
        end loop
      exit loop
    end if

--       -------   Esta es la rutina de contról ------

         if temp < SPv then
            Calefactor = on
             Ventilador = off
            lcd_cursor_position(1,15) 
            lcd_write_char("1")
            lcd_cursor_position(1,19) 
            lcd_write_char("0")

         elsif temp == SPv then
            Calefactor = off
             Ventilador = off
            lcd_cursor_position(1,15) 
            lcd_write_char("0")
            lcd_cursor_position(1,19) 
            lcd_write_char("0")

         elsif temp > SPv then
            Calefactor = off
             Ventilador = on
            lcd_cursor_position(1,15) 
            lcd_write_char("0")
            lcd_cursor_position(1,19) 
            lcd_write_char("1")
          
         end if
   end loop
end procedure



-- -------------------------------------------------------------------------   
-- -------------------------------------------------------------------------

procedure Prog_sp () is     -- Procedimiento de programar set point

   if Programar == 1 then

      lcd_clear_screen()             

   lcd_cursor_position(0,0)   
   print_string(lcd, line3)   
      delay_100ms(20)       

   lcd_cursor_position(1,0)   
   print_string(lcd, line4)     

   c_1 = 0
   c_2 = 0

   forever loop

   SPv = SPK
      SPv = (((SPv * 196)/10)/2)-500        -- convertimos el valor de la eeprom
         SPv = SPv/10                       -- a temperatura
   
         if SPv < -40 then
            SPv = -40
         end if

            if SPv > 125 then
               SPv = 125
            end if   

   lcd_cursor_position(1,6)       
   format_sdword_dec(lcd, SPv,4,0) 
   lcd = 0
   lcd = "C"

   if (Mas == 0) then      
         delay_100ms(5)
         if SPv < 125 then
                  
            if (c_1 < 9) then
               SPK = SPK + 1
               c_1 = c_1 + 1               
            else
               SPK = SPK + 10   
               c_1 = c_1 + 1            
             end if
         end if                 
      else   
         c_1 = 0                  
   end if


      if (Menos == 0) then               
         delay_100ms(5)
                if SPv > -40 then

               if (c_2 < 9) then
                  SPK = SPK - 1   
                  c_2 = c_2 + 1
               else
                  SPK = SPK - 10   
                  c_2 = c_2 + 1         
                  end if   
            end if
      else
         c_2 = 0                                                                                                 
   end if
               
   

      if PGM == 0 then               
          while (PGM == 0 ) loop       
               end loop
            delay_100ms(5) 
            data_eeprom_write (0,SPK)
            delay_100ms(5)           
            SPK = data_eeprom (0)
         
          exit loop
      end if

     end loop

     end if      

      Programar = 0

end procedure

-- ----------------------------------------------------------------
-- ----------------------------------------------------------------


-- -------------------------------------------------------------------
--      ******** Acà inicia el programa en sì ********
-- -------------------------------------------------------------------
         Programar = 0
         Iniciar = 0   
         Retomar = 0
         Calefactor = off
         Ventilador = off

         SPK = data_eeprom (0)

         SPv = SPK       
            SPv = (((SPv * 196)/10)/2)-500    
            SPv = SPv/10                
         
forever loop      
         Pantalla_Espera ()      
         Prog_sp ()            
         Pantalla_Comienzo ()      
         Pantalla_Trabajo ()      

end loop

-- ---------------------------------------------------------------------
--    ********************** y acá terminó ***********************
-- ---------------------------------------------------------------------

Saludos!

[David Met]

Hola a todos.
Gracias por las buenas ideas y concejos que me están dando.

La idea es, tomar un grupo reducido de vasos con hongos y hacerle su propio ambiente. Por ahora, la idea que tenemos en mente es colocarlo dentro de una caja (el cual caben o van a caber 5 vasos) y controlarle todos los parámetros.
La manera con que configuramos el pic, puede controlar hasta 4 cámaras o cajas, por lo tanto serían 20 vasos.

Hay una razón por la de hacer 4 cámaras, y es para cultivarlos en diferentes fechas. Por ejemplo, el comienzo de la cámara 2, será a dos semanas más tarde de iniciar el primero. La cámara 3 se hará 2 semana después del segundo, y lo mismo con la cuarta cámara. Lo hacemos así para no tener que cosechar todos los hongos en forma simultánea. Si lo hacemos separado, siempre tendremos hongos frescos.

La parte que más nos preocupa, es la refrigeración. Porque tener 4 aire acondicionados, es una muy mala idea. Calculo que haremos lo que dice HJ para controlar la temperatura, con un extractor de aire. De todas maneras, estamos investigando y empezaremos a hacer pruebas. Otra alternativa que tenemos en mente, si falla esta, es la de hacer una sola cámara pero cultivar de la misma manera que la anterior.