Programador de riego

Hola a todos de nuevo.

He conseguido que mi estación Netatmo pare el riego cuando llueve. También puedo encenderlo automáticamente cuando la lluvia pare, pero es pronto porque el suelo está aún mojado. Lo suyo es que se activara 4 días después pero IFTT no tiene esa receta. Lo único que se me ocurre es que Netatmo actuará sobre el botón virtual V33, por ejemplo, que parase temporalmente, 4 días por ejemplo, y que pasados esos 4 días se encendiera otra vez. El problema es que no me aclaro como tengo que hacerlo a nivel de código.
Al principio puse el código, y añadí la parte donde aparece ese delay, pero no funciona.

Alguna pista de cómo puedo programarlo?

Otra opción es ver si se puede hacer el delay directamente en la instrucción Webhooks. eso seria mas fácil

Gracias

Actualiza el código para retomar el problema que planteas, hace tiempo de esto.

Hola a todos.

Al final he conseguido solucionar este tema como sigue:

  1. Netatmo detecta lluvia ... para el riego con un web request a través de IFTTT.
  2. IFTTT enciende otra vez el riego cuando el "weather" cambia a "clear" tomando mi localización. Esto es mejor que hacer que se encienda con el Netatmo cuando deja de llover.

Ahora paso a la siguiente parte del proyecto. Controlar la zona 2 del jardín. He llevado luz 220v desde una árquela a la árquela donde tengo el programador de pilas Rain Bird con una zanja de solo 5 metros, un macarrón y 2 cables. He comprado un solenoide Hunter de 24V y un transformador de 220V a 24V para alimentarlo.

Ahora mi idea es poner de momento un Sonoff pero prefiero poner un modulo Arduino y controlarlo desde el que tengo en la zona 1, así puedo utilizar Netatmo e IFTTT.

Para esto he pensado en un emisor y transmisor RF 433 como este:

RF 433 Arduino

Arduino UNO

Rele

Reductor 24V a 12V

En el Arduino actual tengo un rele de 4 de los cuales solo uso 3. Por lo tanto el cable GPIO13 del INT4 será el que conectaré al pin Data del emisor.

// PINES
// INT 1 = D0 = GPIO16
// INT 2 = D5 = GPIO14
// INT 3 = D6 = GPIO12
// INT 4 = D7 = GPIO13 = Emisor RF433

El esquema del receptor creo que sería este, poniendo el cable que va del Rele del receptor al Arduino en el PIN 13 (en la foto esta en el 10 por error), así coincidirá con el programa que tengo actualmente.

Esquema receptor

Este es el esquema que actualmente tengo en el Arduino que controla la zona 1:

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "XXXXXXX";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "XXXXXXXXX";
char pass[] = "XXXXXXXX";

// PINES
// INT 1 = D0 = GPIO16
// INT 2 = D5 = GPIO14
// INT 3 = D6 = GPIO12
// INT 4 = D7 = GPIO13 = Emisor RF433

byte switch_pins[] = {14 , 12 , 16 , 13}; // number of gpio to be used as switch/relay control

bool switch_default[] = {HIGH,HIGH,HIGH,HIGH}; // switches that use reverse polarity should be set to HIGH here

////////////////////////////////////////////////////////////////////////////////////////
// This code can control up to 4 switches                                            //
// For each switch up to 4 schedule start and end times can be configured - (V0..V15) //
// A default duration can be defined per switch                           - (V16..V19)//
// If an end time is not defined at the app the default duration is used              //
// default duration is also used when manually activating the switch       - (V20..V23)//
// for each switch when start time is reached the switch turns on for the duration    //
//                                                                                    //
// maximum duration is used for safety (to limit activation time)          - (V24..V27)//
////////////////////////////////////////////////////////////////////////////////////////
int  start_time_sec[SWITCH_CNT][TIME_CNT];     // array of 4 start times (in seconds) for 4 switches [switch number][schedual timer number]
bool start_valid[SWITCH_CNT][TIME_CNT];        // is the start time valid ?
bool weekdays[SWITCH_CNT][TIME_CNT][8];        // array of 8 days (day 0 not used) for each schedual time
int  active_duration[SWITCH_CNT][TIME_CNT+1];  // duration per switch per time(in sec)
bool end_valid[SWITCH_CNT][TIME_CNT];          // is the end time valid ?
int  max_duration[SWITCH_CNT];                 // max duration per switch
int auto_off = 1;           // 1 is auto or on

// when activating a switch a timer is set for the configured duration
// when the duration ends the switch is turned off by the timer
// the id of the timer is saved using end_timer_id
// if switch is manually turned off the end_timer_id is used to stop the timer.

// end_timer_id is initialized to 32 (per entry) at the setup section
int end_timer_id[SWITCH_CNT];

// timer object declaration
BlynkTimer timer;

// this code use Real Time Clock widget in the blynk app to keep the clock updated from net
WidgetRTC rtc;


BLYNK_CONNECTED() {
  // Synchronize time on connection
  rtc.begin();
  Blynk.syncAll();
}
WidgetLED led1(V55);

bool ledStatus = auto_off;



// V55 LED Widget is ON or OFF
void LedWidget()
{ledStatus = auto_off;
  if (ledStatus) {
   led1.on();
  } else {
    led1.off();
    
  }
}

//////////////////////////////////////////////////////////
// get schedual parameters from App                     //
//////////////////////////////////////////////////////////
void set_time(BlynkParam param, byte switch_no, byte time_no){

     TimeInputParam t(param);
  // Process start time

  if (t.hasStartTime())
  {
    
    Serial.println(String("Start: ") +
                   t.getStartHour() + ":" +
                   t.getStartMinute() + ":" +
                   t.getStartSecond());
    Serial.println(String("Start in sec: ") + param[0].asLong() + String(" for switch") + switch_no + String(" time_no: ") + time_no);
    start_time_sec[switch_no][time_no]= param[0].asLong();
    start_valid[switch_no][time_no] = true;

  }
  else
  {
    // Do nothing
    Serial.println(String("No Start Time Given for switch: ") + switch_no + String(" time_no: ") + time_no);
    start_valid[switch_no][time_no] = false;
  }



  //////////////////////////////////////////////////////////////////////////////
  // check if end time is received convert and save it as day time in seconds //
  //////////////////////////////////////////////////////////////////////////////
  if (t.hasStopTime())
  {
    
    Serial.println(String("Stop: ") +
                   t.getStopHour() + ":" +
                   t.getStopMinute() + ":" +
                   t.getStopSecond());
    Serial.println(String("Stop in sec: ") + param[1].asLong() + String(" for switch") + switch_no + String(" time_no: ") + time_no);

    active_duration[switch_no][time_no] = (param[1].asLong()-start_time_sec[switch_no][time_no]);
    
    // if end time is smaller than start time this means end time is at next day
    if (active_duration[switch_no][time_no]<0) active_duration[switch_no][time_no]=86400+active_duration[switch_no][time_no];
    
    Serial.println(String("Stop duration: ") + active_duration[switch_no][time_no]);

    end_valid[switch_no][time_no] = true;


  }
  else // if end time is not defined //
  {
    // Do nothing
    Serial.println(String("No Stop Time Given for switch: ") + switch_no + String(" time_no: ") + time_no);
    end_valid[switch_no][time_no] = false;
  }

Que tengo que añadir para que me funcione el RF 433 y cuando el programador active el tiempo de riego en el Rele 4 (pin 13) se active el riego en la zona 2?

Gracias y un saludo

Resto del código

// Process weekdays (1. Mon, 2. Tue, 3. Wed, ...)

  for (int i = 1; i <= 7; i++) {
    if (t.isWeekdaySelected(i)) {
      Serial.println(String("Day ") + i + " is selected");
      weekdays[switch_no][time_no][i] = true;
    }
    else {
      weekdays[switch_no][time_no][i] = false;
    }
    
  }

    Serial.println();

}
//this reads status of on/off mode and displays on screen
BLYNK_WRITE(V50) { int Vpin50 = param.asInt();
  auto_off = Vpin50;}


// V0..V3 for switch 0, V4..V7 for switch 1 ...
BLYNK_WRITE(V0)  { set_time(param, 0,0);  }
BLYNK_WRITE(V1)  { set_time(param, 0,1);  }
BLYNK_WRITE(V2)  { set_time(param, 0,2);  }
BLYNK_WRITE(V3)  { set_time(param, 0,3);  }

BLYNK_WRITE(V4)  { set_time(param, 1,0);  }
BLYNK_WRITE(V5)  { set_time(param, 1,1);  }
BLYNK_WRITE(V6)  { set_time(param, 1,2);  }
BLYNK_WRITE(V7)  { set_time(param, 1,3);  }

BLYNK_WRITE(V8)  { set_time(param, 2,0);  }
BLYNK_WRITE(V9)  { set_time(param, 2,1);  } 
BLYNK_WRITE(V10) { set_time(param, 2,2);  }
BLYNK_WRITE(V11) { set_time(param, 2,3);  }

BLYNK_WRITE(V12) { set_time(param, 3,0);  }
BLYNK_WRITE(V13) { set_time(param, 3,1);  }
BLYNK_WRITE(V14) { set_time(param, 3,2);  }
BLYNK_WRITE(V15) { set_time(param, 3,3);  }

// use a slider to define default activation duration (slider count in minute)
BLYNK_WRITE(V16) { active_duration[0][TIME_CNT] = param.asInt()*60; }
BLYNK_WRITE(V17) { active_duration[1][TIME_CNT] = param.asInt()*60; }
BLYNK_WRITE(V18) { active_duration[2][TIME_CNT] = param.asInt()*60; }
BLYNK_WRITE(V19) { active_duration[3][TIME_CNT] = param.asInt()*60; }


// use a slider to define default max duration (slider count in minute)   ***HARD CODE THIS*** NL
BLYNK_WRITE(V24) { max_duration[0] = param.asInt()*60; }
BLYNK_WRITE(V25) { max_duration[1] = param.asInt()*60; }
BLYNK_WRITE(V26) { max_duration[2] = param.asInt()*60; }
BLYNK_WRITE(V27) { max_duration[3] = param.asInt()*60; }

/////////////////////////////////////////////////////////////////
// Handle switch events (from app or from scheduler )          //
/////////////////////////////////////////////////////////////////

// turn off switch after active duration ends
// duration number is not important here 
void turn_off_switch_no_0(){ turn_on_off(0,0,0); Blynk.virtualWrite(V20,0); Serial.println(String("timer turn off switch 0 ") );}
void turn_off_switch_no_1(){ turn_on_off(0,1,0); Blynk.virtualWrite(V21,0); Serial.println(String("timer turn off switch 1 ") );}
void turn_off_switch_no_2(){ turn_on_off(0,2,0); Blynk.virtualWrite(V22,0); Serial.println(String("timer turn off switch 2 ") );}
void turn_off_switch_no_3(){ turn_on_off(0,3,0); Blynk.virtualWrite(V23,0); Serial.println(String("timer turn off switch 3 ") );}

// handle switch state
void turn_on_off(int on_off, byte switch_no , byte time_no){
    long active_duration_ms ;
    char Time_print[16];
    
    if ((on_off==1) && (auto_off == 1)) //auto_off is a slider in app to shut off the program
    {
      // create time as string to print on activation butten
      sprintf(Time_print, "%02d:%02d", hour(), minute());

      // turn on the switch (or off if default is on)
      digitalWrite(switch_pins[switch_no],!switch_default[switch_no]);

      // if end time is valid use the active duration assigned to this time
      // (change to msec will be done later)
      if (end_valid[switch_no][time_no])
         active_duration_ms = ((long)active_duration[switch_no][time_no]);
      else // otherwise use the general time duration
         active_duration_ms = ((long)active_duration[switch_no][4]);

      
      // max duration smaller than two min is not valid
      if ( (max_duration[switch_no]< 120) | (max_duration[switch_no]>active_duration_ms) )
         active_duration_ms = active_duration_ms*1000;
      else
        active_duration_ms = ((long)max_duration[switch_no])*1000;
       

      // if new timer is set before another one ended then disable previous timer
      if (end_timer_id[switch_no]!=32) timer.deleteTimer(end_timer_id[switch_no]);

      // turn on switch and set timer 
      switch (switch_no) {
        case 0: 
          Blynk.setProperty(V20, "onLabel", String(Time_print));
          Blynk.virtualWrite(V20,1);
          end_timer_id[0]=timer.setTimeout(active_duration_ms, turn_off_switch_no_0);
          
         break;
        case 1: 
          Blynk.setProperty(V21, "onLabel", String(Time_print));
          Blynk.virtualWrite(V21,1);
          end_timer_id[1]=timer.setTimeout(active_duration_ms, turn_off_switch_no_1);
         break;
        case 2: 
          Blynk.setProperty(V22, "onLabel", String(Time_print));
          Blynk.virtualWrite(V22,1);
          end_timer_id[2]=timer.setTimeout(active_duration_ms, turn_off_switch_no_2);
         break;
        case 3: 
          Blynk.setProperty(V23, "onLabel", String(Time_print));
          Blynk.virtualWrite(V23,1);
          end_timer_id[3]=timer.setTimeout(active_duration_ms, turn_off_switch_no_3);
         break;    
      } 
      Serial.println(String("turn ON switch: ") + switch_no + String(" for duration: ") + active_duration_ms/60000 + String("min "));
    }
    else 
    {
      digitalWrite(switch_pins[switch_no],switch_default[switch_no]);
      timer.deleteTimer(end_timer_id[switch_no]);
      end_timer_id[switch_no]=32;
      Serial.println(String("turn OFF switch: ") + switch_no);
    }   
}

Resto

// set switch state from APP
BLYNK_WRITE(V20) { turn_on_off(param.asInt(),0,TIME_CNT); }
BLYNK_WRITE(V21) { turn_on_off(param.asInt(),1,TIME_CNT); }
BLYNK_WRITE(V22) { turn_on_off(param.asInt(),2,TIME_CNT); }
BLYNK_WRITE(V23) { turn_on_off(param.asInt(),3,TIME_CNT); }

/////////////////////////////////////////////////////////////////////////////////////////////
// the following function is called every 60 seconds by a timer                            //
//  the function checks if a start time is reached and if yes it will call                 //
//   the turn_on_off function (to turn on the switch and set timer for turning off switch) //
/////////////////////////////////////////////////////////////////////////////////////////////
void activetoday(){         // check if schedule #1 should run today

  if(Blynk.connected()) // set wifi led if no connection
  {
    digitalWrite(WIFI_LED,LOW); 
  }
  else
  {
    digitalWrite(WIFI_LED,HIGH); 
  }
  
  if(year() != 1970){
    unsigned int nowseconds = ((hour() * 3600) + (minute() * 60) + second());
    int dayadjustment = -1;  
    if(weekday() == 1){
      dayadjustment = 6; // needed for Sunday Time library is day 1 and Blynk is day 7
    }
   
 
     for (int switch_cnt = 0;  switch_cnt< SWITCH_CNT; switch_cnt++) {
         for (int timer_cnt = 0;  timer_cnt< TIME_CNT; timer_cnt++) {
              if (start_valid[switch_cnt][timer_cnt] == true) {
                if (weekdays[switch_cnt][timer_cnt][weekday() + dayadjustment]==true){
                  
                   if (nowseconds >= start_time_sec[switch_cnt][timer_cnt]){
                      
                      if(nowseconds < start_time_sec[switch_cnt][timer_cnt]+90){
                        turn_on_off(1,switch_cnt,timer_cnt);
                        Serial.println(String("turn ON switch: ") + switch_cnt);

                      }
                   }
                }
              }
         }
      
     }
 
  } 
}

/////////////////////////////////////

// Digital clock display of the time
void clockDisplay()
{
  // You can call hour(), minute(), ... at any time
  // Please see Time library examples for details

  String currentTime = String(hour()) + ":" + minute() + ":" + second();
  String currentDate = String(day()) + " " + month() + " " + year();
  Serial.print("Current time: ");
  Serial.print(currentTime);
  Serial.print(" ");
  Serial.print(currentDate);
  Serial.println();

  // Send DATE and DATE to Blynk APP
  Blynk.virtualWrite(V101, currentTime);
  // Send date to the App--Not used but is available--this will show processor date if it is important to you
  Blynk.virtualWrite(V102, currentDate);
}


void setup()
{
  
  Serial.begin(9600);  // Debug console
  
  // reset output pins used and system variables
  for (int i = 0; i<SWITCH_CNT ; i++){
    pinMode(switch_pins[i], OUTPUT); // reset output pins
    digitalWrite(switch_pins[i],switch_default[i]); // set switch to default
    end_timer_id[i] = 32;            // reset end timer id's

    for (int j = 0; j<TIME_CNT ; j++)
    {
      end_valid[i][j] = false;       // reset end valid array
    }
    
  }

  
  pinMode(WIFI_LED, OUTPUT);

  
  Blynk.begin(auth, ssid, pass);
    rtc.begin();  // Begin synchronizing time
    timer.setInterval(10000L, clockDisplay);
    timer.setInterval(60000L, activetoday);  // check every 60s if ON / OFF trigger time has been reached
    setSyncInterval(10 * 60); // Sync interval in seconds (10 minutes)

}

void loop()
{
  Blynk.run();
  timer.run();
  LedWidget();
}

Hola a todos. A ver si este finde me pongo con el código, soy novato total, pero creo que tengo que buscar que constante corresponde al switch 4 y con el comando IF hacer que envíe con SEND del emisor al receptor una señal cuando esté en LOW para que el receptor mande al rele remoto señal LOW. Cuando el programador finalice el tiempo de riego, que envíe HIGH.

A ver si me aclaro en qué parte del código tengo que ponerlo.

Hola.

Creo que lo voy a hacer más simple. En la app Blynk voy a añadir un nuevo device Arduino UNO con un nuevo token. Voy a montar el UNO con el rele. Le subiré el. Is o sketch que tengo para mi Arduino actual con el Nuevo token y nueva IP.
En la app seleccionare para el scheduler y botones del cuarto rele el device Arduino UNO y el pin al que conecte el rele.

En principio debe funcionar, no?

Yo ya lo he hecho con unas electroválvulas como las tuyas y 3 relés.

Lo que hago es usar un relé que corta la tensión cuando hago el cambio y mientras no le llegan los 9V invierto otros dos reles para mandar por vada uno 9V o 0V segun quiera abrir o cerrar. Estos 2 reles los uso al revés y a cada uno le meto 9V y 0V por cada pata, seleccionando lo que debe salir.

El chiste de esa electroválvula es que mandando 9 y 0 abre y mandando 0 y 9 cierra.

Pero tienen el peligro de que si una vez abierto el riego, te quedas sin batería en el arduino o silimilar... la inundación está garantizada.

En realidad uso 4 relés, porque son 2 las electrovalvulas a conectar.

Te copio mi código por si te sirve

//Constantes
long tiempoMaximo = 18000000;
//pines
int pin_Boton_Ev_1 = 3;
int pin_R1 = 4;
int pin_R2 = 5;

int pin_Boton_Ev_2 = 6;
int pin_R3 = 7;

int pin_Boton_Lasdos = 8;

// Semáforos
boolean estado_Ev_1 = false;
boolean estado_Ev_2 = false;
boolean fasedoble = false;

long tiempo = 0;
// the setup function runs once when you press reset or power the board


void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(pin_Boton_Ev_1, INPUT);
  pinMode(pin_Boton_Ev_2, INPUT);
  pinMode(pin_Boton_Lasdos, INPUT);
  pinMode(pin_R1, OUTPUT);
  pinMode(pin_R2, OUTPUT);
  pinMode(pin_R3, OUTPUT);
  pinMode(2, OUTPUT);
  Serial.begin(9600);
  apaga();
  delay(2000);
  fasedos();
}

// the loop function runs over and over again forever
void loop() {
//  pintar();

/***********************************************************  
 *   Control de Tiempos
 ***********************************************************/
  if(estado_Ev_1 || estado_Ev_2){
    tiempo++;
    if (tiempo > tiempoMaximo){
      tiempo = 0;
      if (estado_Ev_1) apaga_Ev_1();
      if (estado_Ev_2) apaga_Ev_2();
      if (fasedoble) {
        fasedoble = false;
        enciende_Ev_2();
      }
    }
  }
  else tiempo=0;


/***********************************************************  
 *   Tratar Boton 1
 ***********************************************************/
  
  int nuevoEstado = digitalRead(pin_Boton_Ev_1);
  if (nuevoEstado == 1){
    fasedoble = false;
    if (estado_Ev_2) apaga_Ev_2();
    if (!estado_Ev_1) enciende_Ev_1();
    else apaga_Ev_1();
  }

/***********************************************************  
 *   Tratar Boton 2
 ***********************************************************/

  nuevoEstado = digitalRead(pin_Boton_Ev_2);
  if (nuevoEstado == 1){
    fasedoble = false;
    if (estado_Ev_1) apaga_Ev_1();
    if (!estado_Ev_2) enciende_Ev_2();
    else apaga_Ev_2();
  }

/***********************************************************  
 *   Tratar Boton 3
 ***********************************************************/

  nuevoEstado = digitalRead(pin_Boton_Lasdos);
  if (nuevoEstado == 1) fasedos();
} 

void pintar(){
  Serial.print("Tiempo: ");
  Serial.print(tiempo);
  Serial.print(" Fasedoble: ");
  Serial.print(fasedoble);
  Serial.print(" Estado 1: ");
  Serial.print(estado_Ev_1);
  Serial.print(" Estado 2: ");
  Serial.println(estado_Ev_2);
}

void fasedos(){
    fasedoble = true;
    tiempo = 0;
    if (estado_Ev_2) apaga_Ev_2();
    if (!estado_Ev_1) enciende_Ev_1();
}

void enciende_Ev_1() {
  estado_Ev_1 = true;
  digitalWrite(pin_R1, HIGH);
  digitalWrite(pin_R2, LOW);
// Igualo EV2
  digitalWrite(pin_R3, LOW);
  
  enciende();
  delay(500);
  apaga();
}

void apaga_Ev_1() {
  estado_Ev_1 = false;
  digitalWrite(pin_R1, LOW);
  digitalWrite(pin_R2, HIGH);
   // Igualo EV2
  digitalWrite(pin_R3, HIGH);
  enciende();
  delay(500);
  apaga();
}

void enciende_Ev_2() {
  estado_Ev_2 = true;
  digitalWrite(pin_R3, HIGH);
  digitalWrite(pin_R2, LOW);
// Igualo EV1
  digitalWrite(pin_R1, LOW);
  
  enciende();
  delay(500);
  apaga();
}

void apaga_Ev_2() {
  estado_Ev_2 = false;
  digitalWrite(pin_R3, LOW);
  digitalWrite(pin_R2, HIGH);
   // Igualo EV2
  digitalWrite(pin_R1, HIGH);
  enciende();
  delay(500);
  apaga();
}

void enciende() {
  digitalWrite(2, HIGH);   // turn the LED on (HIGH is the voltage level)
}

void apaga() {
  digitalWrite(2, LOW);   // turn the LED off (LOW is the voltage level)
  digitalWrite(pin_R3, LOW);
  digitalWrite(pin_R2, LOW);
  digitalWrite(pin_R1, LOW);
}

@jguajardo

Gracias por tu respuesta. Estuve tentado con unos bridge que compre o el tema Del doble rele, pero al final preferí comprar solenoides de 24V por el tema que comentas de que si se va la luz mientras está abierto se anega todo. Al final conseguí vender bien el programador y los 3 solenoides de 9V el Arduino me ha salido gratis.

Tengo una zona 2 que quiero manejar desde la misma app Blynk por lo que he devuelto el Arduino UNO y he comprado un NodeMCU que me va fenomenal en el otro prográmador.

Le voy a cargar el mismo sketch que tengo en el otro con su token. Conectare el rele al D7 que es donde lo tengo en el que tengo ahora, y en la app Blynk dejare todo igual menos el device, que elegiré el nuevo.

Con esto ya tengo todo listo. Mañana cuando me llegue todo os digo si me funciona.

Un saludo.

Hola a todos, como era de esperar me ha funcionado a la primera. Solo falta que el lunes me llegue el transformador a 24V para los solenoides y montó todo.

Que chulo, todo manejado desde la misma app de iOS. Lo chuleo de esto comparado con HomeKit es que con ifttt paro el riego automáticamente cuando mi pluviómetro Netatmo detecta lluvia, y conecta el riego cuando weather detecta cambio a clear.

Comprobado. Conexiones hechas y funciona de lujo. Esto ha sido más fácil que utilizar un emisor y receptor rf. Al final la app Blynk te permite añadir distintos Arduinos.

Estoy súper contento.

Muy buen trabajo @Torque73!!
Lograste tu cometido luego de una buena pelea.
Esto es así. Se lucha mucho contra nuestras propias limitaciones y desconocimientos de tantos temas pero si eres perseverante se sientes Muy Bien por lo conseguido.
Nadie te quitará el mérito de que lo hiciste tu solo.