Los precios de la electricidad, hora a hora.

[Caravantes]

Ya sabéis que el precio de la electricidad ha subido mucho. Y además nos marean porque cada hora tiene un precio distinto, sin que tenga validez alguna aquello que planteó el gobierno sobre los tramos "valle", "llano" y "punta". No sabemos a qué hora es razonable poner la lavadora o el radiador.

En la siguiente página de Red Eléctrica se puede ver una gráfica con los distintos precios que nos cobran, cada hora, por el consumo eléctrico. Se puede consultar el día actual, los días anteriores, y a partir de las 21 horas también se puede consultar el día siguiente.
https://www.esios.ree.es/es/pvpc

La propuesta es que Tasker obtenga esos datos para ayudarnos a gestionar mejor nuestros consumos eléctricos. Creo que este asunto puede interesar a más personas, y me gustaría que fuese un proyecto colectivo, no solo mío.

La idea de partida puede ser que Tasker consulte los precios cada día, a las 00:01, para hacer una tabla de 24 elementos, con el precio de cada hora. Luego ya iremos viendo la forma de gestionar óptimamente estos datos.

Por ejemplo, se podrían ordenar los precios de más bajo a más alto, como hace https://www.apaga-luz.com/ Además, por la mañana, Tasker podría sacarnos un aviso indicando cuál es la mejor hora para poner la lavadora, excluyendo las horas en que duermo o que no estoy en casa; quizá convendría añadir al aviso la sugerencia de dejar la lavadora para el día siguiente si no hay ninguna hora conveniente con precio barato. También podría establecerse un precio máximo admisible, y un enchufe inteligente apagaría los radiadores eléctricos si el precio de la hora actual está por encima de ese máximo. Por el contrario, se podría elegir la hora más barata de la mañana y la hora más barata de la tarde para que Tasker encendiera el termo eléctrico esas dos horas concretas, y mantenerlo apagado el resto del día. Quien tenga patinete o coche eléctrico podrá elegir las mejores horas para recargarlo. Y más cosas similares, según la necesidad de cada uno.

Habrá que estudiar cómo puede Tasker transmitir las órdenes de encendido/apagado a los enchufes inteligentes; quizá a través de Google-home, Alexa u otros sistemas. Sobre este asunto no tengo ninguna experiencia ni idea de como abordarlo. Tal vez haya que investigar, estudiar y hacer pruebas. O puede que algún compañero aporte su conocimiento para avanzar más rápido.

Pero el primer problema es encontrar un sitio de donde obtener los precios de la electricidad y que esos datos tengan un formato fácil de manejar.

De momento he visto que los datos diarios (del día actual) se pueden consultar en
https://api.esios.ree.es/archives/70/download_json?locale=es
Por la URL deduzco que los datos están en formato JSON.
Hay un montón de datos para cada hora del día. Creo que el dato PCB es el precio para la Península, Canarias y Baleares; y el precio CYM supongo que sea para Ceuta Y Melilla, que tienen un precio especial, distinto en algunos momentos. No sé lo que hay en el resto de los datos, pero creo que carece de interés para este planteamiento.

La API que tiene Red Eléctrica ofrece muchas más opciones, pero no me aclaro y no sé si habrá alguna forma de mejorar la URL propuesta en el párrafo anterior.

Eso es todo por ahora. Espero que alguien más aporte ideas, sugerencias y propuestas porque insisto en que me gustaría que esto fuese un proyecto colectivo. Y si alguien se atreve a empezar con la tarea (la obtención de datos), pues genial.

[Dark_Tamahome]

Ya sabéis que el precio de la electricidad ha subido mucho. Y además nos marean porque cada hora tiene un precio distinto, sin que tenga validez alguna aquello que planteó el gobierno sobre los tramos "valle", "llano" y "punta". No sabemos a qué hora es razonable poner la lavadora o el radiador.

En la siguiente página de Red Eléctrica se puede ver una gráfica con los distintos precios que nos cobran, cada hora, por el consumo eléctrico. Se puede consultar el día actual, los días anteriores, y a partir de las 21 horas también se puede consultar el día siguiente.
https://www.esios.ree.es/es/pvpc

La propuesta es que Tasker obtenga esos datos para ayudarnos a gestionar mejor nuestros consumos eléctricos. Creo que este asunto puede interesar a más personas, y me gustaría que fuese un proyecto colectivo, no solo mío.

La idea de partida puede ser que Tasker consulte los precios cada día, a las 00:01, para hacer una tabla de 24 elementos, con el precio de cada hora. Luego ya iremos viendo la forma de gestionar óptimamente estos datos.

Por ejemplo, se podrían ordenar los precios de más bajo a más alto, como hace https://www.apaga-luz.com/ Además, por la mañana, Tasker podría sacarnos un aviso indicando cuál es la mejor hora para poner la lavadora, excluyendo las horas en que duermo o que no estoy en casa; quizá convendría añadir al aviso la sugerencia de dejar la lavadora para el día siguiente si no hay ninguna hora conveniente con precio barato. También podría establecerse un precio máximo admisible, y un enchufe inteligente apagaría los radiadores eléctricos si el precio de la hora actual está por encima de ese máximo. Por el contrario, se podría elegir la hora más barata de la mañana y la hora más barata de la tarde para que Tasker encendiera el termo eléctrico esas dos horas concretas, y mantenerlo apagado el resto del día. Quien tenga patinete o coche eléctrico podrá elegir las mejores horas para recargarlo. Y más cosas similares, según la necesidad de cada uno.

Habrá que estudiar cómo puede Tasker transmitir las órdenes de encendido/apagado a los enchufes inteligentes; quizá a través de Google-home, Alexa u otros sistemas. Sobre este asunto no tengo ninguna experiencia ni idea de como abordarlo. Tal vez haya que investigar, estudiar y hacer pruebas. O puede que algún compañero aporte su conocimiento para avanzar más rápido.

Pero el primer problema es encontrar un sitio de donde obtener los precios de la electricidad y que esos datos tengan un formato fácil de manejar.

De momento he visto que los datos diarios (del día actual) se pueden consultar en
https://api.esios.ree.es/archives/70/download_json?locale=es
Por la URL deduzco que los datos están en formato JSON.
Hay un montón de datos para cada hora del día. Creo que el dato PCB es el precio para la Península, Canarias y Baleares; y el precio CYM supongo que sea para Ceuta Y Melilla, que tienen un precio especial, distinto en algunos momentos. No sé lo que hay en el resto de los datos, pero creo que carece de interés para este planteamiento.

La API que tiene Red Eléctrica ofrece muchas más opciones, pero no me aclaro y no sé si habrá alguna forma de mejorar la URL propuesta en el párrafo anterior.

Eso es todo por ahora. Espero que alguien más aporte ideas, sugerencias y propuestas porque insisto en que me gustaría que esto fuese un proyecto colectivo. Y si alguien se atreve a empezar con la tarea (la obtención de datos), pues genial.


Muchas gracias, siempre va venir bien saber a cuantos nos clavan cada dia/hora xD

[Osconse]

Ya sabéis que el precio de la electricidad ha subido mucho. Y además nos marean porque cada hora tiene un precio distinto, sin que tenga validez alguna aquello que planteó el gobierno sobre los tramos "valle", "llano" y "punta". No sabemos a qué hora es razonable poner la lavadora o el radiador.

En la siguiente página de Red Eléctrica se puede ver una gráfica con los distintos precios que nos cobran, cada hora, por el consumo eléctrico. Se puede consultar el día actual, los días anteriores, y a partir de las 21 horas también se puede consultar el día siguiente.
https://www.esios.ree.es/es/pvpc

La propuesta es que Tasker obtenga esos datos para ayudarnos a gestionar mejor nuestros consumos eléctricos. Creo que este asunto puede interesar a más personas, y me gustaría que fuese un proyecto colectivo, no solo mío.

La idea de partida puede ser que Tasker consulte los precios cada día, a las 00:01, para hacer una tabla de 24 elementos, con el precio de cada hora. Luego ya iremos viendo la forma de gestionar óptimamente estos datos.

Por ejemplo, se podrían ordenar los precios de más bajo a más alto, como hace https://www.apaga-luz.com/ Además, por la mañana, Tasker podría sacarnos un aviso indicando cuál es la mejor hora para poner la lavadora, excluyendo las horas en que duermo o que no estoy en casa; quizá convendría añadir al aviso la sugerencia de dejar la lavadora para el día siguiente si no hay ninguna hora conveniente con precio barato. También podría establecerse un precio máximo admisible, y un enchufe inteligente apagaría los radiadores eléctricos si el precio de la hora actual está por encima de ese máximo. Por el contrario, se podría elegir la hora más barata de la mañana y la hora más barata de la tarde para que Tasker encendiera el termo eléctrico esas dos horas concretas, y mantenerlo apagado el resto del día. Quien tenga patinete o coche eléctrico podrá elegir las mejores horas para recargarlo. Y más cosas similares, según la necesidad de cada uno.

Habrá que estudiar cómo puede Tasker transmitir las órdenes de encendido/apagado a los enchufes inteligentes; quizá a través de Google-home, Alexa u otros sistemas. Sobre este asunto no tengo ninguna experiencia ni idea de como abordarlo. Tal vez haya que investigar, estudiar y hacer pruebas. O puede que algún compañero aporte su conocimiento para avanzar más rápido.

Pero el primer problema es encontrar un sitio de donde obtener los precios de la electricidad y que esos datos tengan un formato fácil de manejar.

De momento he visto que los datos diarios (del día actual) se pueden consultar en
https://api.esios.ree.es/archives/70/download_json?locale=es
Por la URL deduzco que los datos están en formato JSON.
Hay un montón de datos para cada hora del día. Creo que el dato PCB es el precio para la Península, Canarias y Baleares; y el precio CYM supongo que sea para Ceuta Y Melilla, que tienen un precio especial, distinto en algunos momentos. No sé lo que hay en el resto de los datos, pero creo que carece de interés para este planteamiento.

La API que tiene Red Eléctrica ofrece muchas más opciones, pero no me aclaro y no sé si habrá alguna forma de mejorar la URL propuesta en el párrafo anterior.

Eso es todo por ahora. Espero que alguien más aporte ideas, sugerencias y propuestas porque insisto en que me gustaría que esto fuese un proyecto colectivo. Y si alguien se atreve a empezar con la tarea (la obtención de datos), pues genial.

Hola Caravantes, cuanto tiempo.

Me encanta el proyecto propuesto pero a nivel de Tasker poco voy a poder aportar pero lo seguiré atentamente pues me interesa mucho ya que tengo vehículo eléctrico, patinete y placas solares y quiero que mi factura se reduzca al máximo mientras no haya producción solar.

Mientras tanto yo uso la app Redos de Red Eléctrica (
https://linksharing.samsungcloud.com/61wIr3TsVJKQ) aunque desde hace unas semanas funciona malamente y no carga los datos a la primera.

No vamos leyendo y gracias por la propuesta!!

[WillyWeb]

Un ejercicio muy interesante, pero aquí no se tira nadie a la piscina. :oh:


De momento he visto que los datos diarios (del día actual) se pueden consultar en
https://api.esios.ree.es/archives/70/download_json?locale=es
Por la URL deduzco que los datos están en formato JSON.


Sí, son datos JSON que se pueden ver más fácilmente usando sitios como este... https://codebeautify.org/jsonviewer

Cargarlos en Tasker tiene poca ciencia...

Acción: Solicitud HTTP
Método: GET
URL: la propuesta
Salida Estructurada: sí

Y sacar los datos es tan fácil como usar la nueva sintáxis para manejar estructuras JSON/HTML/XML...

%http_data[Campo](índice)

"%http_data" es el nombre de la variable predefinida para la acción
"[Campo]" es el nombre del campo que nos interesa (ojo a las mayúsculas si las tiene)
"(indice)" es el número de índice si ese campo aparece más de una vez

Con algo así ... %http_data[Hora] ... se sacaría el valor del primer campo "Hora" que aparezca en el JSON ... "00-01"

Y con algo como ... %http_data[Hora](3) ... sacaríamos el tercer "Hora" del JSON ... "02-03"

Recorrer todos los valores con un búcle es cosa de niños. ;-)


Creo que el dato PCB es el precio para la Península, Canarias y Baleares; y el precio CYM supongo que sea para Ceuta Y Melilla

Por lo que he visto en varios sitios supones bien, esos son los precios del MWh. Ojo que en casi todas partes lo ponen en kWh.

Venga. Yo ya he abierto el melón. Lo siguiente puede ser sacar el valor máximo y el mínimo, por ejemplo.

:palomitas:

[WillyWeb]

Parece que nadie se anima. :rolleyes:

SACAR EL PRECIO MÁXIMO Y MÍNIMO

Partimos de que los datos están en una "estructura", parecida a un array, que Tasker genera automáticamente al cargar el archivo JSON.


Solicitud HTTP
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es
Salida Estructurada: sí


El precio del MWh está almacenado en los campos "PCB" (para Península/Canarias/Baleares) y "CYM" (para Ceuta/Melilla). Elegir el campo adecuado es un pequeño reto muy fácil de resolver. :silbando:


Obtener Ubicación v2
%campo = CYM [SI %gl_latitude < 35.95 Y %gl_longitude > -5.60]
%campo = PCB [SI %campo INDEF]


Creo que eso no requiere muchas aclaraciones. Si estás más al sureste de Tarifa seguramente te interesa el campo CYM, en otro caso tu campo es PCB.

Y una vez decido el %campo que nos interesa los precios para cada hora del día estarán en el array ... %http_data[%campo]()

Para sacar el precio más alto y/o más bajo simplemente tenemos que recorrer ese array tomando nota de si el valor analizado es mayor o menor que el que tuviéramos anotado previamente.


%pmin=999
%pmax=0
PARA %pmwh EN %http_data[%campo]()
%pmin = %pmwh [SI %pmwh < %pmin]
%pmax = %pmwh [SI %pmwh > %pmax]
FIN PARA


Mostramos los resultados...

FLASH %campo Mín: %pmin Máx: %pmax

...y no funciona. :facepalm:

No es del planteamiento. No es de las acciones (salvando errores tipográficos). No es nada que esté a la vista. Y se soluciona con una acción. :silbando:

¿Alguien se lanza al ruedo? :palomitas:

[Caravantes]

SACAR EL PRECIO MÁXIMO Y MÍNIMO


Bueno, he añadido alguna cosita más, para generar un array con el precio de todas las horas, e ir visualizando resultados (parciales y finales)


Tarea: PrecioElectric
A1: Solicitud HTTP [
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es
Tiempo Límite (Segundos): 30
Structure Output (JSON, etc): Encendido ]

A2: Establecer Variable [
Nombre: %campo
A: PCB
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A3: Establecer Variable [
Nombre: %pmin
A: 999
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A4: Establecer Variable [
Nombre: %pmax
A: 0
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A5: Establecer Variable [
Nombre: %pmwh
A: 0
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A6: Establecer Variable [
Nombre: %hora
A: 0
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A7: Para (for) [
Variable: %pmwh
Ítems: %http_data[%campo]()
Structure Output (JSON, etc): Encendido ]

A8: Establecer Variable [ - Nombre: %pmin - A: %pmwh - Calcular: Encendido - Dígitos de Redondeo Máximos: 3 - Structure Output (JSON, etc): Encendido ]
Si (if) [ %pmwh < %pmin ]

A9: Establecer Variable [ - Nombre: %pmax - A: %pmwh - Calcular: Encendido - Dígitos de Redondeo Máximos: 3 - Structure Output (JSON, etc): Encendido ]
Si (if) [ %%pmwh > %pmax ]

A10: Insertar en Array [ - Matriz de Variables (array): %precio - Posición: 25 - Valor: %pmwh ]

A11: Flash [ - Texto: hora:%hora. Precio:%pmwh. Min:%pmin . Max:%pmax. ]
Si (if) [ %hora < 2 | %hora > 21 ]

A12: Sumar a Variable [ - Nombre: %hora - Valor: 1 - Enrollar (wrap around): 0 ]

A13: Fin Para (end for)

A14: Flash [
Texto: Elementos: %precio(#) - %precio()
Largo: Encendido ]

A15: Flash [
Texto: %campo Min:%pmin . Max:%pmax
Largo: Encendido ]
...y -efectivamente- no funciona.:facepalm:

He estado un rato dándole vueltas e incluso he inicializado la variable (en A5) pero sigue sin funcionar y no soy capaz de averiguar qué falla. :nusenuse:

[WillyWeb]

He estado un rato dándole vueltas e incluso he inicializado la variable (en A5) pero sigue sin funcionar y no soy capaz de averiguar qué falla. :nusenuse:

Pues es de locos. Los valores numéricos del JSON no son números ... ¿cómo te has quedado? :oh:

Lo que pasa realmente es que, para Tasker, el separador decimal es el punto y en el JSON se usa la coma. :rolleyes:

Solicitud HTTP
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es
Salida Estructurada: sí

Buscar y Reemplazar en Variable
Variable: %http_data
Buscar: (\d),(\d)
Reemplazar Con: $1.$2

Con esas dos acciones cargas el JSON y cambias todos sus valores numéricos para que Tasker los interprete adecuadamente.

Bueno, he añadido alguna cosita más, para generar un array con el precio de todas las horas...

Lo que recorres en el bucle es un array con el precio de todas las horas ... %http_data[%campo]()

:idea2:

Voy a proponer otra forma de encontrar los valores mínimo/máximo que tiene ventajas adicionales.

Establecer Array [ %pmwh = %http_data[%campo]() - Separador: ,]
Procesar Array [ %pmwh - Tipo: Orden Numérico, Coma Flotante ]
Establecer Variable [ %pmin = %pmwh(>) ]
Establecer Variable [ %pmax = %pmwh(<) ]

Sin bucle. Sin Comparaciones. Sin inicializar variables. Con menos acciones. Y ahora tenemos un array con los precios ordenados de menor a mayor.

Si ahora quieres una lista de los cuatro precios más bajos simplemente haces esto...

%pbajos = %pmwh(:4)

Genial, pero ¿a qué horas? :pensando:

[WillyWeb]

Es curioso que este tema ya tenga 300 lecturas y que nadie diga nada. :nusenuse:

:rolleyes: Terminaba yo mi soliloquio con esta pregunta retórica...

Genial, pero ¿a qué horas?

Existen varias soluciones dependiendo de lo que queramos hacer con la información. El propósito más simple sería mostrarla con una notificación o un flash, en cuyo caso necesitamos algo "legible" del tipo...

111.22 €/MWh de 01-02

Para eso simplemente tenemos que combinar los arrays de los precios y las horas de esta forma...

Arrays Merge
Nombres: %http_data[%campo] y %http_data[Hora] (cada uno en una línea)
Tipo: Simple
Esamblador: _€/MWh de_ (el _ es un espacio en blanco)
Salida: %pyh

Esa acción sustituye al "Establecer Arrary %pmwh" que usé antes, de forma que ese bloque ahora quedaría así...

Arrays Merge ... (lo de arriba)
Procesar Array [ %pyh - Tipo: Orden Numérico, Coma Flotante ]
Establecer Variable [ %pmin = %pyh(>) ]
Establecer Variable [ %pmax = %pyh(<) ]

Otra cosa relacionada con esta historia...

La otra tarde/noche, pasadas ya las 21:00, los datos que contenía el JSON llevaban fecha del día siguiente. Supongo que a esas horas se hacen públicas las nuevas tarifas y la URL que estamos usando descarga los últimos datos disponibles. El caso es que quería ver el precio de las últimas horas del día y ya no pude.

Eso se puede solucionar pasando un parámetro adicional en la URL que descarga los datos, tal que así...

https://api.esios.ree.es/archives/70/download_json?locale=es&date=aaaa-mm-dd

Y para el que se lo pregunte, ese formato de fecha (aaaa-mm-dd) es fácil de componer usando una acción "Parse/Format Date And Time".

¿Todo claro hasta aquí? :rolleyes:

Bueno. Pues llegados a este punto, y para que a Caravantes no le pegue un jamacuco (https://dle.rae.es/jamacuco) con tanto subir y bajar, voy a juntar todo lo que tenemos hasta el momento.

Parse/Format Date And Time
Tipo: Now
Output: yyyy-MM-dd
Variable: ymd
Offset: (jugar con sus valores)

Solicitud HTTP
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es&date=%ymd
Salida Estructurada: sí

Buscar y Reemplazar en Variable
Variable: %http_data
Buscar: (\d),(\d)
Reemplazar Con: $1.$2

Obtener Ubicación v2
%campo = CYM [SI %gl_latitude < 35.95 Y %gl_longitude > -5.60]
%campo = PCB [SI %campo INDEF]

Arrays Merge
Nombres: %http_data[%campo] y %http_data[Hora] (cada uno en una línea)
Tipo: Simple
Esamblador: _€/MWh de_ (el _ es un espacio en blanco)
Salida: %pyh

Procesar Array [ %pyh - Tipo: Orden Numérico, Coma Flotante ]
Establecer Variable [ %pmin = %pyh(>) ]
Establecer Variable [ %pmax = %pyh(<) ]

Flash [ %pmin ]

Eso nos muestra a qué hora tenemos el precio más bajo, pero un programa de lavado lo mismo necesita dos o tres horas, a ser posible a un precio que nos salga más rentable lavar que tirar la ropa sucia y renovar el armario.

¿Qué hacemos con eso? :palomitas:

[Caravantes]

Sin bucle. Sin Comparaciones. Sin inicializar variables. Con menos acciones. Y ahora tenemos un array con los precios ordenados de menor a mayor.

Pues parecía una buena idea pero creo que no funciona. (o yo me he equivocado en algún detalle)

A1: Solicitud HTTP [
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es
Tiempo Límite (Segundos): 30
Structure Output (JSON, etc): Encendido ]

A2: Establecer Variable [
Nombre: %campo
A: PCB
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A3: Establece Array [
Matriz de Variables (array): %pmwh
Valores: %http_data[%campo]()
Separador: , ]

A4: Flash [
Texto: Elementos: %pmwh(#) - %pmwh()
Largo: Encendido ]

A5: Procesar Array [
Matriz de Variables (array): %pmwh
Tipo: Orden Numérico, Coma-Flotante ]

A6: Establecer Variable [
Nombre: %pmin
A: %pmwh(>)
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A7: Establecer Variable [
Nombre: %pmax
A: %pmwh(<)
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A8: Flash [
Texto: Elementos: %pmwh(#) - %pmwh()
Largo: Encendido ]

A9: Flash [
Texto: %campo Min:%pmin . Max:%pmax
Largo: Encendido ]


El array se genera en la acción 3, y he insertado una acción 4 que muestra el número de elementos y luego el array completo, y resulta que el array tiene 48 elementos porque Tasker confunde el separador de elementos con las comas decimales que tienen los valores obtenidos.


1398205

Puesto que hay un valor que es 210,00 y tasker considera que eso son dos elementos del array, al final de la tarea resulta que el valor mínimo %pmin es 00. Y también resulta que el valor máximo %pmax es 316 (cuando debería ser 316,13).

Si ahora quieres una lista de los cuatro precios más bajos simplemente haces esto... %pbajos = %pmwh(:4) Genial, pero ¿a qué horas?

Yo había pensado un array de dos dimensiones, o (creo que lo prefiero) dos arrays, uno para las horas y otro para los precios; haría un bucle (con otro bucle interno) para ordenar los precios por el procedimiento clásico, pero si hay que intercambiar valores (porque están en el orden incorrecto), no solo intercambio los precios sino también las horas. De esta forma al final tengo un array con los precios ordenados y otro array paralelo con las horas correspondientes a esos precios. La hora que estuviera en primera posición sería la del precio más bajo y la última sería la del precio más caro.


Luego haría un segundo bucle para encontrar la hora más barata de la mañana (AM) y la hora más barata de la tarde (PM), tal como indiqué en el enunciado incial para encender el termo en esas dos horas (salvo que esas horas estén muy próximas (diferencia<6), en cuyo caso enciendo el termo solo una de ellas, la más barata). Sé que todo esto hace tareas muy largas, pero eso es algo que a mí nunca me ha preocupado; no soy bueno optimizando ni abreviando, por lo que suelo acabar con tareas largas, y no me importa porque funcionan y las entiendo.

Pero todos estos detalles posteriores siguen supeditados a que encontremos primero la forma de evitar la confusión entre comas decimales y separadores de array. En la acción 3 que genera el array he probado a poner como separador un punto y coma (;) y también he probado a poner un punto (.) pero tampoco sirve; en ambos casos la acción 4 me dice que el array obtenido tiene un solo elemento (muy largo). Por otro lado, puede haber una solución fácil porque mi tarea de ayer sí que terminaba con un array de 24 elementos.
1398204

[Caravantes]

Pues llegados a este punto, y para que a Caravantes no se le pegue un jamacuco con tanto subir y bajar, voy a juntar todo lo que tenemos hasta el momento.

Hola Willy. Estaba trabajando con tu penúltimo mensaje (construyendo la tarea y escribiendo la respuesta) mientras tu estabas publicando otro mensaje nuevo. Aunque he publicado mi respuesta después, no había leído ese último mensaje tuyo. Quedo pendiente de leer ese último mensaje tuyo, ahora no tengo tiempo.

[WillyWeb]

... resulta que el array tiene 48 elementos porque Tasker confunde el separador de elementos con las comas decimales que tienen los valores obtenidos.

Se te ha pasado esto...

Lo que pasa realmente es que, para Tasker, el separador decimal es el punto y en el JSON se usa la coma. :rolleyes:

Solicitud HTTP
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es
Salida Estructurada: sí

Buscar y Reemplazar en Variable
Variable: %http_data
Buscar: (\d),(\d)
Reemplazar Con: $1.$2

Con esas dos acciones cargas el JSON y cambias todos sus valores numéricos para que Tasker los interprete adecuadamente.

Si no haces eso, además del problema de la coma que ya te has encontrado, tampoco podrás procesar los datos adecuadamente.

Yo había pensado un array de dos dimensiones, o (creo que lo prefiero) dos arrays...

Como te comenté antes los datos que estás procesando ya están en un array que Tasker crea automáticamente a partir de la estructura del JSON. La única pega que le he encontrado a ese tipo de array/estructura es que no se puede modificar (es de solo-lectura) y tienes que hacer una copia en un array "normal" para poder ordenarlo, por ejemplo. De todas formas buena parte de todo ese planteamiento que haces se resuelve con una sola acción, como te cuento en el mensaje anterior.

Luego haría un segundo bucle para encontrar la hora más barata de la mañana (AM) y la hora más barata de la tarde (PM)...

Ese es un planteamiento muy interesante. :pensando:

Así, a bote pronto, se me ocurre partir el día en dos (PM y AM) y sacar el máximo/mínimo de cada una de las partes. Con el sistema que te he propuesto creo que eso se podría hacer con muy pocas acciones más.

Quedo pendiente de leer ese último mensaje tuyo, ahora no tengo tiempo.

Sin problema. Aquí te espero. :maburro:

[Caravantes]

Arrays Merge
Nombres: %http_data[%campo] y %http_data[Hora] (cada uno en una línea)
Tipo: Simple
Esamblador: _€/MWh de_ (el _ es un espacio en blanco)
Salida: %pyh

La leche, eso ha sido muy interesante. El

Flash Array de %pyh(#) elementos: %pyh()
me saca lo siguiente
1398396

Es fascinante, pero realmente lo veo poco práctico. Por ejemplo, con esa estructura no veo nada fácil ordenar por horas (AM/PM). Por otro lado, si lo que queremos es terminar sacando por pantalla un aviso del tipo "El mejor momento de poner la lavadora es a las 03 (precio 203.90 €/Mwh)" me parece más práctico componer y formatear ese texto en el momento de lanzar el aviso/flash/notificación, y no en el array; en los array creo preferible tener los datos de la forma más simple posible, para facilitar tareas como la ordenación por horas o bien tener una tabla/array en la que meto las horas en las que no estoy en casa (o estoy durmiendo) y la tarea debería ser capaz de descartar esas horas.

Establecer variable %nolavar a 00,01,02,03,04,05,06,07,08,09,10,11,12,13,14

Por otro lado, tengo un problema con la variable %pmin
1398397
Me sospecho que este problema está derivado precisamente de haber hecho el merge, juntando en cada elemento del array datos numéricos y texto. ¿o puede que yo me haya vuelto a equivocar en alguna otra cosa?


Tarea: PrecioElectric2

A1: Solicitud HTTP [
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es
Tiempo Límite (Segundos): 30
Structure Output (JSON, etc): Encendido ]

A2: Buscar y Reemplazar en Variable [
Variable: %http_data
Buscar: (\d),(\d)
Reemplazar Coincidencias: Encendido
Reemplazar Con: $1.$2 ]

A3: Establecer Variable [
Nombre: %campo
A: PCB
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A4: Arrays Merge [
Nombres: %http_data[%campo]
%http_data[Hora]
Merge Type: Simple
Ensamblador: €/MWh de
Salida: %pyh ]

A5: Procesar Array [
Matriz de Variables (array): %pyh
Tipo: Orden Numérico, Coma-Flotante ]

A6: Flash [
Texto: Array de %pyh(#) elementos:
%pyh()
Largo: Encendido ]

A7: Establecer Variable [
Nombre: %pmin
A: %pyh(>)
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A8: Establecer Variable [
Nombre: %pmax
A: %pyh(<)
Calcular: Encendido
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A9: Flash [
Texto: %campo Min:%pmin . Max:%pmax
Largo: Encendido ]

Así, a bote pronto, se me ocurre partir el día en dos (PM y AM) y sacar el máximo/mínimo de cada una de las partes. Con el sistema que te he propuesto creo que eso se podría hacer con muy pocas acciones más.


Pues explícanos cómo, porque yo creo que no sabría hacerlo sin un array independiente para las horas. Gracias por tu tiempo y tu sapiencia.

[WillyWeb]

Es fascinante, pero realmente lo veo poco práctico...

Hombre, no me digas eso, que casi te he resuelto esto ...

Yo había pensado un array de dos dimensiones, o (creo que lo prefiero) dos arrays, uno para las horas y otro para los precios; haría un bucle (con otro bucle interno) para ordenar los precios por el procedimiento clásico, pero si hay que intercambiar valores (porque están en el orden incorrecto), no solo intercambio los precios sino también las horas. De esta forma al final tengo un array con los precios ordenados y otro array paralelo con las horas correspondientes a esos precios. La hora que estuviera en primera posición sería la del precio más bajo y la última sería la del precio más caro.

... con dos acciones.

Solo te falta extraer los precios y las horas de %pyh() tirando de "Buscar y Reemplazar". Con una RegEx como \d\d\d\.\d\d deberían salir los precios y con \d\d-\d\d las horas. Y si afinas esa última un poco te quedas solo con la hora de inicio, que es la que parece que te interesa.

Por otro lado, tengo un problema con la variable %pmin

Es que tienes marcado "Calcular" en A7 y A8. :oh:

Pues explícanos cómo, porque yo creo que no sabría hacerlo sin un array independiente para las horas. Gracias por tu tiempo y tu sapiencia.

Cuando haces el "Arrays Merge" juntas los datos de las 24 horas porque estás tirando de %http_data[PCB]. La idea es separar previamente los datos de AM/PM y procesar cada parte por separado.

Establecer Array [ %pream con %http_data[PCB](1:12) y separador , ]
Establecer Array [ %horam con %http_data[Hora](1:12) y separador , ]
Array Merge [ %pream y %horam ensamblados con " de " unidos en %pyham]
Procesar Array [ %pyham Orden Numérico, Coma-Flotante ]

Establecer Array [ %prepm con %http_data[PCB](13:24) y separador , ]
Establecer Array [ %horpm con %http_data[Hora](13:24) y separador , ]
Array Merge [ %prepm y %horpm ensamblados con " de " unidos en %pyhpm]
Procesar Array [ %pyhpm Orden Numérico, Coma-Flotante ]

Eso debería funcionar. Prueba y me cuentas. :rolleyes:

Por cierto, si vas a usar siempre los datos PCB te puedes ahorrar la variable %campo y A3.

[Caravantes]

Hombre, no me digas eso, que casi te he resuelto esto

Uf. Creo que el problema es que estás tres peldaños por encima de mí y seguramente no soy capaz de entender todas las posibilidades que hay para seguir desarrollando lo que has propuesto hasta el momento. Por poner solo un ejemplo, tú dominas el asunto de las expresiones regulares, y yo no (es una de mis asignaturas pendientes); por ese tipo de cosas es por las que -algunas veces- no veo cómo continuar avanzando en lo que has propuesto. Pero valoro y agradezco lo que aportas, sobre todo porque así vamos aprendiendo. Cada vez que pones una expresión regular consulto en Internet para entenderla, porque no me conformo con una tarea que has hecho tú y que yo no entienda. También me pasa con el abanico de acciones de Tasker, que tú pareces dominar mejor que nadie y utilizas posibilidades que a mí no se me habrían ocurrido. Gracias nuevamente.

Es que tienes marcado "Calcular" en A7 y A8.

Vaya. Por el nombre de la variable (%pmin) supuse que era el precio mínimo, variable numérica. En la primera versión de la tarea, esa acción no daba problemas porque en el array solo había números. Ahora siendo un array alfanumérico no tiene sentido manener la casilla de CALCULAR. Arreglado, gracias.

Ya me había dado cuenta de que podía quitar la variable %campo. Inicialmente la había dejado por si se apuntaba al proyecto algún compañero de Ceuta y Melilla, pero parece claro que eso no está ocurriendo, y de todas formas tiene fácil sustituir PCB por CYM (en un solo sitio) o sea que tienes razón en que es mejor quitarlo.

Y sí, la tarea funciona perfectamente.
1398668

A1: Solicitud HTTP [
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es
Tiempo Límite (Segundos): 30
Structure Output (JSON, etc): Encendido ]

A2: Buscar y Reemplazar en Variable [
Variable: %http_data
Buscar: (\d),(\d)
Reemplazar Coincidencias: Encendido
Reemplazar Con: $1.$2 ]

A3: Arrays Merge [
Nombres: %http_data[PCB]
%http_data[Hora]
Merge Type: Simple
Ensamblador: €/MWh de
Salida: %pyh ]

A4: Procesar Array [
Matriz de Variables (array): %pyh
Tipo: Orden Numérico, Coma-Flotante ]

A5: Flash [
Texto: Array de %pyh(#) elementos:
%pyh()
Largo: Encendido ]

A6: Establecer Variable [
Nombre: %pmin
A: %pyh(>)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A7: Establecer Variable [
Nombre: %pmax
A: %pyh(<)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A8: Flash [
Texto: PCB Min:%pmin . Max:%pmax
Largo: Encendido ]

A9: Establece Array [
Matriz de Variables (array): %pream
Valores: %http_data[PCB](1:12)
Separador: , ]

A10: Establece Array [
Matriz de Variables (array): %horam
Valores: %http_data[Hora](1:12)
Separador: , ]

A11: Arrays Merge [
Nombres: %pream
%horam
Merge Type: Simple
Ensamblador: de
Salida: %pyham ]

A12: Procesar Array [
Matriz de Variables (array): %pyham
Tipo: Orden Numérico, Coma-Flotante ]

A13: Flash [
Texto: Array AM de %pyham(#) elementos:
%pyham()
Largo: Encendido ]

A14: Establece Array [
Matriz de Variables (array): %prepm
Valores: %http_data[PCB](13:24)
Separador: , ]

A15: Establece Array [
Matriz de Variables (array): %horpm
Valores: %http_data[Hora](13:24)
Separador: , ]

A16: Arrays Merge [
Nombres: %prepm
%horpm
Merge Type: Simple
Ensamblador: de
Salida: %pyhpm ]

A17: Procesar Array [
Matriz de Variables (array): %pyhpm
Tipo: Orden Numérico, Coma-Flotante ]

A18: Flash [
Texto: Array PM de %pyhpm(#) elementos:
%pyhpm()
Largo: Encendido ]

[WillyWeb]

Y sí, la tarea funciona perfectamente.

Pues me alegro. No lo había probado.

Cada vez que pones una expresión regular consulto en Internet para entenderla...

No eres el único. Me he leído esto docenas de veces...

Expresión regular - Wikipedia (https://es.wikipedia.org/wiki/Expresi%C3%B3n_regular)

Y hago pruebas, hasta que sale lo que quiero, en este otro sitio...

https://regex101.com/

También me pasa con el abanico de acciones de Tasker, que tú pareces dominar mejor que nadie y utilizas posibilidades que a mí no se me habrían ocurrido.

En su momento revisé TODAS las acciones de Tasker y procuré (no siempre pude) escribir una pequeña tarea de prueba para asegurarme de que había entendido su funcionamiento. Repito ese proceso cada vez que João añade una nueva acción. Gracias a eso creo que llego a usar casi la mitad de las posibilidades de Tasker.

Ahora siendo un array alfanumérico no tiene sentido mantener la casilla de CALCULAR.

La casilla solo se debe marcar si el valor que se quiere asignar a la variable tiene que salir de evaluar matemáticamente lo que se ponga en el campo "A". En cualquier otro caso puede dar resultados no deseables, como esta vez.

RECAPITULEMOS...


Podemos leer el JSON y ajustar sus valores numéricos para que Tasker los interprete adecuadamente.
Hemos dado con un sistema simple y rápido de ordenar "en paralelo" dos arrays (precios y horas).
Podemos hacer el proceso anterior para las 24 horas, los tramos AM/PM, o cualquier otro periodo de horas.
Podemos sacar fácilmente el precio/hora más bajo ... %pyh(>) %pyhpm(>) %pyham(>).
Y también podemos sacar los X precios/horas más bajos de cualquiera de esos tramos.


Me ha parecido entender que ahora quieres ordenar esas X horas, pero antes las tienes que sacar del sitio en el que están "encajadas" ... nnn.nn de hh-hh ... y no ves claro cómo hacerlo.

:pensando:

Una vez ordenados "en paralelo" los precios/horas de uno de los tramos horarios (pongamos que el AM) sacamos las X horas (pongamos que 4) más baratas así...

%pyhamb = %pyham(:4)

Creo que si luego hacemos esto...

Concatenar Variable [ %pyhamb ]
Buscar y Reemplazar [ \d\d-\d\d en %pyhamb y almacenar en %horamb ]
Ordenar [ %horamb en Orden Numérico, Enteros ]

...ya lo tendríamos.

:palomitas:

[Caravantes]

Hola.
Perdón por el retraso en responder, por causa de obligaciones familiares y otros asuntos sociales. Sigamos.

RECAPITULEMOS... Podemos leer el JSON y ajustar sus valores numéricos para que Tasker los interprete adecuadamente. Hemos dado con un sistema simple y rápido de ordenar "en paralelo" dos arrays (precios y horas). Podemos hacer el proceso anterior para las 24 horas, los tramos AM/PM, o cualquier otro periodo de horas. Podemos sacar fácilmente el precio/hora más bajo ... %pyh(>) %pyhpm(>) %pyham(>). Y también podemos sacar los X precios/horas más bajos de cualquiera de esos tramos.


Creo que sí, que voy entendiendo todo eso.

Me ha parecido entender que ahora quieres ordenar esas X horas, pero antes las tienes que sacar del sitio en el que están "encajadas" ... nnn.nn de hh-hh ... y no ves claro cómo hacerlo.
Una vez ordenados "en paralelo" los precios/horas de uno de los tramos horarios (pongamos que el AM) sacamos las X horas (pongamos que 4) más baratas así...
%pyhamb = %pyham(:4)
Creo que si luego hacemos esto...
Concatenar Variable [ %pyhamb ]
...



Paremos aquí porque eso último (en negrita) ya no me ha funcionado. Le he añadido a la tarea las acciones siguientes:


A19: Establecer Variable [
Nombre: %pyhamb
A: %pyham(:4)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]
A20: Flash [
Texto: pyhamb=%pyhamb
Largo: Encendido ]
A21: Concatenar Variable [
Nombre: %pyhamb ]
A22: Flash [
Texto: pyhamb=%pyhamb
Largo: Encendido ]He comprobado que %pyham(:4) sí contiene los cuatro valores más bajos del array, y en A19 esos cuatro valores son traspasados a la variable %pyhamb
A20 me muestra el contenido de esa variable, ok
1399592

Tras Concatenar Variable [ %pyhamb ]
A22 me vuelve a mostrar el contenido de esa variable, y ahí es donde ya no funciona
1399593

Realmente no entiendo la acción A21: Concatenar Variable [ %pyhamb ]
Yo pensaba que la acción concatenar sirve para "unir" varios elementos de un array, pero aquí %pyhamb no es un array, según creo, y por eso no funciona.
O me estoy despistando en otra cosa?

[WillyWeb]

No te funciona porque te has comido la parte importante...

Buscar y Reemplazar [ \d\d-\d\d en %pyhamb y almacenar en %horamb ]

Eso genera el array que echas en falta y que solo contiene las horas.

[Caravantes]

No te funciona porque te has comido la parte importante...

Buscar y Reemplazar [ \d\d-\d\d en %pyhamb y almacenar en %horamb ]



Creo que ese no es el problema.
Como he comentado en mi mensaje anterior (y mostrando los flash), la acción de
Concatenar Variable [ %pyhamb ]
deja vacía (limpia) esa variable %pyhamb
Y eso me parecía suficiente problema para no continuar.

La acción que propones como continuación
Buscar y Reemplazar [ \d\d-\d\d en %pyhamb y almacenar en %horamb ]
da un error porque la variable %pyhamb no está definida. O al menos eso es lo que yo interpreto. Por si no se lee bien la imagen, el texto en amarillo dice
"Buscar y Reemplazar en Variable: undefined variable: %pyhamb"

1399781



A19: Establecer Variable [
Nombre: %pyhamb
A: %pyham(:4)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]
A20: Flash [
Texto: pyhamb=%pyhamb
Largo: Encendido ]
A21: Concatenar Variable [
Nombre: %pyhamb ]
A22: Buscar y Reemplazar en Variable [
Variable: %pyhamb
Buscar: \d\d-\d\d
Almacenar Coincidencias En Array: %horamb ]
A23: Flash [
Texto: pyhamb=%pyhamb
Largo: Encendido ]

[WillyWeb]

:facepalm:

Vale, ya he visto en qué la he cagado. El resultado de esto... %pyham(:4) ...no es un array. Ya es una lista de valores concatenados. No te habías despistado.

Si quitas A21 (la acción de concatenar) debería funcionar, pero para verlo tendrás que cambiar el flash de A23 así... horamb=%horamb

Perdona por darte indicaciones incorrectas. :(

[Caravantes]

Vale, ya he visto en qué la he cagado. El resultado de esto... %pyham(:4) ...no es un array. Ya es una lista de valores concatenados.



Un array y una variable de valores concatenados tienen el mismo aspecto, así que no me sorprende nada que también te puedas haber confundido en la composición mental.
Y no te disculpes porque solo se equivoca el que hace cosas.
La cuestión es que ya funciona, tenemos la lista de las 4 horas más baratas en horario AM.
1399822


A19: Establecer Variable [
Nombre: %pyhamb
A: %pyham(:4)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A20: Flash [
Texto: pyhamb=%pyhamb
Largo: Encendido ]

A21: Buscar y Reemplazar en Variable [
Variable: %pyhamb
Buscar: \d\d-\d\d
Almacenar Coincidencias En Array: %horamb ]

A22: Procesar Array [
Matriz de Variables (array): %horamb
Tipo: Orden Numérico, Enteros ]

A23: Flash [
Texto: horamb=%horamb()
Largo: Encendido ]

Por similar procedimiento se podrían obtener la lista de x horas más baratas en AM, PM o en el conjunto de las 24 horas.
Esto soluciona uno de los objetivos iniciales que yo había planteado: elegir la hora más barata de AM y de PM para encender el termo eléctrico, que quedaría apagado las otras 22 horas (el agua se mantiene caliente muchas horas, no hay problema, lo tengo comprobado).


Nos queda pendiente el tema de averiguar cómo hacemos que Tasker active y desactive un enchufe inteligente, asunto sobre el que no tengo ni repajolera idea, pero creo que hay páginas que dan algunas pistas, como por ejemplo
https://eshome.es/controla-home-assistant-con-tasker/
De este asunto ya empezamos a hablar en 2017 pero desde entonces estos inventos han cambiado mucho.
https://www.htcmania.com/showthread.php?t=1280843



Volviendo a las horas, hemos dividido la jornada en dos tramos (AM-PM) pero igualmente se podría dividir en cuatro tramos o en los que se quiera, según las necesidades de cada uno. Incluso es posible hacer tramos desiguales (asimétricos), sin problema.



Creo que falta añadir un detalle de cierta importancia, según mi planteamiento inicial:
Supongamos que hay ciertas horas en las que no voy a estar en casa, o voy a estar durmiendo. Es claro que en esas horas no voy a poner la lavadora, aunque sean las horas baratas. La tarea debería ser capaz de decirme la hora más barata que esté en mi lista de horas operativas para lavar. Como ya dije hace unos días, se podría hacer mediante algo así

A) Establecer variable %nuncalavar a 00,01,02,03,04,05,06,07,08,09,10,11,12,13,14

O todo lo contrario
B) Establecer variable %puedelavar a 15,16,17,18,19,20,21,22,23

Y ahora viene lo difícil, que es encontrar la hora más barata que encaje con una limitación de horarios de ese tipo.
Lo veo igual de complidado por el método A que por el B. No es difícil, pero sí es un poco tedioso. Yo haría dos bucles anidados para ir viendo si la hora más barata es válida para cada una de las horas de mi horario; en caso contrario habría que probar con la segunda hora más barata, etc, hasta encontrar con una hora "barata" que encaje en mi horario. Calculo que eso me conlleva unas 20 acciones.
Pero supongo que Willy y su magia son capaces de abreviar el asunto. ¿no?

[WillyWeb]

Creo que lo puedes hacer con muchas menos de 20 acciones. :pensando:

Sin meditarlo mucho (posible cagada)...


Generas un array con las horas a evitar (%evitarhoras)
Recorres ese array eliminando del array "paralelo" las posiciones que coincidan con cada hora+1. Me explico: si quieres evitar las 00 (tramo 00-01), en el array paralelo eso está en la posición 1=00+1.
Y luego sigues todo el proceso que ya tienes controlado.


Si no la he vuelto a cagar eso son cuatro/cinco acciones. :silbando:

La pega que veo es que luego no podrás partir fácilmente ese array paralelo por una hora concreta. La solución; :pensando: deja que lo piense un rato.

[WillyWeb]

Me puese al tema unas horas después de soltar mi idea inicial pero no llegué a contar mis avances. :D

La historia comenzó descargando el JSON. Arreglando el temas de las comas. Y usando "Array Merge" para conseguir ese array "paralelo" (%pyh) de 24 elementos (uno por hora) con la forma "xxx.xx €/MWh de hh-hh" o similar.

Lo siguiente que hicimos fue ordenar ese array para facilitar la localización de los mejores precios/horas, pero antes vamos a evitar momentos poco convenientes por el motivo que sea (ausencia, siesta, etc).

MÉTODO 1

Establecer Array [ %evitar=12,03,04,02 y separador=, ]
Procesar Array [ %evitar Orden Alfabético Inverso ]
Para [ %pos en %evitar() ]
Sacar de Array [ %pyh el elemento %pos ]
Fin Para

Este método requiere que las horas se escriban con dos dígitos para que sean ordenables alfabéticamente. ¿Y por qué ese ordenamiento? Pues para evitar un pequeño contratiempo que me he encontrado al eliminar los elementos del array. :rolleyes:

Supongamos que en la siguiente lista queremos eliminar los elementos 01 y 02...

123.45 de 01-02 <
234.56 de 02-03 <
345.67 de 03-04
456.78 de 04-05

Al quitar el 01 la lista queda así..

234.56 de 02-03
345.67 de 03-04 <
456.78 de 04-05

Y como se puede observar el 02 ya no es el mismo de antes. :oh:

Eso lo evitamos quitando los elementos en orden inverso (desde abajo). Espero que se entienda. :loco:

Otro acercamiento sería establecer las horas que nos %valen en lugar de las que queremos %evitar.

MÉTODO 2

Establecer Variable [ %valen=12,3,4,2 ]
Establecer Array [ %pyh=%pyh(%valen) y seperador=, ]

Mucho más rápido y simple. No es necesario escribir las horas de ninguna forma especial ni ordenarlas. Y solo se usan dos acciones. :silbando:

¿Tema resuelto?

Pues no. Ambos métodos tienen un pequeño fallo cuya detección y reparación dejo en vuestras manos. Pero vamos, que tampoco es imprescindible. :palomitas:

[Caravantes]

Estoy pendiente de continuar con la tarea del hilo en cuanto pueda; la pelota está en mi tejado.

Pero de momento os cuento otra cosa relacionada.
Un amigo tiene una casa con un termo eléctrico. La casa no tiene Wifi y por diferentes motivos no resulta oportuno hacer enlace desde el smartphone ni otras maniobras. O sea que no hay posibilidad de poner un enchufe "inteligente" con Wifi ni nada similar. Hay que buscar una solución más sencilla.

Hemos comprado un programador horario para que el termo solo esté encendido uno o dos ratos al día, en los momentos en que la electricidad suele tener precios normalmente bajos.
En la página
https://www.esios.ree.es/es/pvpc
he consultado los precios de la electricidad de los últimos 30 días. He anotado en una hoja de cálculo cuáles han sido las horas que me han parecido significativamente baratas de cada madrugada-mañana (AM) y de cada tarde-noche (PM). Luego he aplicado una suma para saber cuáles horas han sido las más ventajosas, en promedio mensual. En AM (y en el total diario de 24 horas), la hora de electricidad más barata suele ser de 4 a 5, seguida por poca diferencia de 3 a 4. En PM la hora más barata suele ser de 15 a 16.
1401407
De momento vamos a programar para que el termo reciba electricidad de 4 a 5 y de 15 a 15:20. Con el uso habrá que ir viendo si ese plan es adecuado.
Si ocurre más de un día que en algún rato se acaba el agua caliente habrá que ampliar el horario de carga eléctrica y/o subir la temperatura del termo, que es regulable -hasta 80 grados máximo- y de momento está configurado solo a 70 grados.
Por el contrario, si ocurre que pasan las semanas y en todo momento hay agua caliente de sobra se podría probar a reducir el horario de carga eléctrica y/o bajar la temperatura del termo; bajar la temperatura del termo significaría que el agua alcanza la temperatura prevista en menos tiempo y entonces deja de calentar, por lo que también habrá menos consumo eléctrico.
Según el manual del termo, los 80 grados (el máximo) suelen alcanzarse tras hora y media, aunque eso también depende de la temperatura del agua de entrada; en función de esa referencia, me ha parecido oportuno programar una hora y veinte minutos para llegar a 70 grados.

Se agradecen comentarios y opiniones si alguien tiene una idea que pueda mejorar el planteamiento descrito.

Cuento todo esto de forma detallada porque lo ideal sería que nuestra tarea Tasker hiciese algo similiar (dar corriente a un termo eléctrico en ciertos ratos, por medio de un enchufe inteligente conectado a Internet), pero adaptándose cada día a las horas en que los precios sean más baratos, que como se ha visto en la tabla anterior, no siempre son las mismas horas.

[WillyWeb]

Estoy pendiente de continuar con la tarea del hilo en cuanto pueda; la pelota está en mi tejado.

Ese es mi chico. :ok:

Se agradecen comentarios y opiniones si alguien tiene una idea que pueda mejorar el planteamiento descrito.

A poco de empezar este proyecto estuve trasteando en las estadísticas de esa web que mencionas y no fui capaz de encontrar algo equivalente a la hoja de cálculo que te has fabricado. Tampoco busqué con demasiado ahínco ya que me pareció más entretenido sacar esos datos con una tarea.

Establecer Array [ %mejor = 24 elementos a 0 ]
Para [ %offset 0:-6 ]
Parse/Format Date And Time [ Tipo: Now Output: yyyy-MM-dd Variable: ymd Offset: Días = %offset ]
Solicitud HTTP [ https://api.esios.ree.es/archives/70/download_json?locale=es&date=%ymd ]
Buscar y Reemplazar en Variable [ Variable: %http_data Buscar: (\d),(\d) Reemplazar Con: $1.$2 ]
Arrays Merge [ Entrada: %http_data[PCB] de %http_data[Hora] Salida: %pyh ]
Procesar Array [ %pyh Tipo: Orden Numérico, Coma-Flotante ]

Para [ %ind 1:3 ]
Buscar y Reemplazar en Variable [ Variable: %pyh(%ind) Buscar: \d\d$ Almacenar en Array: %hhh ]
Sumar a Variable [ %mejor(%hhh1) +1 ]
Fin Para
Fin Para
Flash [ %mejor() ]

Eso cuenta qué horas han sido las más baratas durante la última semana. Lo explico...


Creamos un array de 24 elementos (uno por hora) inicializados a 0 para ir contando cada vez que esa "hora" es la más barata.
Iniciamos un bucle para recorrer días desde hoy (%offset=0) hacia atrás (%offset=-6).
Con la acción "Parse/Format Date" sacamos la fecha correspondiente a hoy-%offset en el formato que requiere el API.
Descargamos los datos.
Cambiamos las comas por puntos en los valores numéricos.
Creamos el famoso array "paralelo" con precios y horas.
Y lo ordenamos por precio (recuerdo que los elementos tienen la forma "ppp.pp de hh-hh").

-Ahora vamos a anotar las tres mejores horas de ese día.
Con un bucle de 1 a 3.
Extraemos los dos últimos dígitos del elemento %pyh(%ind) (ahora aclaro esto).
Sumamos 1 a esa hora %mejor que acabamos de extraer.
Fin de los bucles.
Mostramos el contenido del array %mejor()


La aclaración...

Recuerda que en los datos que descargamos la primera hora (00-01) está en el elemento 1 del array, la segunda (01-02) está en el 2... y así sucesivamente. Ya te habrás dado cuenta de que el segundo número de esa pareja equivale al índice del array en el que está guardado el valor. Al ir incrementando el contenido de ese índice estaremos contando las veces que esa hora es la mejor. Y si al final el valor más alto está en el índice 5 eso querrá decir que la mejor hora es de 04-05.

Dime que lo has entendido. No soy capaz de explicarlo más claro con menos palabras. :loco:

Un par de cositas más...

Me he dado cuenta de que al retroceder en el tiempo la segunda mejor hora va cambiando. Eso me hace pensar que no es buena idea analizar mucho más de una semana para no desvirtuar la estimación.

En mis pruebas me encontré con que algunas veces aparecen "empates" que, aunque pueden hacer pensar que las horas señaladas son igual de buenas, resulta que se dan como consecuencia de que una es tantas veces tercera como otra segunda. Ese error se puede "mitigar" dando un peso diferente a cada posición cambiando el +1 de la acción "Sumar a Variable" por esto otro... 4-%ind

Cuento todo esto de forma detallada porque lo ideal sería que nuestra tarea Tasker hiciese algo similar (dar corriente a un termo eléctrico en ciertos ratos, por medio de un enchufe inteligente conectado a Internet), pero adaptándose cada día a las horas en que los precios sean más baratos, que como se ha visto en la tabla anterior, no siempre son las mismas horas.

Sí. Ese era el objetivo final. Y de momento creo que vamos bien. :rolleyes:

[Caravantes]

Dime que lo has entendido. No soy capaz de explicarlo más claro con menos palabras.


Perfectamente explicado y entendido. Muchas gracias.
Yo también había pensado que una tarea Tasker podría hacer esto. De hecho, creo recordar que en algún otro hilo se hablaba de una tarea Tasker que directamente iba generando una hoja de cálculo en drive (aunque igualmente me sirve generar un fichero TXT local con los valores separados por punto-y-coma; luego es bien fácil convertir eso a Excel), pero pensé que una tarea de ese tipo terminaría liándome más tiempo que hacer la tabla a mano, como lo he hecho, que me ha llevado solo unos 15 minutos.

[cace0353]

Hola a todos! Después de dos años de un casi abandono del foro (que no de Tasker pues alguna cosilla he hecho) entré la semana pasada y me interesó el tema propuesto. Me lo leí de cabo a rabo y copié el código colgado por Caravantes en el post #14. Funcionaba!

A partir de él empecé a elaborar mi propio proyecto para conseguir que el programa me proporcionara datos y opciones para elegir en que horas era más favorable poner en marcha los grandes consumidores domésticos. Todo ello a partir de una escena en 2400x1080 cuyo enlace al xml es: https://pastebin.com/9KnAQxpd

De entrada, y a la vista de lo que se ha propuesto, detecto dos maneras de enfocar el tema:

1.- Obtener una hora u horas que habitualmente són más baratas para ajustar un programador al que se enchufe el aparato en cuestión. He visto dos opciones de hacerlo un par de post más arriba y creo que esto acabaria aquí ya que no hay una gestión contínua de los datos. Aparte de esto me permito dos observaciones: a) en ocasiones hay cortes de luz (al menos donde yo vivo) y la programación queda "desplazada" con el peligro de que el desplazamiento horario nos llevara a un horario "caro". b) Los sábados y domingos acostumbran a ser más "baratos" y por tanto lo ideal sería recurrir a un programador diario de 7 dias alimentado con bateria recargable desde el propio enchufe (bastante más caros).

2.- Que el programa nos proporcione las mejores horas en un rango especificado configurable (p.e. de 8 a 24 ó incluso total de 0 a 24) de manera que seleccionemos manualmente las horas (o pareja de horas consecutivas por si el ciclo de utilización es más largo) y nos establezca un perfil con una alarma para avisarnos. Más adelante, una vez encontrado el procedimiento para activar el enchufe por WiFi, seria fácil modificar el mismo perfil para que iniciara la conexión de la base automáticamente.

Este és, pués, el código basado en el que he referido, notablemente ampliado para las nuevas prestaciones y que incorpora las siguientes funciones:

- El dia cuyos datos se muestran en el recuadro de encabezamiento y los precios máximo y mínimo del dia.
- Mostrar los precios para las 24 horas ordenados por horas en una lista a la izquierda de la pantalla y en la que se han oscurecido las horas transcurridas (una pijadilla...).
- Mostrar en un recuadro el precio/hora actual y la posición o "ranking" en la relación de precios ordenados de menor a mayor. El color de fondo (verde, amarillo, rojo) se corrresponde con el "ranking".
- Selección del horario hábil para el que se mostrarán los resultados ordenados por precio.
- Mostrar la lista ordenada por precios de las horas en el horario seleccionado en un menú "scrollable"
- Mostrar la pareja de horas consecutivas con un precio más favorable (recuadro indicado 2H).
- Seleccionar dos alarmas pulsando en el recuadro correspondiente: una para 1 hora y otra para 2 horas. Estas alarmas se indican al lado del icono del reloj. Pueden eliminarse con una pulsación larga sobre la hora.
- Cambiar, a partir de las 21 h. entre mostrar los precios para hoy y para mañana pulsando sobre el icono de actualizar que está programado como conmutador continuo.

El código que adjunto en formato texto está bastante comentado pero en catalán. No creo que suponga un problema. Los nombres de variables del código original se han mantenido.

Tarea: Gestio Tarifes

<Obtenim la data d'avui %data_consulta en format "yyyy-MM-dd">
A1: Parse/Format DateTime [
Tipo de Entrada: Now (Current Date And Time)
Output Format: yyyy-MM-dd
Formatted Variable Names: %data_consulta
Output Offset Type: Ninguno
Continuar Tarea Tras Error:Encendido ]
Si (if) [ %data_consulta ~ %* ]

A2: Solicitud HTTP [
Método: GET
URL: https://api.esios.ree.es/archives/70/download_json?locale=es&date=%data_consulta
Tiempo Límite (Segundos): 30
Structure Output (JSON, etc): Encendido ]

A3: Buscar y Reemplazar en Variable [
Variable: %http_data
Buscar: (\d),(\d)
Reemplazar Coincidencias: Encendido
Reemplazar Con: $1.$2 ]

A4: Si (if) [ %Prima ~ %* ]

A5: Establecer Variable [
Nombre: %Prima
A: 8
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A6: Establecer Variable [
Nombre: %Nona
A: 24
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A7: Fin Si (end if)

A8: Establecer Variable [
Nombre: %hora
A: %TIME
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A9: Separar Variable [
Nombre: %hora
Separador: . ]

A10: Establecer Variable [
Nombre: %hora
A: %hora1
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A11: JavaScriptlet [
Código: var verd = "#FF005A29";
var vermell = "#92FF0000";
var color = "#FFEF9013";
Salida Automática: Encendido
Tiempo Límite (Segundos): 45 ]

<Obtenim la data actual %avui_barres en format "dd/MM/yyyy">
A12: Parse/Format DateTime [
Tipo de Entrada: Now (Current Date And Time)
Output Format: dd/MM/yyyy
Formatted Variable Names: %avui_barres
Output Offset Type: Ninguno
Continuar Tarea Tras Error:Encendido ]

<Obtenim la data de la consulta feta en format "dd/MM/yyyy">
A13: Establecer Variable [
Nombre: %dia_barres
A: %http_data[Dia](1)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

<Fem que %pyh sigui la matriu amb els preus per les 24 hores del dia i després els ordenem per PREU…>
A14: Arrays Merge [
Nombres: %http_data[PCB]
%http_data[Hora]
Merge Type: Simple
Ensamblador: de
Salida: %pyh ]

A15: Procesar Array [
Matriz de Variables (array): %pyh
Tipo: Orden Numérico, Coma-Flotante ]

<Matriu amb tots els preus i hores ordenats per HORES tal com surten del JSON per mostrar-les a la columna de l'esquerra…>
A16: Arrays Merge [
Nombres: %http_data[PCB]
%http_data[Hora]
Merge Type: Simple
Ensamblador: €/MWh de
Salida: %total ]

<Per veure les hores ja passades i mostrar-les en un menú enfosquit sobreposat i només si la data es avui…>
A17: Establece Array [
Matriz de Variables (array): %passades
Valores: %total(:%hora)
Separador: , ]
Si (if) [ %hora > 0 & %dia_barres ig %avui_barres ]

<Calcular els preus màxim i mínim del dia…>
A18: Establecer Variable [
Nombre: %pmax
A: %pyh(<)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A19: Establecer Variable [
Nombre: %pmin
A: %pyh(>)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

<Si ja ha passat la primera hora fixada inicia la llista ordenada d'hores més barates a partir l'hora %prima…>
A20: Si (if) [ %hora > %Prima & %dia_barres ig %avui_barres ]

A21: Establecer Variable [
Nombre: %prima
A: %hora+1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

A22: En Otro Caso (else)

A23: Establecer Variable [
Nombre: %prima
A: %Prima+1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

A24: Fin Si (end if)

<Matriu de PREUS per les hores seleccionades de %Prima a %Nona…>
A25: Establece Array [
Matriz de Variables (array): %pre_pers
Valores: %http_data[PCB](%prima:%Nona)
Separador: , ]

<Matriu de les HORES seleccionades…>
A26: Establece Array [
Matriz de Variables (array): %hora_pers
Valores: %http_data[Hora](%prima:%Nona)
Separador: , ]

A27: Arrays Merge [
Nombres: %pre_pers
%hora_pers
Merge Type: Simple
Ensamblador: de
Salida: %seleccio ]

<Ordena la llista de Preu/hora des de l'hora actual fins l'hora %Nona…>
A28: Procesar Array [
Matriz de Variables (array): %seleccio
Tipo: Orden Numérico, Coma-Flotante ]

A29: Establecer Variable [
Nombre: %result
A: - - - -
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]
Si (if) [ %result ~ %* ]

<------------------------- INICI Determinació DUPLA hores més barates>
A30: Ancla

A31: Establecer Variable [
Nombre: %limit
A: %Nona-1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

<Salta la determinació de la DUPLA d'hores si només en queda una….>
A32: Ir A [
Tipo: Etiqueta de Acción
Etiqueta: ---------------------------- FINAL Determinació dues hores més barates ]
Si (if) [ %seleccio(#) ~ 1 ]

A33: Si (if) [ %hora < %limit | %dia_barres !~ %avui_barres ]

A34: Establecer Variable [
Nombre: %penult
A: %seleccio(#)-1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

A35: Establecer Variable [
Nombre: %minim
A: 999.99
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A36: Para (for) [
Variable: %pri
Ítems: 1:%penult
Structure Output (JSON, etc): Encendido ]

A37: Establecer Variable [
Nombre: %seg
A: %pri+1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

A38: Sección de Variable [
Nombre: %seleccio(%pri)
De: 1
Longitud: 6
Encajar: Encendido
Almacenar Resultado En: %primera ]

A39: Sección de Variable [
Nombre: %seleccio(%seg)
De: 1
Longitud: 6
Encajar: Encendido
Almacenar Resultado En: %segona ]

A40: Establecer Variable [
Nombre: %suma
A: %primera+%segona
Calcular: Encendido
Dígitos de Redondeo Máximos: 2
Structure Output (JSON, etc): Encendido ]

A41: Si (if) [ %suma < %minim ]

A42: Establecer Variable [
Nombre: %minim
A: %suma
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A43: Establecer Variable [
Nombre: %result
A: %seleccio(%pri)
%seleccio(%seg)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A44: Establecer Variable [
Nombre: %hora_inici
A: %seleccio(%pri)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A45: Separar Variable [
Nombre: %hora_inici
Separador: de ]

A46: Separar Variable [
Nombre: %hora_inici2
Separador: - ]

A47: Fin Si (end if)

A48: Fin Para (end for)

A49: Establecer Variable [
Nombre: %hora_inici
A: %hora_inici21:00
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A50: Fin Si (end if)

<---------------------------- FINAL Determinació dues hores més barates>
A51: Ancla

<Cerca el preu de l'hora actual…>
A52: Para (for) [
Variable: %cont
Ítems: 0:24
Structure Output (JSON, etc): Encendido ]

A53: Si (if) [ %pyh(%cont) ~ * de %hora-* ]

A54: Establecer Variable [
Nombre: %valor_actual
A: %pyh(%cont)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A55: Separar Variable [
Nombre: %valor_actual
Separador: de ]

A56: Establecer Variable [
Nombre: %preu_actual
A: %valor_actual1
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A57: Establecer Variable [
Nombre: %hora_actual
A: %valor_actual2
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

<surt del bucle per poder posar %cont com a valor del ranking d'hores mes barates….>
A58: Ir A [
Tipo: Etiqueta de Acción
Etiqueta: Hora trobada ]

A59: Fin Si (end if)

A60: Fin Para (end for)

<Hora trobada>
A61: Ancla

A62: Establecer Variable [
Nombre: %color
A: %verd
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]
Si (if) [ %cont < 9 ]

A63: Establecer Variable [
Nombre: %color
A: %vermell
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]
Si (if) [ %cont > 16 ]

A64: Establecer Variable [
Nombre: %Alarma1
A: - -
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]
Si (if) [ %Alarma1 ~ %* ]

A65: Establecer Variable [
Nombre: %Alarma2
A: - -
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]
Si (if) [ %Alarma2 ~ %* ]

A66: Destruir Escena [
Nombre: Q_ELECT
Continuar Tarea Tras Error:Encendido ]

A67: Mostrar Escena [
Nombre: Q_ELECT
Mostrar Como: Diálogo, Fondo Muy Oscurecido
Posición Horizontal: 100
Posición Vertical: 100
Animación: Derecha
Continuar Tarea Inmediatamente: Encendido
Allow Outside Boundaries: Encendido
Blocking Overlay +: Encendido
Overlay +: Encendido ]

Agradecimiento a las aportaciones de WillyWeb que nos enseña a pescar. En concreto he aprendido el uso de los símbolos (<) y (>) para obtener los valores mayor y menor de una matriz, el uso del comando Parse/Format Data Time que desconocia y, en particular, del parámetro offset. Gracias!

[WillyWeb]

Agradecimiento a las aportaciones de WillyWeb que nos enseña a pescar...

La leche, me has emocionado. :cry:

Y la tarea tiene una pinta y unas funcionalidades impresionantes. :ok:

[cace0353]

Lo siento :-(. Hay un error en la selección del grupo de dos horas más barato. Tal como está escrito siempre saldràn seleccionadas las dos primeras horas de la lista, aunque no sean consecutivas por horas, porque la suma serà inferior a cualquier otro par!.
Revisando esta parte. El resto funciona correctamente…

[Caravantes]

Hola Cace; encantado de verte y más encantado de que intervengas con una aportación tan fantástica y completa. Gracias.

a) en ocasiones hay cortes de luz (al menos donde yo vivo) y la programación queda "desplazada" con el peligro de que el desplazamiento horario nos llevara a un horario "caro".

Supongo que este párrafo te refieres al tema que yo comenté, del termo sin enchufe inteligente ni conexión a Internet. Hemos comprado un "Programador digital Garza 400602" que lleva batería (igual que los relojes digitales) y mantiene correctamente la hora aunque se produzca un corte de corriente. No hay desplazamiento horario.

b) Los sábados y domingos acostumbran a ser más "baratos" y por tanto lo ideal sería recurrir a un programador diario de 7 dias alimentado con bateria recargable desde el propio enchufe (bastante más caros).

El dispositivo que te he mencionado admite hasta 8 programas (secuencias de encendido/apagado), y cualquiera de esos 8 programas puede ajustarse para que se ejecute para todos los días o para ciertos días concretos de la semana, o para los fines de semana (sábados y domingos), etc. Este cacharrito cuesta unos 10 euros en Amazon, Leroy Merlín y otros sitios similares. A mí no me parece caro.

Por otro lado, tanto un termo eléctrico como un sistema de calefacción puede mantener una eficacia razonable si recibe alimentación eléctrica al menos una vez al día. Hace años tuve tarifa nocturna y usaba un programador de ese tipo para que el termo eléctrico tomase energía de 7 a 8 de la mañana; el agua del termo se mantenía caliente todo el día. También tenía acumuladores térmicos que se "calentaban" por la noche e iban soltando el calor a lo largo de la jornada. Pero es impensable que cosas de este tipo puedan "cargarse" solo durante el fin de semana. Aunque sería más barato, para el martes el agua del termo ya no estaría caliente y los acumuladores térmicos ya habrían soltado el 90% del calor que hubieran acumulado, por lo que cada semana te quedarías varios días sin agua caliente y/o sin calefacción.

[cace0353]

Bueno, el error se debia a que calculaba la dupla de horas más baratas a partir de la matriz ordenada por los precios en lugar de hacerlo con la ordenada por las horas.

He modificado la sección del código donde se determina este par de horas. Para ello he definido de nuevo la matriz de precios de las horas restantes en A31 (%restants).
Por tanto, y en resumen: aparece una acción nueva (A31) y se cambian las referencias a la matriz %seleccio por %restants. El resto de código permanece igual.

<------------------------- INICI Determinació DUPLA hores més barates>
A30: Ancla

<Llista de Preu/hora des de l'hora actual fins l'hora %Nona ORDENAT PER HORES…>
A31: Arrays Merge [
Nombres: %pre_pers
%hora_pers
Merge Type: Simple
Ensamblador: de
Salida: %restants ]

A32: Establecer Variable [
Nombre: %limit
A: %Nona-1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

<Salta la determinació de la DUPLA d'hores si només en queda una….>
A33: Ir A [
Tipo: Etiqueta de Acción
Etiqueta: ---------------------------- FINAL Determinació dues hores més barates ]
Si (if) [ %restants(#) ~ 1 ]

A34: Si (if) [ %hora < %limit | %dia_barres !~ %avui_barres ]

A35: Establecer Variable [
Nombre: %penult
A: %restants(#)-1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

A36: Establecer Variable [
Nombre: %minim
A: 999.99
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A37: Para (for) [
Variable: %pri
Ítems: 1:%penult
Structure Output (JSON, etc): Encendido ]

A38: Establecer Variable [
Nombre: %seg
A: %pri+1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

A39: Sección de Variable [
Nombre: %restants(%pri)
De: 1
Longitud: 6
Encajar: Encendido
Almacenar Resultado En: %primera ]

A40: Sección de Variable [
Nombre: %restants(%seg)
De: 1
Longitud: 6
Encajar: Encendido
Almacenar Resultado En: %segona ]

A41: Establecer Variable [
Nombre: %suma
A: %primera+%segona
Calcular: Encendido
Dígitos de Redondeo Máximos: 2
Structure Output (JSON, etc): Encendido ]

A42: Si (if) [ %suma < %minim ]

A43: Establecer Variable [
Nombre: %minim
A: %suma
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A44: Establecer Variable [
Nombre: %result
A: %restants(%pri)
%restants(%seg)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A45: Establecer Variable [
Nombre: %hora_inici
A: %restants(%pri)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A46: Separar Variable [
Nombre: %hora_inici
Separador: de ]

A47: Separar Variable [
Nombre: %hora_inici2
Separador: - ]

A48: Fin Si (end if)

A49: Fin Para (end for)

A50: Establecer Variable [
Nombre: %hora_inici
A: %hora_inici21:00
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A51: Fin Si (end if)

<---------------------------- FINAL Determinació dues hores més barates>
A52: Ancla

Caravantes Lo del precio/hora en los fines de semana lo decia porque altera los datos estadísticos si calculas las medias de 5 ó 6 dias pasados y coges un fin de semana entre los ellos.

El programa debe completarse con el perfil o perfiles necesarios para que te avise a las horas de conectar los aparatos que hubieras programado en la escena.
Si se logra activar un enchufe por WiFi podria ejecutarse automáticamente la tarea (sin escena) a las 00:00 y que ella se encargara de arrancar los aparatos a la hora más favorable...

[WillyWeb]

Bueno, el error se debía a que calculaba la dupla de horas más baratas a partir de la matriz ordenada por los precios en lugar de hacerlo con la ordenada por las horas.

Veamos si lo he entendido.

Partes de un subconjunto de los datos originales en su orden natural (por horas). Creas el array "paralelo" (nombre pendiente de patente) que recorres hasta el penúltimo elemento sumando el precio de cada hora con el de la siguiente. Y si esa suma resulta ser el valor más bajo encontrado ya tienes localizadas las dos horas consecutivas con el mejor precio ... ¿correcto?

:pensando:

%min = 1000
Para [ %aaa de 1:23 ]
%bbb = %aaa + 1
%sum = %http_data[PCB](%aaa) + %http_data[PCB](%bbb)
%xxx = %aaa [ SI %sum < %min ]
%min = %sum [ SI %sum < %min ]
Fin Para
%bbb = %xxx + 1
%aaa = %http_data[PCB](%xxx) de %http_data[Hora](%xxx)
%bbb = %http_data[PCB](%bbb) de %http_data[Hora](%bbb)

Eso es una versión simplificada del mismo procedimiento, por cierto muy elegante :ok:, que saca las DOS mejores horas consecutivas del DÍA, momento ideal para poner una lavadora, el lavaplatos o encender el calentador.

Si quieres analizar un rango concreto de horas solo tienes que modificar el "1:23" del bucle (o usar variables). Y si quieres un rango de más de dos horas los cambios tampoco son complicados. :silbando:

[WillyWeb]

Pensaba que el algoritmo anterior ya era lo más simple posible, pero cuando lo he probado en Tasker me he dado cuenta de que se podía mejorar ligeramente. Y sí, confieso que los "retazos" de código que voy proponiendo para este proyecto los escribo sin haberlos probado antes. :shock:

Al tema...

%min = 9999
Para [ %ind1 de 1:23 ]
Establecer Múltiples Variables [ Nombres: %ind2,%pre1,%pre2 Valores: %ind1+1,%http_data[PCB](%ind1),%http_data[PCB](%ind2) Calcular: Sí ]
Establecer Múltiples Variables [ Nombres: %res1,%res2,%min Valores: %ind1,%ind2,%pre1+%pre2 Calcular: Sí ] [ SI %pre1+%pre2 < %min ]
Fin Para

Al finalizar ese bucle tendremos el array %res() con los índices de las dos (o las que quieras) mejores horas consecutivas del periodo analizado (todo el día en este ejemplo).

[cace0353]

Ostras WillyWeb, desconocia totalmente lo de asignar multiples variables en Tasker con una única instrucción. Siempre lo hacia con un javascriplet de múltiples lineas.
Mañana, cuando tenga un rato, lo pruebo!
He vuelto a pescar un pez! ;-)

[WillyWeb]

Bueno, parece que nadie se atreve con el paso final. :silbando:

Se supone que ya tenemos las horas "buenas" y ahora toca encender/apagar el termo, lavaplatos, radiador o lo que sea.

¿Con qué?


Con un enchufe compatible con Tuya o Smart Life (https://www.amazon.es/s?k=enchufe+tuya) (son básicamente lo mismo).
Con una cuenta gratuita en IFTTT (https://ifttt.com/plans) (válida para cinco applets).
Y con un applet que use Webhooks (https://ifttt.com/maker_webhooks) en la parte IF y Smart Life (https://ifttt.com/smartlife) en la parte THEN.


¿Cómo?


Con algún perfil de hora y sus correspondientes variables que marquen el momento de encendido/apagado.
Con alguna tarea para componer y enviar a IFTTT la URL que Webhooks necesita.


Me suena que de esto ya hemos hablado antes. :pensando:

Bueno, ir mirando esas cosas. Por cierto, ojo con la corriente máxima que pueda aguantar el enchufe (o interruptor) elegido. Si no lo tenéis claro lo estudiamos con calma.

**EDITO**

En algunos casos el enchufe WiFi no es una opción porque es necesario pulsar un botón físico para que el aparto se ponga en marcha. Entonces hace falta un chisme como este...

SwitchBot (https://www.amazon.es/SwitchBot-mec%C3%A1nicamente-interruptor-temporizador-programable/dp/B07B7NXV4R) junto con SwitchBot Hub Mini (https://www.amazon.es/SwitchBot-Mini-Smart-Remote-Acondicionado/dp/B07TTH5TMW/).

O como estos otros...

https://www.amazon.es/Riiai-Interruptor-inteligente-aplicaci%C3%B3n-temporizador/dp/B095YMVHFX

https://es.aliexpress.com/item/1005003535335637.html

https://es.aliexpress.com/item/1005003061028654.html

[cace0353]

Al finalizar ese bucle tendremos el array %res() con los índices de las dos (o las que quieras) mejores horas consecutivas del periodo analizado (todo el día en este ejemplo).

Bueno, WillyWeb, pues he incorporado tu propuesta de compresión del código para determinar la dupla de horas consecutivas más favorables por precio adaptándolo a mis necesidades:

a) Calcula sólo a partir de la hora actual hasta la hora fijada como %Nona (normalmente las 24:00 pero configurable en la escena mediante un "consulta de variable").

b) Hay un condicional SI para ejecutar esta parte de código desde la primera hora %Prima si se está mostrando la lista del dia sigüiente (como opción conmutable en la escena a partir de las 21:00)

c) He añadido unas instrucciones adicionales para separar la primera hora del grupo y darle el formato HH:MM que se asigna a la variable global %Alarma2 y que, mediante el correspondiente perfil activará un aviso o arrancará el enchufe WiFi...

Ajunto el código entre las dos Anclas o comentarios que deberia substituirse con el ahorro de 8 acciones...

<------------------------- INICI Determinació DUPLA hores més barates>
A30: Ancla

A31: Establecer Variable [
Nombre: %limit
A: %Nona-1
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

<Salta la determinació de la DUPLA d'hores si només en queda una….>
A32: Ir A [
Tipo: Etiqueta de Acción
Etiqueta: ---------------------------- FINAL Determinació dues hores més barates ]
Si (if) [ %seleccio(#) ~ 1 ]

A33: Si (if) [ %hora < %limit | %dia_barres !~ %avui_barres ]

A34: Establecer Variable [
Nombre: %minim
A: 9999
Calcular: Encendido
Dígitos de Redondeo Máximos: 1
Structure Output (JSON, etc): Encendido ]

A35: Para (for) [
Variable: %pri
Ítems: %hora:%limit
Structure Output (JSON, etc): Encendido ]

A36: Establecer Múltiples Variables [
Nombres: %seg,%pre1,%pre2
Valores: %pri+1,%http_data[PCB](%pri),%http_data[PCB](%seg)
Calcular: Encendido
Dígitos de Redondeo Máximos: 2
Structure Output (JSON, etc): Encendido ]

A37: Establecer Múltiples Variables [
Nombres: %res1,%res2,%minim
Valores: %pri,%seg,%pre1+%pre2
Calcular: Encendido
Dígitos de Redondeo Máximos: 2
Structure Output (JSON, etc): Encendido ]
Si (if) [ %pre1+%pre2 < %minim ]

A38: Fin Para (end for)

A39: Fin Si (end if)

A40: Establecer Variable [
Nombre: %hora_inici
A: %http_data[Hora](%res1)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A41: Establecer Variable [
Nombre: %result
A: %http_data[PCB](%res1)%http_data[Hora](%res1)
%http_data[PCB](%res2) de %http_data[Hora](%res2)
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

A42: Separar Variable [
Nombre: %hora_inici
Separador: - ]

A43: Establecer Variable [
Nombre: %hora_inici
A: %hora_inici1:00
Dígitos de Redondeo Máximos: 3
Structure Output (JSON, etc): Encendido ]

<---------------------------- FINAL Determinació dues hores més barates>
A44: Ancla


*** EDITO ***

A pesar de que las horas seleccionadas són correctas los precios mostrados en la escena no lo són, siempre muestra los de las últimas dos horas del bucle...

Detectado el error de que no se muestran los precios mínimos he modificado la accion A41 y ya está resuelto...

[WillyWeb]

En A41 haces una suposición que no siempre es cierta. Al salir del bucle las variables %pre1 y %pre2 puede que no tengan el precio de las dos horas emparejadas. Si lo haces así...

%result =
%http_data[PCB](%res1) de %http_data[Hora](%res1)
%http_data[PCB](%res2) de %http_data[Hora](%res2)

...problema resuelto.

Y para definir %hora_inici puedes hacer esto...

%hora_inici = %http_data[Hora](%res1)
Buscar y Reemplazar [ En: %hora_inici Buscar: -\d\d$ Reemplazar: :00 ]

O esto otro...

Sección de Variable [ %http_data[Hora](%res1) De:1 Longitud: 2 Almacenar en: %hora_inici ]
%hora_inici = %hora_inici:00

[cace0353]

En A41 haces una suposición que no siempre es cierta. Al salir del bucle las variables %pre1 y %pre2 puede que no tengan el precio de las dos horas emparejadas. Si lo haces así...

%result =
%http_data[PCB](%res1) de %http_data[Hora](%res1)
%http_data[PCB](%res2) de %http_data[Hora](%res2)

...problema resuelto.

OK!
Gracias…

[Caravantes]

¿Con qué? Con un enchufe compatible con Tuya o Smart Life (son básicamente lo mismo)...
¿Cómo? Con algún perfil de hora y sus correspondientes variables que marquen el momento de encendido/apagado.

Hace dos años se hizo otro hilo específico para abordar ese tema con detalle:
Controlar relé Wifi desde tasker (https://www.htcmania.com/showthread.php?t=1525110) https://www.htcmania.com/showthread.php?t=1525110

Me ha parecido oportuno continuar esta parte de la conversación en ese hilo que ya existe dedicado a ese asunto. Quien quiera ir directamente a mi post, puede hacerlo en
https://www.htcmania.com/showthread.php?p=33388600#post33388600

Gracias, Willy, por tus inestimabes aportaciones en ambos hilos.

[cace0353]

Me engancho de nuevo.

Para probar la propuesta de WillyWeb para ejecutar el tramo de determinación de la dupla, cloné mi tarea y realicé los cambios en ella.
Una vez funciona todo correctamente me parecia que la tarea modificada era màs lenta y he puesto controles de tiempo (%TIMEMS) al inicio y al final de este fragmento de código en ambas tareas guardando las salidas (%tiemp_fin - %tiemp_ini) en un archivo de texto en modo "Añadir nueva linea".

He aquí los resultados para 5 ejecuciones alternadas:

Cace0353: 72
WillyWeb: 437
Cace0353: 95
WillyWeb: 420
Cace0353: 115
WillyWeb: 405
Cace0353: 75
WillyWeb: 413
Cace0353: 111
WillyWeb: 396

Sorprendentemente el código mas "pedreste" ha resultado ser mas rapido de ejecución!

De todas formas hemos aprendido cosas nuevas…

Gracias!

[WillyWeb]

Sorprendentemente el código mas "pedreste" ha resultado ser mas rapido de ejecución!

:oskitar:

Está claro que esa acción de "Establecer Múltiples Variables" está poco pulida. Gracias por tomarte el tiempo de hacer la comprobación.

Por cierto, tienes un cronómetro interno muy fino para deterctar diferencias de apenas 300 milisegundos. :risitas:

[cace0353]

:oskitar:



Está claro que esa acción de "Establecer Múltiples Variables" está poco pulida. Gracias por tomarte el tiempo de hacer la comprobación.

Por cierto, tienes un cronómetro interno muy fino para deterctar diferencias de apenas 300 milisegundos. :risitas:
¿Y cual es este "cronómetro interno"?
(Vamos a acabar con todo el pescado! [emoji23])

*** EDITO ***

Vaaale! no lo habia pillado...:estrellas: pensaba (viniendo de donde viene el comentario) que no fuera un nuevo comando!

De todas formas, en tareas que se ejecutan en poco más de un segundo 3 décimas de segundo se notan...

Saludos

[JUANJO94]

50€ de descuento para tí + Tarifa de luz más barata del mercado + SIN PERMANENCIA + Compensación de excedentes si tienes placas solares al mejor precio (0,08€ / Kwh mínimo) + Energía 100% verde

Consigue 50€ de regalo aquí: https://share.octopusenergy.es/wheat-calf-179

4,8/5 Estrellas en Google y Trustpilot. En menos de 72h habrás cambiado de compañía sin cortes y totalmente gratis. Octopus Energy no cobra ningún coste asociado ni ningún servicio extra. Solo pagas el precio más bajo del mercado por la electricidad que consumes. Octopus Energy está presente en 8 países: España, Reino Unido, Alemania, EEUU, Japón, Italia, Francia y Nueva Zelanda.

Consulta artículos de la OCU y El Economista hablando sobre OCTOPUS ENERGY:

OCU: https://www.ocu.org/vivienda-y-energia/gas-luz/informe/tarifas-electricas-baratas

El Economista: https://www.eleconomista.es/energia/noticias/12602239/12/23/las-tarifas-100-renovables-ya-son-mas-baratas-que-las-tradicionales.html

TARIFAS:

OCTOPUS RELAX: 0,127 €/kWh precio fijo las 24h del día

OCTOPUS 3: 0,097 €/kWh en Valle, 0,126 €/kWh en Llano, 0,172 €/kWh en Punta

OCTOPUS FLEXI: tarifa indexada a mercado

OCTOPUS SOLAR: 0,085 €/kWh en Valle, 0,134 €/kWh en Llano, 0,182 €/kWh en Punta + Excedentes a 0,08€ / Kwh

UNA VEZ QUE YA SEAS CLIENTE DE OCTOPUS ENERGY A TRAVÉS DE ESTE ENLACE

https://share.octopusenergy.es/wheat-calf-179

TAMBIEN PODRÁS TENER TU PROPIO CÓDIGO PARA INVITAR AMIGOS Y CONSEGUIR 50€ POR CADA AMIGO QUE SE UNA.

¡INCLUSO SIN LOS 50€ DE REGALO YA ES LA TARIFA MÁS BARATA DEL MERCADO!

https://share.octopusenergy.es/wheat-calf-179