aktualizacja zadania

Alek/doniczka/src/czujnik.py

@@ -0,0 +1,7 @@
+class Czujnik:
+
+    def __init__(self, name):
+        self.name = name
+
+    def pomiar(self):
+        ...

Alek/doniczka/src/doniczka.py

@@ -0,0 +1,57 @@
+from czujnik import Czujnik
+from roslina import Roslina
+
+
+class Doniczka:
+
+    def __init__(self, a: Roslina, b: Czujnik):
+        self.a = a
+        self.b = b
+
+    def podlej(self):
+        ...
+
+    def czy_podlac(self) -> bool:
+        return self.b.pomiar() > self.a.zapotrzebowanie
+
+
+# rozrysować strukturę działania doniczki
+# zależności między elementami i co się powinno dziać
+# moze dodać typ rośliny żeby nadać ine ilości zapotrzebowania na wodę
+# zapotrzebowanie -> {"nazwa_rosliny": ["ilosc_wody", "interwal_podlewania", "docelowa_wilgotnosc"]}
+#              START
+#                |
+#       doniczka: wybierz rosline z listy
+#       ---------------------------------
+#       |                               |
+#       | (jest na liście)              | (brak na liście)
+#       |                               |
+#   doniczka:                           doniczka:
+#   pobierz parametry z bazy            pobierz parametry od usera
+#       |                               |
+#       ---------------------------------
+#                       |
+#                   czujnik:
+#                    pomiar
+#                       |
+#                   doniczka:
+#                   czy_podlac
+#                       |
+#               ---------------------
+#              t|                  n|
+#              doniczka:           doniczka:
+#              czy jest woda       czekaj interwal
+#               ---------------
+#              t|            n|
+#           doniczka:        doniczka:
+#           podlej           powiadom usera
+#               |
+#           doniczka:
+#           czekaj interwal
+#
+# dodać zapisywanie do bazy stanu aktualnego, żeby dało się wznowić pracę po przerwaniu
+
+
+
+
+

Alek/doniczka/src/roslina.py

@@ -0,0 +1,18 @@
+class Roslina:
+
+    def __init__(self, name: str, water_required=1000):
+        self.water_required = water_required
+        self.name = name
+
+
+
+
+
+a = Roslina(656)
+
+
+
+
+
+def a(x=1000):
+    print(x)

Alek/listy_i_inne.py

@@ -0,0 +1,65 @@
+macierz = [[0, 0, 1, 0, 0], [1, 0, 0, 0, 0], [1, 1, 0, 1, 1], [0, 0, 1, 0, 0], [0, 0, 1, 1, 1]]
+
+# for row in macierz:
+#     for element in row:
+#         print(element)
+#
+# for i in range(len(macierz)):
+#     row = macierz[i]
+#     for j in range(len(row)):
+#         element = row[j]
+#         print(element)
+
+print("---------------------------------------")
+
+
+def szukaj_rekurencyjnie(row, col, rzeka):
+
+    wszystkie_mokre_miejsca.add((row, col))
+    rzeka.add((row, col))
+    if col > 0:
+        element = macierz[row][col-1]
+        pozycja = (row, col-1)
+        if element == 1 and pozycja not in wszystkie_mokre_miejsca:
+            szukaj_rekurencyjnie(pozycja[0], pozycja[1], rzeka)
+
+    if row < len(macierz) - 1:
+        element = macierz[row + 1][col]
+        pozycja = (row + 1, col)
+        if element == 1 and pozycja not in wszystkie_mokre_miejsca:
+            szukaj_rekurencyjnie(pozycja[0], pozycja[1], rzeka)
+
+    if col < len(macierz[0]) - 1:
+        element = macierz[row][col + 1]
+        pozycja = (row, col + 1)
+        if element == 1 and pozycja not in wszystkie_mokre_miejsca:
+            szukaj_rekurencyjnie(pozycja[0], pozycja[1], rzeka)
+
+    if row > 0:
+        element = macierz[row - 1][col]
+        pozycja = (row - 1, col)
+        if element == 1 and pozycja not in wszystkie_mokre_miejsca:
+            szukaj_rekurencyjnie(pozycja[0], pozycja[1], rzeka)
+
+
+
+dlugosc = len(macierz[0])
+wszystkie_mokre_miejsca = set()  # pojedyncze punkty
+wszystkie_rzeki = set()  # cale rzeki
+
+for i in range(dlugosc):
+    for j in range(len(macierz)):
+        element = macierz[j][i]
+        pozycja = (j, i)
+        if element == 1 and pozycja not in wszystkie_mokre_miejsca:
+            aktualna_rzeka = set()
+            szukaj_rekurencyjnie(j, i, aktualna_rzeka)
+            wszystkie_rzeki.add(tuple(aktualna_rzeka))
+
+# print(wszystkie_rzeki)
+for x in wszystkie_rzeki:
+    print(f"{x} dlugosc: {len(x)}")
+print("---------------------------------------")
+print(len(max(wszystkie_rzeki)))
+
+# doniczka > kompozycja z klas roślina i czujnik

Alek/zadanie1.py

@@ -0,0 +1,71 @@
+# DHT22
+
+
+# 0 - 1054 <--- opornosc
+# -20 - 100 <--- temperatura
+
+
+# co sekundę otrzymuejmy odczyt z czujnika i chcemy przedstawić userowi temeraturę
+
+
+# [600 632 680 690 600 632 680 690 600 632 680 690 0 0 700 690 600 632 680 690 1054 700 690 720 720 750 760 770 740 ] # 1hz
+
+
+# 1. czegos co generuje nam dane
+#      a) Jesli uruchomimy program to będzie dzialal do momentu az go zatrzymamy (while True)
+#      b) podaje ten zestaw [600 632 680 690 600 632 680 690 600 632 680 690 0 0 700 690 600 632 680 690 1054 700 690 720 720 750 760 770 740 ]
+#       (poczatkowo po tych 20 elementach moze sie program konczyc)
+#     c)  wyprintuj przeskalowaną opronosc (z 600 na temperature)
+
+from time import sleep
+from statistics import median
+from numpy import interp
+
+input_data = [600, 632, 680, 690, 600, 632, 680, 690, 600, 632, 680, 690, 0, 0, 700, 690, 600, 632, 680, 690, 1054, 700,
+              690, 720, 720, 750, 760, 770, 740]
+input_range = [0, 1054]
+output_range = [-20, 100]
+avg_list = []
+
+# Mediany
+
+# def median
+# def sortujaca
+
+
+def sortujaca(array):
+
+    array_length = len(array)
+    for x in range(array_length):
+        for y in range(0, array_length - x - 1):
+            if array[y] > array[y + 1]:
+                temp = array[y]
+                array[y] = array[y + 1]
+                array[y + 1] = temp
+    return array
+
+
+def mediana(data):
+    """
+    Return median value for provided data
+
+    :param data: list of values
+    :return:
+    """
+    sorted_args = sortujaca(data)
+    if len(sorted_args) % 2 == 0:
+        n1 = sorted_args[len(sorted_args) // 2 - 1]
+        n2 = sorted_args[len(sorted_args) // 2]
+        result = (n1 + n2) / 2
+    else:
+        result = sorted_args[len(sorted_args) // 2]
+    return result
+
+
+for index, value in enumerate(input_data):
+    sample_list = input_data[max(0, index - 4):index + 1]  # pierwszy krok jest spoko
+    median_value = mediana(sample_list)
+    mapped_value = interp(median_value, input_range, output_range)  # TO jest spoko ale mean bym zamienii na median i rozbi to
+    # znalexc jak sobie rondowac cos do 2 miejsca z intem i przy princie
+    print(f'Mediana z ostatnich {len(sample_list)} sek.: {mapped_value:.2f}')
+    sleep(1)