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)

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)

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)

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)

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)

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)

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)

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)