Przeszukaj forum

Mam ponad dziesięcioletni, chiński skuterek. Z racji wieku, oraz pochodzenia, niektóre rzeczy nie działają w nim idealnie - jedną z nich jest stacyjka. Od jakiegoś czasu problem z nią polega na tym, że przekręcenie kluczyka nie zawsze włącza zasilanie, a jak już zadziała, to delikatne ruszenie go powoduje zgaszenie silnika. Wyraźnie jakiś problem ze stykami. Za pierwszym razem rozebrałem całą stacyjkę i przeczyściłem styki, ale jest to dość skomplikowany proces, którego nieumiejętne przeprowadzenie skutkuje wyskoczeniem sprężyny i koniecznością zbierania części z całej podłogi. Potrzebne było jakieś inne rozwiązanie. Nie, nie mówię o wymianie na nową. Rozdział 2: Pomysł Mam telefon z Androidem. Mam dużo Raspberry Pi, w każdym smaku. PiPico ma Bluetootha. Mój telefon też. Kiedyś pisałem programy na Badę, programowanie "niskopoziomowe" nie jest mi też straszne. Może by tak podpiąć jakąś malinę do skutera i odpalać go zdalnie? Nie może to być zbyt trudne ( ͡° ͜ʖ ͡°) W razie czego, mam kogo prosić o pomoc. Rozdział 3: Założenia Po pierwsze, chcę, żeby skuter dało się też odpalać i gasić tak, jak zwykle - z kluczyka. Telefon prędzej ulegnie awarii niż kawałek naciętego metalu, więc tak będzie bezpieczniej. Po drugie, sterowanie ma iść przez Bluetootha i ma być możliwe tylko po wcześniejszym sparowaniu się urządzeń. Musi być też jakieś ograniczenie kto może sparować się z kontrolerem, żeby nie dało się porwać skutera. Po trzecie, kontroler ma czuwać na własnym zasilaniu, żeby nie rozładował akumulatora w skuterze. Po włączeniu zasilania lub odpaleniu może z niego korzystać żeby się podładować. Rozdział 4: Jak odpalić skuter? Podczas normalnego używania, skuter odpala się następująco: Wsadź kluczyk w stacyjkę i go przekręć Wciśnij hamulec Wciśnij i przytrzymaj przycisk rozrusznika Gdy silnik pracuje, puść przycisk rozrusznika Na schemacie widać, że rozrusznik kontrolowany jest przez przekaźnik, który podłączony jest szeregowo przez czujnik hamulca i przycisk rozrusznika. Wychodzi więc na to, że aby odpalić skuter potrzebne są 3 przekaźniki: Załączający zasilanie - symulowane przekręcenie kluczyka w stacyjce, Zwierający przewód na poziomie czujnika hamulca - symulowane wciśnięcie hamulca, Zwierający przewód na poziomie przycisku rozrusznika - symulowane wciśnięcie go. No dobra, ale jak zgasić skuter? No więc okazało się, że nie wystarczy wyłączyć zasilania. Ze stacyjki wychodzi przewód, na którym podczas pracy silnika jest napięcie ~60V. Przekręcenie kluczyka na zero powoduje jego zwarcie do masy. Wygląda więc na to, że zgaszenie silnika wymaga czwartego przekaźnika, który będzie rozwierał tę linię na czas pracy silnika. Musiałem przemyśleć jak go podpiąć, aby dalej możliwe było odpalenie i zgaszenie silnika używając tylko klucza. Rozdział 5: Lista zakupowa Od swojego mentora embeddowego usłyszałem, że jest taki fajny, miniaturowy kontroler, który ma bluetootha oraz można do niego łatwo podłączyć akumulatorek Li-Ion - Xiao BLE . Podobno PiPico nie jest zbyt energooszczędne, mózgiem projektu został więc Xiao. Skuter ma zasilanie 12V, kontrolery przeważnie działają na 5V/3.3V. Aby móc sterować skuterem potrzebna będzie mi garść przekaźników. Okazało się jednak, że przekaźniki mają wiele parametrów, takich jak napięcie sterowania, napięcie cewki... Znalezienie odpowiednich zajęło mi trochę czasu. Idealny przekaźnik może być sterowany napięciem 3.3V i ma cewkę na 3.3V lub 5V. Początkowo, gdy zaczynałem pracę nad projektem, myślałem, że wystarczą mi tylko dwa przekaźniki, ale na Botlandzie nie było dostępnych odpowiednich, stanęło więc na module z cewką 12V i logiką 5V. Do tego potrzebny był mi też konwerter poziomów logicznych oraz przetwornica step-up z 3.3V do 12V - na zasilaniu z akumulatorka tylko takie napięcie jest dostępne. Wymagania i możliwości prądowe przekaźnika i przetwornicy się pokrywały, więc nie przewidywałem problemów. W trakcie prac, oraz po podźganiu skutera miernikiem w różnych miejscach, okazało się jednak, że będę potrzebował więcej niż 2 przekaźniki, wróciłem więc do sklepu i zobaczyłem, że asortyment jest teraz większy. Zgarnąłem więc moduł 4 przekaźników (cewka 5V, logika 3.3-5V) które będą kontrolowały odpalanie i gaszenie silnika, oraz jeden pojedynczy (cewka 5V, logika 3.3V+), który będzie włączał zasilanie skutera i zasilany będzie z przetwornicy step-up z 3.3V do 5V. Z pozostałych rzeczy, zgarnąłem sobie garść przełączników (do debugowego wyłączania przekaźników - podpięte szeregowo za przełącznikami), kilka różnokolorowych kontrolek (bo blinkenlightsy są fajne), wyświetlacz OLED (początkowo do zabawy, później do wyświetlenia kodu parowania Bluetooth) oraz buzzerek, żeby słyszeć, że moduł działa. Rozdział 6: Oprogramowanie kontrolera Na początku prac myślałem o napisaniu programu w Pythonie, bo go dość dobrze znam, ale miałem problem z wydajnością rysowania na ekranie. Arduino IDE okazało się niewiele lepsze - ekran wyciągał chyba jedną klatkę na sekundę. Mentor Embeddowy doradził mi zabawę Zephyrem, więc poszedłem w tę stronę. Okazało się, że o ile początkowe skonfigurowanie wszystkiego było odrobinę skomplikowane, to późniejsze pisanie na Zephyrze jest dość proste i przyjemne. Dokumentacja jest ok, udostępniają też wiele przykładów jak używać każdego komponentu systemu-- ale jak to "nie ma sterownika do twojego ekranu"? Skoro nie ma sterownika, trzeba go napisać samemu! Podglądając jak napisany jest sterownik do podobnego wyświetlacza, oraz z dokumentacją mojego pod ręką, udało mi się uruchomić wyświetlacz. Można było przejść do prac nad główną częścią programu. Oprogramowanie kontrolera składa się z kilku modułów: QMBStarter - główna logika odpalania i gaszenia silnika, Sensors - odczyt wskazań z czujników (włączone zasilanie, czy silnik pracuje), Bluetooth - zarządzanie połączeniami Bluetooth i komunikacja z aplikacją, Notifications - obsługa ekranu, buzzera i LEDów na kontrolerze. Moduł QMBStarter (nazwa pochodzi od modelu silnika: QMB139) jest automatem skończonym/maszyną stanów. Żądanie z aplikacji powoduje poruszanie się pomiędzy stanami, zgodnie z określonymi regułami. Przykładowo, jeśli zasilanie jest wyłączone ( => jesteśmy w stanie POWERED_OFF ) i z aplikacji przyjdzie żądanie odpalenia silnika ( => przejście do stanu RUNNING ), ścieżka przez którą trzeba przejść jest jednoznacznie określona. Wracając do tematu parowania urządzeń Bluetooth. Pudełko z całym sprzętem planowałem ukryć gdzieś pod owiewkami skutera, dzięki czemu ekran nie byłby dostępny dla osób postronnych. Zawartość ekranu przez to mogła być uznawana za "tajną", stanęło więc na strategii parowania polegającej na przepisaniu kodu z wyświetlacza na telefon. Nikt niepowołany nie będzie w stanie wysyłać żądań do kontrolera, bo nie będzie sparowany, a nie będzie mógł się sparować, bo nie ma dostępu do ekranu. Ładnie i bezpiecznie. Pozostała więc... Rozdział 7: Obudowa Obudowa powstała na miniaturowej drukarce 3D Easythreed Nano - tania, ale jakość wydruku i obszar roboczy pozostawiają wiele do życzenia. Do zaprojektowania użyłem Autodesk Fusion, a slicingiem zajęła się CURA. Upchanie wszystkiego wymagało trochę kombinowania, ale udało się zmieścić. ...a potem okazało się, że lepiej będzie dać kable z tyłu i ekran z przodu... ...i w ten sposób wszystko zostało pięknie zapakowane (przy okazji: wydruk jednego pudełka w całości trwał jakieś 20 godzin ಠ_ಠ ) Rozdział 8: Android "Napiszę apkę na Androida!" - pomyślałem - "To nie może być przecież trudne!". No więc okazało się, że jednak jest. Nie dość, że wersji Androida jest milion, to jeszcze w międzyczasie zmienili język programowania jakim powinno się posługiwać, ciężko więc było początkującemu znaleźć dobre tutoriale. Z braku lepszych pomysłów, zagadałem do Internetowej Wyroczni (AKA ChatGPT): Hej, jak zrobić aplikację na Androida, która łączy się z urządzeniem Bluetooth, używając Kotlina? Hej, musisz zrobić tak i tak. Chcesz cały projekt? Tak, poproszę. Bla, bla bla bla... Chcesz wariant BLE? Tak, poproszę. Dzięki! Hej, a jak mogę zdefiniować filtry urządzeń Bluetooth? O w taki sposób. Dzięki. Jak zrobić, że po kliknięciu urządzenia włącza mi inne Activity? Bla bla bla... Jak patrzeć czy zmieniły się wartości charakterystyk GATT? Bla bla bla... Jak wysłać nową wartość do charakterystyki? Bla bla bla... Jak wyliczyć odległość od urządzenia Bluetooth? Bla bla bla... ...i tak dalej. ChatGPT okazał się świetnym narzędziem do nauki - był jak generator dokładnie takiego tutoriala, jakiego potrzebujesz. Odrobinę wiedziałem o tym jak działa Android, kojarzyłem też niektóre koncepty z programowania na smartfony, szybko więc "kliknęło" i byłem w stanie sam rozbudować aplikację i dodać do niej wszystko, czego potrzebowałem. Jedyny minus to strata honoru przez zastosowanie vibecodingu. Rozdział 9: Montaż i jazdaaaaaaa Pudełko planowałem wsadzić do skuterowego schowka pod kierownicą. Początkowo myślałem, że konieczne będzie wycięcie całego plastiku z tyłu, okazało się jednak, że wszystko idealnie mieści się bez tego. Jedyne co musiałem zrobić, to nawiercić kilka otworów na kable: Po podłączeniu wszystkiego, sprawdzeniu czy działa, oraz złożeniu skutera do kupy, można było zrobić jazdę testową: https://www.youtube.com/watch?v=KYT4AcXjoSQ Rozdział 10: Podsumowanie Zaczynając od dużej ilości lutowania, przechodząc przez naukę Zephyra, programowania mikrokontrolerów i Androida, kończąc na druku 3D i łączeniu kabelków, ten projekt zahaczył o wiele dziedzin. Wszystko po to, żebym mógł wyjść z samym telefonem do skutera i na nim pojechać, a potem po prostu odejść wierząc, że sam zgaśnie. Jest kilka rzeczy które można poprawić, takie jak jakość kodu (kontrolera i apki) czy bezpieczniejsze umiejscowienie pudełka (gąbki dookoła, żeby wibracje go nie zabiły). Największym problemem jest brak skutecznego wykrywania czy silnik pracuje (miałem z tym drobne problemy), ale generalnie jest to sukces i projekt uznaję za udany. Dokładniejszy opis wszystkich etapów prac, z zachowaniem lepszej chronologii, znajduje się na mojej stronie. W chwili pisania nie ma jeszcze ostatniej części, opisującej jak wyglądało finalne składanie wszystkiego, ale powinna się niedługo pojawić.

Cześć, Chciałem pokazać Wam mój projekt, który powstał głównie dla frajdy. Co dokładnie robi ten system? Pozwala z poziomu aplikacji Android: - włączać i wyłączać przekaźniki (np. światła w akwariach), - ustawiać harmonogram działania (czas startu i końca) dla pierwszego przekaźnika (z ogólnie 4 możliwych). Od strony tzw. "backendu": - Raspberry Pi 5 ma uruchomione mosquitto (MQTT), które dostępne jest na publicznym IP przez port TLS (8883) - mam więc dostęp do tego systemu w sposób (stosunkowo) bezpieczny, z dowolnego miejsca na świecie, z pomocą telefonu. - Całość komunikacji jest szyfrowana (zarówno mosquitto, apka na Androidzie, jak i urządzenia docelowe z Pico W korzystają z certyfikatów x509). Dodatkowo na brokerze jest login i hasło. Dodatkowo na Raspberry działa fail2ban, więc łatwo do systemu włamać się nie da. Procedura generowania kluczy opisana jest w README w repozytorium projektu. Dodatkowy bajer: urządzenia Pico W są wykrywane automatycznie – bez ręcznego dodawania ich do aplikacji Androidowej. Zajmuje się tym demon systemowy na Raspberry (aqua_topic_provider/provider.c). Lista wykrytych urządzeń wysyłana jest następnie do brokera MQTT, który udostępnia listę wykrytych urządzeń dla każdego zainteresowanego klienta (tu - aplikacja Android). Dodanie nowego urządzenia do systemu jest więc stosunkowo proste: Dla każdego nowego urządzenia z Pico W wystarczy lekko zmodyfikować konfigurację firmware (dodać sprzętowy MAC Pico W, ilość przycisków (przekaźników) oraz (dowolną) nazwę hosta - pod tą nazwą urządzenia występują na liście w aplikacji na Androidzie). Potem wystarczy skompilować, wgrać na Pico W, i tyle - apka na Androidzie po chwili pokaże nowe urządzenie na liście. Więcej info w readme na repo: pliki (Credentials.h / MacHostMapping.cpp) Architektura systemu System składa się z trzech głównych komponentów: 1. Raspberry Pi Pico W – jednostka wykonawcza: - steruje przekaźnikami, - reaguje na fizyczne przyciski, - obsługuje MQTT przez TLS (PubSubClient + WiFiClientSecure), - synchronizuje czas lokalny przez NTP (protokół pobierania aktualnego czasu z internetu), - nasłuchuje na UDP 0.0.0.0 (wszystkie interfejsy lokalne) / port 12345 - by dać się wykryć, - maszyna stanów obsługuje cykl życia aplikacji. Urządzenia wyglądają trochę topornie, ale to nie musi być piękne, tylko ma działać Program na Pico W korzysta z frameworka arduino-pico / https://github.com/earlephilhower/arduino-pico Do tego Arduinowy driver OLED (Adafruit_SSD1306), WiFi, MQTT (PubSubClient). Jest też zaimplementowana opcja update firmware urządzeń z Pico W przez OTA (ArduinoOTA). Całość firmware napisana jest jednakże w c++ (jedyny plik .ino ma raptem kilka linijek), i gdzieś mi chodzi po głowie by oddzielić biblioteki Arduino w osobnym module, i kiedyś zmigrować całość na jakieś inne środowisko, ale ogólnie chyba nie ma to sensu - systen działa stabilnie i bezproblemowo 24/7). 2. Raspberry Pi 5 – serwer i broker: - działa tu Mosquitto (MQTT broker), - demon w C cyklicznie wysyła pakiety UDP ("AQUA_DISCOVER" na 239.255.255.250:12345), (wspomniany wyżej provider.c) - Pico W odpowiada pakietem UDP "AQUA_FOUND|MAC|IP|hostname|amountOfSwitches" (DiscoverMe.cpp), - na podstawie tych odpowiedzi budowany jest JSON i publikowany na topicu: AQUA_DEVICES_UPDATE Przykładowa odpowiedź: { "devices": [ { "mac": "28:cd:c1:05:b8:76", "ip": "10.8.0.2", "hostName": "akwarium_duże_w_salonie", "switches": 1 }, { "mac": "28:cd:c1:05:b8:64", "ip": "10.8.0.3", "hostName": "akwarium_bojowniki_w_salonie", "switches": 2 } ] } 3. Aplikacja Android – interfejs użytkownika: - napisana głównie w Javie (bo lubię), z drobnymi elementami w Kotlinie, - korzysta z Eclipse paho w trybie klienta MQTT (org.eclipse.paho.client.mqttv3) - zapisuje się na główny topic AQUA_DEVICES_UPDATE, i później na pomocnicze topici AQUA_DEVICE_* - na tej podstawie buduje listę urządzeń widoczną w aplikacji, - każde urządzenie dostaje pozycję na liście (nazwa, przełączniki, przycisk ustalania harmonogramu). - komunikacja jest dwukierunkowa - czyli w apce włączam/wyłączam przekaźniki w urządzeniach, a w urządzeniach naciśnięcie danego przycisku odświeża stan switcha w apce w czasie rzeczywistym. Komunikacja przez brokera Gdy użytkownik: - zmienia stan przekaźnika (np. ON/OFF), - ustawia nowy harmonogram (np. 7:00–22:00), aplikacja Android publikuje odpowiedni JSON na MQTT: Włączanie przekaźnika: Topic: AQUA_DEVICE_SWITCH_SET/akwarium_duże_w_salonie { "isOn1": true } Ustawienie harmonogramu: Topic: AQUA_DEVICE_TIME_SET/akwarium_duże_w_salonie { "dateHourStart": 420, "dateHourEnd": 1320 } Te liczby to po prostu ilość minut od godziny 0:00. Pico W odpowiada statusem: Topic: AQUA_DEVICE_STATUS/akwarium_duże_w_salonie { "status": "ok", "dateHourStart": 420, "dateHourEnd": 1320, "isOn1": true [...] } Aplikacja na Pico W sama decyduje, czy pierwszy przekaźnik ma być włączony/wyłączony na podstawie lokalnego czasu i ustawionego harmonogramu. Można oczywiście ręcznie ten przekaźnik włączyć/wyłączyć, ale ostatecznie o określonych godzinach jego stan zostanie nadpisany przez ustalony harmonogram. Oczywiście prócz tego Pico W działają w pełni autonomicznie. Broker w tym przypadku służy tylko do ustawiania parametrów, i kontroli stanu przycisków przez aplikację. Pliki konfiguracyjne + submoduł W repozytorium nie ma plików z danymi wrażliwymi. Sam projekt wymaga by sklonować go z odświeżeniem submodułów: git clone --recurse-submodules https://github.com/jaszczurtd/lights-timer.git Ważne jest, by zawartość folderu "libraries" przekopiować do folderu "libraries" zarządzanego przez Arduino. Ważne jest również by odpowiednio skonfigurować i uzupełnić zawartość plików libraries/Credentials/ca_cert.c, oraz libraries/Credentials/MacHostMapping.h/.cpp – trzeba je dostosować do: - nazwy i hasła WiFi, - loginu/hasła/ip (domeny) do brokera MQTT, - certyfikatu x509 - przypisania MAC → hostname i liczby przekaźników. Sama wersja Arduino IDE z której korzystam to 2.3.x. Nie wiem czy to zadziała z wcześniejszymi wersjami. Po resztę informacji odsyłam do README w repozytorium. Dlaczego w ogóle to zbudowałem? Oczywiście wiem, że istnieją gotowe systemy smart home, które to wszystko robią lepiej, i pewnie jeszcze więcej – ale nie w tym rzecz. Prócz samej chęci tworzenia, jestem jednym z tych, którzy chcą mieć sterowanie domem w komórce, ale maja awersję do chmur wszelakich - stwierdziłem że nie chcę żeby światło w moich akwariach zależało od jakiegoś serwera cholera wie gdzie, albo nawet w Chinach. I najważniejsze - lubię malinki. Jedna chodzi 24/7, i robi za domowe centrum sterowania wszechświatem, więc idealnie nadaje się jako pośrednik dla tego systemu. I jeszcze pewnie odpowiedź na pytanie które się kołacze w głowie niejednego z was - ten projekt może się wydawać swoistym overkillem w temacie zdalnego włączania przekaźników. I tak pewnie by było, gdyby chodziło tylko o te przekaźniki. Ale struktura tego projektu i całe środowisko tak naprawdę zbudowałem z myślą o kilku ciekawszych rzeczach, którymi się pochwalę w przyszłości, i przy których to całe security, brokery, discovery itp, jest po prostu niezbędne. A co planuję dodać jeszcze do tego konkretnego projektu? - na pewno konfigurację WiFi dla Pico W z poziomu urządzeń (teraz trzeba to zmieniać w źródłach), - będzie pomiar temperatury wody w akwariach, - przyda się sterowanie chłodzeniem/grzaniem wody w akwariach, - może rozbuduję harmonogram, - reszta pomysłów jest na razie tajna Na razie moja żona (zapalona akwarystka) nie zgłasza konkretnego, dodatkowego zapotrzebowania, więc chwilowo zostaje tak jak jest. Ale to się wkrótce zapewne zmieni. Chętnie odpowiem na pytania, wyjaśnię dlaczego coś jest tak, a nie inaczej, etc. Pewnie są jakieś bugi, których chwilowo nie wykryłem, pewnie są miejsca które można lepiej ogarnąć, wiadomo. Repozytorium kodu https://github.com/jaszczurtd/lights-timer Pozdrawiam! Marcin (jaszczurtd)

Hej. Kupiłem sobie takie coś: https://botland.com.pl/klawiatury-bezprzewodowe/13217-klawiatura-bezprzewodowa-bluetooth-30-czarna-7-cali-5904422350208.html Przeznaczenie do RPi i tam jest spoko. Klawiatura nie ma AltGr ale w malince zmapowałem sobie Command na AltGr. Tyle że postanowiłem sprawdzić, jak to będzie latać z telefonem i tu problem, bo ani żółć mnie nie zaleje, ani łaski nikomu nie zrobię... ktoś ma jakiś sposób? BTW klawiaturka mechanicznie jest bardzo fajna i mieści się w kieszeni kurtki...

Witam, Jestem Nowy na forum, więc proszę o wyrozumiałość. Mam problem ze zrobieniem aplikacji mobilnej w Qt. Wszystko robię na podstawie Kursu Qt - Mateusz Patyk. Mianowicie podczas kompilacji pojawiał się błąd, o tym, że używam Java 1.8, a muszę mieć Java 11. Zainstalowałem, więc ją dla całego Windowsa oraz dla Qt (JDK 11). Błąd zniknął, ale pojawiły się kolejne dwa błędy, o których chyba było napisane w kursie. Proszę o poradę, co mam teraz zrobić. Cofnąć się do JDK 8, czy zrobić coś innego? Może mam zainstalować Open SSL? Wkleję jeszcze inne zrzuty. PS. Nie instalowałem NDK, bo Qt go wykrywa, jeśli dobrze rozumiem.

Uczę się Basic for android. Poszukuję informacji czy button jest wciśnięty i przytrzymany, ewentualnie zdarzenia key_up (przechodzę z MIT AI2 i tam takie rzeczy były) Aplikacja testowa: #Region Project Attributes #ApplicationLabel: B4A Example #VersionCode: 1 #VersionName: 'SupportedOrientations possible values: unspecified, landscape or portrait. #SupportedOrientations: portrait #CanInstallToExternalStorage: False #End Region #Region Activity Attributes #FullScreen: true #IncludeTitle: false #End Region Sub Process_Globals 'These global variables will be declared once when the application starts. 'These variables can be accessed from all modules. Private xui As XUI Private tmr As Timer End Sub Sub Globals 'These global variables will be redeclared each time the activity is created. Private button1 As Button Private Label1 As Label Private Label2 As Label Dim w As Byte End Sub Sub Activity_Create(FirstTime As Boolean) Activity.LoadLayout("Layout") tmr.Initialize("timer1", 100) End Sub Sub Activity_Resume End Sub Sub Activity_Pause (UserClosed As Boolean) End Sub '***************************************************************************** Private Sub Button1_Click w = w + 1 Label1.Text = w End Sub Private Sub Button1_LongClick w = w+1 tmr.Enabled = True End Sub Sub timer1_Tick ' tutaj chcę obsługę po "podniesieniu" przycisku ' If button1.text Then ' ' w = w + 1 ' ' Else ' tmr.Enabled = False ' End If End Sub

Zacząłem pisać aplikację która będzie miała za zadanie przechowywanie linków ze znacznikiem czasowym z you tube. Chodzi o to że często bywa w filmach, że chcę obejrzeć tylko fragment filmu który omawia interesujący mnie temat. Jakie uprawnienia muszę nadać mojej aplikacji aby znalazła się ona na liście "udostępnij", tak jak teraz są to: schowek, sms, mail?

Nie wiem czy ktoś tutaj się tym zajmuje. Chodzi o skrypty w basic for android. Przy okazji, od roku można pobrać pełną bezpłatną wersję tego narzędzia klik. Przerabiam aplikację poskładaną kiedyś w ai2. Mam skrypt który ustawia mi przyciski 'All variants script 'AutoScaleAll 'BtnPlanista.Bottom = 100%y 'BtnPlanista.Width = 100%x BtnPlanista.Bottom = 97%y BtnPlanista.Height = 8%y BtnPlanista.Width = 90%x BtnPlanista.Left = 5%x BtnL1.Bottom = BtnPlanista.Top - 2%y BtnL1.Height = 15%y BtnL1.Width = 43%x BtnL1.Left = 5%x BtnL2.Bottom = BtnPlanista.Top - 2%y BtnL2.Height = 15%y BtnL2.Width = 43%x BtnL2.Left = 52%x BtnTunDwn.Bottom = BtnL2.Top + 3%y BtnTunDwn.Height = 10%y BtnTunDwn.Width = 43%x BtnTunDwn.Left = 5%x BtnVolDwn.Bottom = BtnL1.Top + 3%y BtnVolDwn.Height = 10%y BtnVolDwn.Width = 43%x BtnVolDwn.Left = 52%x BtnTuneUp.Bottom = BtnTunDwn.Top + 3%y BtnTuneUp.Height = 10%y BtnTuneUp.Width = 43%x BtnTuneUp.Left = 5%x BtnVolUp.Bottom = BtnVolDwn.Top + 3%y BtnVolUp.Height = 10%y BtnVolUp.Width = 43%x BtnVolUp.Left = 52%x BtnOnoff.Bottom = BtnVolUp.Top + 3%y BtnOnoff.Height = 15%y BtnOnoff.Width = 90%x BtnOnoff.Left = 5%x BtnOnoff.Text = "On/Off" BtnTband.Bottom = BtnOnoff.Top + 3%y BtnTband.Height = 10%y BtnTband.Width = 43%x BtnTband.Left = 5%x BtnInput.Bottom = BtnOnoff.Top + 3%y BtnInput.Height = 10%y BtnInput.Width = 43%x BtnInput.Left = 52%x I prawidłowo działał do czasu dodania kilku labelek (tych u góry). Tak to teraz wygląda, niestety nie mam zapisanej poprzedniej wersji gdzie przyciski jeszcze były równo. Program jak narazie nic nie robi gdyż chcę wpierw dopracować layout no ale takie kwiatki wychodzą. Tak wygląda stara wersja programu, mniej więcej chciałbym uzyskać podobny widok ster_pok.zip

Z konieczności utworzenia małego mobilnego systemu pomiarowego, pojawiła się potrzeba połączenia mikrokontrolera z telefonem pracującym na Androidzie, tak aby ten drugi otrzymywał dane z pierwszego. Wybór podstawowej platformy (Android) padł z uwagi na jej powszechność, a także brak konieczności zakupu płytek, czujników itp. Dlatego też chciałbym ośmielić tym artykułem osoby, które noszą się z zamiarem tworzenia projektów, które wymagają dużej ilości dostępnych w telefonach czujników, interfejsów komunikacyjnych i możliwości obliczeniowych, które czasem się marnują, a samo przedsięwzięcie nie przewiduje trwałego montażu telefonu w projektowanym urządzeniu (choć pewnie dużo osób i tak ponownie wykorzystuje te same mikrokontrolery/płytki z czujnikami itd. do kolejnych projektów). Jedną z wad takiego rozwiązania, jest brak zestawu pinów ogólnego przeznaczenia (GPIO) w telefonach. Ten artykuł bierze udział w naszym konkursie! Na zwycięzców czekają karty podarunkowe Allegro, m.in.: 2000 zł, 1000 zł i 500 zł. Potrafisz napisać podobny poradnik? Opublikuj go na forum i zgłoś się do konkursu! Czekamy na ciekawe teksty związane z elektroniką i programowaniem. Sprawdź szczegóły » W kilku słowach niniejszy poradnik przeprowadzi przez proces tworzenia aplikacji na Androida (Java), która będzie komunikować się poprzez wirtualny port szeregowy za pomocą przewodu USB z całkiem nowym Raspberry Pi Pico. Oczywiście, omówiony zostanie również kod w języku C, który będzie sterował stanami logicznymi pinów mikrokontrolera (włączony/wyłączony) na podstawie odczytu wysłanych z telefonu danych. Ponadto będzie on również na żądanie telefonu odczytywał stan logiczny wybranych wejść i wysyłał te informacja, które wyświetlone zostaną w aplikacji mobilnej. Dodatkowo zaznajomi on z przygotowaniem środowiska do kompilacji programów w C/C++ na Raspberry Pi Pico jak i podpowie jak do pewnego stopnia zautomatyzować proces kompilacji i wgrywania programu do mikrokontrolera. Przygotowanie aplikacji na telefon z Androidem Po pierwsze należy pobrać i zainstalować zintegrowane środowisko programistyczne (IDE) Android Studio. Po utworzeniu nowego projektu z domyślną opcją "Empty Activity" i następnie wybranym "API21: Android 5.0 (Lollipop)" w pozycji "Minimum SKD" można zacząć od utworzenia pliku o nazwie "usb_devices.xml" o następującej zawartości (widoczne w pliku wartości wyjaśnione zostaną później): <?xml version="1.0" encoding="utf-8"?> <resources> <usb-device product-id="10" vendor-id="11914" /> </resources> Należy skopiować go do katalogu "app\res\xml" tak jak na zrzucie poniżej. Albo skopiować plik w Eksploratorze Windows i wkleić w Android Studio (może być wymagane utworzenie katalogu "xml" - patrz opcje menu kontekstowego), albo utworzyć bezpośrednio w edytorze Android Studio, czy znaleźć jego lokalizację na dysku (domyślnie "Litera:\Users\Użytkownik\AndroidStudioProjects\NazwaProjektu\app\src\main\res\xml"). Następnie można przystąpić do konfiguracji pliku "AndroidManifest.xml" (do znalezienia jak na zdjęciu powyżej w katalogu "manifests"). Należy wkleić poniższe linijki kodu: <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" /> <meta-data android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" android:resource="@xml/usb_device" /> tak jak pokazano to na zrzucie ekranu: Aplikacja będzie korzystała z zewnętrznej biblioteki usb-serial-for-android, którą należy podłączyć do aplikacji. Zrobić można to edytując najpierw plik "build.gradle (Project)", następnie - "build.gradle (Module)" tak, jak przedstawiono na zdjęciach poniżej: wklejając poniższe linijki: maven { url 'https://jitpack.io' } compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } implementation 'com.github.mik3y:usb-serial-for-android:3.3.0' Teraz można zsynchronizować projekt klikając na "Synch Now" (ostatni rysunek powyżej). Teraz należy wkleić poniższy kod do pliku "app\res\layout\activity_main.xml". Będzie opisywał on wygląd ekranu aplikacji - pole tekstowe i dwa przyciski. <?xml version="1.0" encoding="utf-8"?> <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity"> <TextView android:id="@+id/tekst" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="vendorID productID" android:textSize="29sp" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintHorizontal_bias="0.5" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" /> <Button android:id="@+id/on" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginStart="50dp" android:layout_marginTop="50dp" android:text="ON" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" /> <Button android:id="@+id/off" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="50dp" android:layout_marginEnd="50dp" android:text="OFF" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintTop_toTopOf="parent" /> </android.support.constraint.ConstraintLayout> Teraz przyszła pora na kod programu. Należy otworzyć plik "MainActivity.java" z katalogu "app\java" i zastąpić jego zawartość (poza pierwszą linijką rozpoczynającą się od "package...") tą podaną poniżej. Komentarz zawarte w kodzie opisują "co jest od czego" i ich przestudiowanie da pogląd na to, jak to wszystko działa. // Zaimportowanie używanych przez aplikację klas import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.hardware.usb.UsbDevice; import android.hardware.usb.UsbDeviceConnection; import android.hardware.usb.UsbManager; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.WindowManager; import android.widget.Button; import android.widget.TextView; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; // Zaimportowanie zewnętrzenej biblioteki "usb-serial-for-android" import com.hoho.android.usbserial.driver.CdcAcmSerialDriver; import com.hoho.android.usbserial.driver.ProbeTable; import com.hoho.android.usbserial.driver.UsbSerialDriver; import com.hoho.android.usbserial.driver.UsbSerialPort; import com.hoho.android.usbserial.driver.UsbSerialProber; import com.hoho.android.usbserial.util.SerialInputOutputManager; public class MainActivity extends AppCompatActivity { // Deklaracja zmiennych globalnych - opis w dalszej części kodu TextView poleTekstowe; BroadcastReceiver broadcastReceiver; UsbSerialPort usbSerialPort; SerialInputOutputManager serialInputOutputManager; ScheduledFuture co100Ms; ExecutorService rx; Button on; Button off; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Załadowanie pliku układu okna i elementów aplikacji setContentView(R.layout.activity_main); // Ekran będzie włączony tak długo, jak aplikacja będzie widoczna na głównym planie getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); // Przypisanie pola tekstowego z pliku układu do zmiennej w kodzie aplikacji poleTekstowe = findViewById(R.id.tekst); // Definicja obiektu, który będzie nasłuchiwał zdarzeń związanych z podłączeniem i odłączeniem // miktokontrolera do telefonu broadcastReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { // Przełącznik "switch" - program nie musi sprawdzać po kolei wszystkich "if'ów" czy // "else if'ów", tylko kieruje się do właściwego miejsca za pierwszym podejściem switch (intent.getAction()) { // Obsługa akcji podłączenia urządzeni USB do telefonu case "android.hardware.usb.action.USB_DEVICE_ATTACHED": UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE); UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE); // Wartości, które należy umieścić we wspomnianym wcześniej pliku "usb_device.xml" poleTekstowe.setText(usbDevice.getVendorId() + " " + usbDevice.getProductId()); ProbeTable probeTable = new ProbeTable(); // Przypisanie odpowiedniego dla Pico sterownika probeTable.addProduct(usbDevice.getVendorId(), usbDevice.getProductId(), CdcAcmSerialDriver.class); UsbSerialProber usbSerialProber = new UsbSerialProber(probeTable); UsbSerialDriver usbSerialDriver = usbSerialProber.probeDevice(usbDevice); UsbDeviceConnection usbDeviceConnection = usbManager.openDevice(usbSerialDriver.getDevice()); // Przypisanie wcześniej zdefiniowanego sterownika do wirtualnego portu // szeregowego USB usbSerialPort = usbSerialDriver.getPorts().get(0); try { // Próba otwarcia portu szeregowego dla mikrokontrolera usbSerialPort.open(usbDeviceConnection); // Zdefiniowanie parametrów komunikacji usbSerialPort.setParameters(115200, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE); // Sygnał Data Terminal Ready - Pico i Android rozpocznął komunikację usbSerialPort.setDTR(true); // Sygnał Request To Send - wymaga go np. Arduino do rozpoczęcia komunikacji z Androidem usbSerialPort.setRTS(true); } catch (Exception ignored) {} // Obiekt nasłuchujący danych przychodzących SerialInputOutputManager.Listener serialInputOutputListener = new SerialInputOutputManager.Listener() { @Override public void onRunError(Exception ignored) {} @Override public void onNewData(byte[] data) { runOnUiThread(() -> poleTekstowe.setText(new String(data))); } }; serialInputOutputManager = new SerialInputOutputManager(usbSerialPort, serialInputOutputListener); serialInputOutputManager.setReadTimeout(0); // Definicja pozyższego obiektu jako oddzielnego wątku programu... rx = Executors.newSingleThreadExecutor(); // ...i jego uruchomienie rx.submit(serialInputOutputManager); // Zdefiniowanie osobnego wątku, który będzie wywoływał się do 100 ms wysyłając // porcję danych co100Ms = Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> { try { usbSerialPort.write("o".getBytes(), 0); } catch (Exception ignored) {} }, 0, 100, TimeUnit.MILLISECONDS); break; // Obsługa akcji podłączenia urządzeni USB do telefonu case "android.hardware.usb.action.USB_DEVICE_DETACHED": // Sprzątanie po ustanowionej wcześniej komunikacji do odłączeniu Pico od Androida if (co100Ms != null && rx != null) { co100Ms.cancel(false); serialInputOutputManager.stop(); rx.shutdown(); poleTekstowe.setText("Odłączono"); } break; } } }; // Definicja filtrów podłączone/odłączone urządzenie USB IntentFilter intentFilter = new IntentFilter(); intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED); intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED); // Uruchomienie nasłuchiwania podłączenia/odłączenia urządzenia USB this.registerReceiver(broadcastReceiver, intentFilter); // Definicja przycisków "ON" i "OFF" on = findViewById(R.id.on); on.setOnClickListener(v -> { try { // Wysłanie ciągu znaków do mikrokontrolera usbSerialPort.write("n".getBytes(), 0); } catch (Exception ignored) {} }); off = findViewById(R.id.off); off.setOnClickListener(v -> { try { usbSerialPort.write("f".getBytes(), 0); } catch (Exception ignored) {} }); } // Sprzątanie po ustanowionej komunikacji w momencie zamknięcia (strzałką wstecz) aplikacji @Override protected void onDestroy() { if (co100Ms != null && rx != null) { co100Ms.cancel(false); serialInputOutputManager.stop(); rx.shutdown(); } this.unregisterReceiver(broadcastReceiver); super.onDestroy(); } } Ostatnim krokiem w tej części będzie skompilowanie pliku *.apk aplikacji, który to będzie można zainstalować w telefonie. Wybieramy z menu "Build" pozycję "Generate Signed APK...", wybrać "APK", utworzyć nowy klucz ("Create new..."), wybrać opcję "Build Variants" "release" oraz "Signature Versions" "V2..." i zakończyć kreatora przyciskiem "Finish" - zrzuty poniżej. W powiadomieniu wyświetli się lokalizacja do pliku *.apk. Za jego pomocą można zainstalować aplikację w telefonie. Gotowe! Przynajmniej androidowa aplikacja Pliki do znalezienia tutaj: Android.zip Program dla Raspberry Pi Pico Za wszelką cenę chciałem uruchomić Pico SDK, aby móc zaprogramować "Małą Malinkę" w C i finalnie kopiując plik *.uf2 do widocznej pamięci masowej po podłączeniu jej do komputera trzymając przyciśnięty przycisk "BOOTSEL". Było to zanim powstał skrypt dla Windowsa, a że na Windowsie 7 nie chciał współpracować żaden instalator Microsoftu, to rozwiązałem to w inny sposób. Jak to mówią "the hard way". Po pierwsze nigdy nie zrobiłem nic w C, co więcej oficjalna instrukcja do C/C++ mówiła np. o łatwej konfiguracji chociażby CLion'a. Nie wspominała tylko, że na Linuksie... A więc do rzeczy. Pobieramy następujące składniki: ARM GCC Compiler CMake MinGW Python 3 Raspberry Pi Pico SDK TinyUSB Następnie wypakowujemy je w swojej ulubionej lokalizacji (ja utworzyłem oddzielny folder, gdzie przechowuję binarki programów do "devovania"). Nie ma instalatorów, więc otwarcie mogę się przyznać, że mam niechęć do nich, jak ja coś zrobię, to wiem, gdzie naśmieciłem i łatwiej później posprzątać. Można się przyznawać się, kto też tak ma Co zrobić... A nie, jest MinGW, instalujemy architekturę x86_64. Pierwsze trzy pozycje będą zawierały podkatalog "bin", których ścieżki należy umieścić w systemowej zmiennej "PATH" (Komputer>Właściwości>Zaawansowane ustawienia systemu>Zmienne środowiskowe>Zmienne systemowe) oddzielając je średnikiem. Python 3, tutaj należy podać ścieżkę katalogu głównego. Zawartość TinyUSB kopiujemy do podkatalogu "lib" folderu gdzie wypakowano Raspberry Pi Pico SDK. Można się też pokusić o utworzenie zmiennej użytkownika "PICO_SDK_PATH" zawierającej ścieżkę do wspomniajego w poprzednim zdaniu katalogu. Na zdjęciu tak to wygląda: Pora przygotować właściwe pliki. Najpierw "CMakeLists.txt", który będzie miał zawartość jak poniżej. Należy wspomnieć, że plik"pico_sdk_import.cmake" należy umieścić w katalogu projektu, a znaleźć można go w katalogu zawierającym Raspberry Pi Pico SDK w podfolderze "external". cmake_minimum_required(VERSION 3.17) include(pico_sdk_import.cmake) project(project_name) # nazwa projektu set(CMAKE_C_STANDARD 11) pico_sdk_init() add_executable(project_name file_name.c) # dodanie plików wykonywalnych projektu target_link_libraries(project_name pico_stdlib) pico_enable_stdio_usb(project_name 1) # włączenie połączenia szeregowego USB pico_enable_stdio_uart(project_name 0) # wyłączenie UART pico_add_extra_outputs(project_name) Teraz tworzymy długo wyczekiwany plik *.c taki jak wskazany w "CMakeLists.txt" plik wykonywalny. Jego zawartość będzie jak poniżej. Komentarze rozjaśnią sprawę. #include <stdio.h> #include "pico/stdlib.h" int main() { stdio_init_all(); // Użycie pinu GP25 (dioda LED na płytce) gpio_init(25); // Ustawienie GP25 jako wyjścia gpio_set_dir(25, GPIO_OUT); gpio_init(0); // Ustawienie GP0 jako wejścia gpio_set_dir(0, GPIO_IN); gpio_init(1); gpio_set_dir(1, GPIO_IN); // Podciąga GP1 poprzez wbudowany w czip RP2040 opornik - stan wysoki (1), gdy nie podłączony do masy (GND) gpio_pull_up(1); // Bufor dwóch znaków. Efektywnie jednego, drugi to znak terminalny "\0" // Jeśli chcesz odczytać 5 znaków, ustaw należy ustawić bufor na 6 char wiadomosc[2]; while (true) { // Odczytuje dwa znaki (łącznie z terminalnym) w wejścia. Jeśli chcesz odczytywać wiadomości // ze zmienną ilością znaków, użyj "gets(wiadomosc)" zamiast "fgets(wiadomosc, 2, stdin)" // i zakończ wysyłane wiadomości znakiem kowej linii - "\n" fgets(wiadomosc, 2, stdin); // Odczytuje pierwszy znak (indeks [0]) wektora zawierającego wiadomość. // Java może porównać cały ciąg w instrukcji "switch" ;P switch(wiadomosc[0]) { case 'n': // Włącza diodę led przy wiadomości "n" ze standardowego wejścia gpio_put(25, 1); break; case 'f': // Wyłącza diodę led przy wiadomości "f" ze standardowego wejścia gpio_put(25, 0); break; case 'o': // Odczytuje wartości stanów GP0 i GP1 - wysoki (1) lub niski (0) // i wysyła je przez połączenie szeregowe printf("GP0: %d, GP1: %d", gpio_get(0), gpio_get(1)); break; } } } Do kompilacji przygotujemy plik wsadowy *.bat, który ułatwi zautomatyzuje kompilację. Jego zawartość będzie następująca: @echo off mode con: cols=130 lines=32 for %%i in (%1) do (set sciezka=%%~pi) for %%i in (%1) do (set litera=%%~di) cd /d "%litera%%sciezka%" cmake.exe -DCMAKE_BUILD_TYPE=Release -G "CodeBlocks - MinGW Makefiles" "%litera%%sciezka%" cmake.exe --build "%litera%%sciezka%" robocopy "%litera%%sciezka% " "G:\ " "*.uf2" /nfl /ndl /njh /njs /np pause Należy zmienić literę "G:\ " na tą, pod którą pojawi się dysk wymienny Pico. Spacje nie są błędem. Dziwna sprawa, ale inaczej nie chce działać, przynajmniej na Siódemce, a dodanie spacji na końcu było rozwiązaniem. Przygotowany plik chowamy przed wzrokiem i np. programem Default Programs Editor tworzymy pozycję w menu kontekstowym pliku *.c a jeszcze lepiej tworzymy nowe rozszerzenie dla plików C Pico. Albo kompilujemy wykorzystując dwie linijki zaczynające się od "cmake.exe", albo korzystamy ze szpanerskiego menu, a efekt kompilacji będzie następujący: Pliki do znalezienia tutaj: Pico.zip Pierwsze uruchomienie Po uruchomieniu aplikacji na telefonie i podłączeniu Pico przez kabel USB i adapter OTG należy zgodzić się, aby aplikacja uruchamiała się wraz z podłączeniem mikrokontrolera do smartfona. Nada to uprawnienia do korzystania z połączenia USB aplikacji. Pola "vendorID" i "productID" zmienią swoje wartości na te, które trzeba było umieścić we wspomnianym wcześniej pliku "usb_devices.xml". Po odłączeniu i ponownym podłączeniu (w trakcie działania aplikacji mobilnej, gdyż w androidowej aplikacji odczyt od cykliczne nadawanie zakodowane jest po podłączeniu urządzenia, ale tym zdefiniowanym w pliku "MainActivity.java", który wykonuje się po jej uruchomieniu) Malinki będzie można włączyć i wyłączyć jej diodę LED (GP25) i co 100 ms (na żądanie telefonu) będzie odczytywany stan wejść GP0 i GP1. Jak to działa, na zdjęciach poniżej. Zwarcie pinów GP0 (1) i 3V3OUT (36) ustawi stan wysoki na wejściu GP0, a połączenie GP1 (2) z GND (3) przesteruje normalnie wysoki stan do niskiego. Gotowe pliki wykonywalne tutaj: Binarki.zip Podsumowanie Niniejszy artykuł nie jest projektem od A do Z jakiegoś przedsięwzięcia, tylko przedstawia zagadnienie komunikacji portem szeregowym pomiędzy mikrokontrolerem (tutaj Raspberry Pi Pico, choć nie musi to być on) a telefonem komórkowym z Androidem wykorzystując natywne rozwiązania tworzenia programów na te platformy, tym samym nie będąc na "łasce" np. rozwiązań modułowych tworzenia aplikacji z klocków, wykorzystując wszystkie możliwości jakie daje Android, Pico, Java i C. Oczywiście to tylko zalążek, ale nie znalawszy gotowego rozwiązania, zmotywowało mnie to, żeby takie zrobić i zaprezentować, ktoś może mieć łatwiej. Ja już mam łatwiej, bo takiego potrzebuję PS. Nie spodziewałem się, że tak długo zajmie mi napisanie tego tekstu... PS2. Nazwa aplikacji mobilnej to taka losowo wklepana na klawiaturze. PS3. Pierwszy obrazek, drugi kod i trzy następne obrazki to trochę ludzik, trochę android

W ostatnim czasie zorientowałem się, że trochę życie by mi ułatwiło urządzenie, które pozwoliło by mi sterować odtwarzaczem multimediów odpalanym na urządzeniu (telefonie) z Androidem. Całość byłoby niewielkim pilotem podobnym do tych znanych ze standardowych słuchawek np. takich: Widzimy tam po prawej stronie pilot do sterowania głośnością oraz włączaniem i zatrzymywaniem odtwarzacza. Chciałbym zrobić coś podobnego w formie niewielkiej płytki z kilkoma przyciskami fizycznymi działającej najlepiej bezprzewodowo (komunikacja poprzez Bluetooth). Funkcje o których myślę to zwiększanie i zmniejszanie głośności (2 przyciski: [+] i [-]), pauza/start (1 przycisk) i jeśli się da oraz jeśli odtwarzacz to obsługuje to szybkie cofanie się lub przeskakiwanie o kilka sekund do przodu w zależności od odtwarzacza (2 przyciski: [>] i [<]). Słuchawki z obrazka sam posiadam i ten pilot działa z wieloma odtwarzaczami - aplikacja YouTube, TuneIn i wiele innych. Mnie interesuje podobna funkcjonalność tj. kompatybilność z wieloma odtwarzaczami. Moje pytania to: 1. Jakie elementy elektroniczne będą potrzebne do wykonania urządzenia. 2. Jakie oprogramowanie będzie potrzebne (łącznie z technologiami i językami programowania). 3. Jaki jest poziom skomplikowania projektu - do ogarnięcia dla początkującego, średnio zaawansowanego, eksperta itd. Będę wdzięczny za wszelką pomoc. Informacje ogólne jak działają tego typu piloty i w jaki sposób potrafią działać z różnymi odtwarzaczami też będą pomocne.

Dzień dobry, W swoim pierwszym wpisie, chciałbym przedstawić własną wersję sterownika światła sterowanego za pomocą aplikacji na androida. Sam sterownik składa się z: NodeMCU MODUŁ 2 PRZEKAŹNIKÓW 5V Dwóch przycisków Wspomagając się powyższym rysunkiem, zmontowałem całość korzystając z płytki uniwersalnej. NodeMCU łączy się z lokalną siecią WiFi. Do sterowania wykorzystuje bibliotekę aREST udostępniając funkcje on, off i get przyjmujące jako parametr numer przekaźnika. Kod w wersji skróconej i zdjęcia urządzenia do podejrzenia poniżej. // Rest and esp library #include <ESP8266WiFi.h> #include <aREST.h> // WiFi parameters const char* ssid = "ssid"; const char* password = "password"; const int SWITCH1 = 5; const int SWITCH2 = 16; const int RELAY1 = 12; const int RELAY2 = 14; const unsigned long INTERVAL = 500; bool relay1State = LOW; bool relay2State = LOW; bool switch1State = LOW; bool switch2State = LOW; unsigned long currentMillis = 0; unsigned long switch1Millis = 0; unsigned long switch2Millis = 0; aREST rest = aREST(); const int LISTEN_PORT = 80; WiFiServer server(LISTEN_PORT); int onControl(String value); int offControl(String value); int getControl(String value); void setup(void) { rest.set_id("10"); rest.set_name("Light Switches"); Serial.begin(115200); pinMode(SWITCH1, INPUT); pinMode(SWITCH2, INPUT); pinMode(RELAY1, OUTPUT); pinMode(RELAY2, OUTPUT); digitalWrite(RELAY1, !relay1State); digitalWrite(RELAY2, !relay2State); rest.variable("light1", &relay1State); rest.variable("light2", &relay2State); rest.function("on", onControl); rest.function("off", offControl); rest.function("get", getControl); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("Light Switches connected"); server.begin(); Serial.println("Light Switches address"); Serial.println(WiFi.localIP()); } void loop() { currentMillis = millis(); if (currentMillis - switch1Millis >= INTERVAL && digitalRead(SWITCH1)) { switch1State = !switch1State; if(switch1State==HIGH){ digitalWrite(RELAY1, LOW); relay1State = !LOW; } if(switch1State==LOW){ digitalWrite(RELAY1,HIGH ); relay1State = !HIGH; } switch1Millis = currentMillis; } if (currentMillis - switch2Millis >= INTERVAL && digitalRead(SWITCH2)) { switch2State = !switch2State; if(switch2State==HIGH){ digitalWrite(RELAY2, LOW); relay2State = !LOW; } if(switch2State==LOW){ digitalWrite(RELAY2,HIGH); relay2State = !HIGH; } switch2Millis = currentMillis; } WiFiClient client = server.available(); if (!client) { return; } while (!client.available()) { delay(10); } rest.handle(client); } int onControl(String value) { if (value=="0") { digitalWrite(RELAY1, LOW); relay1State = !LOW; switch1State = HIGH; return 0; } if (value=="1") { digitalWrite(RELAY2, LOW); relay2State = !LOW; switch2State = HIGH; return 0; } return -100; } int offControl(String value) { if (value=="0") { digitalWrite(RELAY1, HIGH); relay1State = !HIGH; switch1State = LOW; return 0; } if (value=="1") { digitalWrite(RELAY2, HIGH); relay2State = !HIGH; switch2State = LOW; return 0; } return -100; } int getControl(String value) { if (value=="0") { return relay1State; } if (value=="1") { return relay2State; } return -100; } Aplikacja składa się z czterech ekranów. Pierwszy to przełączanie żarówki przez przytrzymanie odpowiadającego jej pola na ekranie. Dwa kolejne odpowiadają za włącznie i wyłączenie wszystkich żarówek jednocześnie. Ostatni odpowiada za dodawanie i usuwanie połączeń, czyli wprowadzamy nazwę, adres urządzenia i numer przełącznika. Problemy i dalszy rozwój Jestem zadowolony z działania sterownika jedyny problem, jaki zaobserwowałem to przełączanie się przekaźników podczas podłączania innych urządzeń do przedłużacza, do którego jest wpięty. W aplikacji do bieżącej funkcjonalności chcę dodać włącznie wcześniej zdefiniowanych grup żarówek. I dodać nową funkcjonalności w postaci sterowania taśmami led, możliwość włączenia komputera, a także zakładkę gromadzącą wartości z czujników. Cały kod i aplikacja znajduje się w moim repozytorium

Witam Serdecznie, jestem nowicjuszem i proszę o pmoc. Po podłączeniu Telefonu z Androidem*dowolnego) przez bluetooth mam opcję połączeń przychodzących i wychodzących. Mogę ustawić tylko połączenia wychodzące i ustawi mi się np port com 11 a przychodzących już nie ustawię ponieważ pewnie android nie obsługuję takiej opcji. (testowałem kiedyś b2710 solid i tam mogę to ustawić bez problemu ale to już inna bajka) streszczając Czy jest możliwość połączenia się przez bluetooth za pomocą Arduino? żeby móc ustawić te połączenia w aplikacji na komputerze żeby był np com 12? dla mnie to czarna magia i się na tym nie znam dziękuję z góry?