Przeszukaj forum

Nie mogę wgrać żadnego programu na płytkę. Najpierw ładuje się bardzo długo a potem wywala błąd avrdude: stk500_recv(): programmer is not responding i temu podobne zaczynające się na avrdude: . Wszystko szło bardzo dobrze robiłem już drugą część kursu arduino aż pewnego dnia nic nie mogę wgrać. próbowałem już zmiany kabla, prze instalowanie arduino, tak port jest wybrany dobry, uruchomienie arduino jako administrator i uruchomienie portu szeregowego (zawiesiło mi komputer i nie mogę teraz zamknąć tego okienka), przytrzymywanie przycisku reset podczas wgrywania na płytkę(zdaje się że wywaliło wtedy trochę inny błąd) mam podejrzenia co do botloadera ale na razie nie mam odpowiedniego kabla żeby wypalić na nowo proszę o pomoc bo zbliża się turniej robotyki a ja jestem z nie działającą płytką😧

Witam państwa😉 jako że jestem stanowczym człowiekiem i jeszcze trzy dni temu obiecywałem sobie że nie będę się uczył nowych rzeczy, lub takich których nie będę używał w najblizszej przyszlosci jak np. freeRTOS, tak że ten......no od dwóch dni piłuję temat freeRTOS'a😜 i mam w związku z tym kilka pytań, pierwsze.. Tworząc zadania, zadania te uruchomią się automatycznie czy potrzebuje jeszcze wywołać vTaskStartScheduler Bo znalazłem wiele przykładów gdzie ta funkcja jest wywoływana lub nie jest i działa...też wyczytałem różne opinie że jest potrzebna ta funkcja, lub że nie jest potrzebna bo utworzone zadanie startuje automatycznie..jak to jest z tym?

cześć, potrzebuje pomocy z programem do sterowania rębaka no stress. Większość kodu zrobiłem lecz coś nie działa program i nie mam pomysłu co jest nie tak. program ten ma za zadanie po wykryciu 3000 obrotów RPM włączyć przekaźnik sterowania silnikiem do przodu, lecz gdy obroty spadną do 1000 ma on włączyć na 0,5s przekaźnik silnika do tyłu i go zatrzymać. Po osiągnięciu obrotów 3000 ma on od nowa uruchomić silnik do przodu. pin awaria - wyłącznik bezpieczeństwa(wyłącza oba silniki) zmienna walek - włączanie wyłączanie silnika do przodu prowizorycznie RPM zmieniam wartością zmiennej //#define czujnik 2 // - w projekcie obrotomierz jest jako RPM //#define walek 6 //(OPCJONALNIE) czy jest wlaczony walek #define awaria 5 // wyłącza posów #define cewkaPrzod 3 // przekaznik wlaczajacy posow w przod #define cewkaTyl 4 // przekaznik wlaczajacy posow w tyl int RPM = 3001; int a = 0; bool walek; void setup(){ //pinMode(czujnik, INPUT_PULLUP); //pinMode(walek, INPUT_PULLUP); // wlaczyc jesli jest czujnik wałka pinMode(awaria, INPUT_PULLUP); pinMode(cewkaPrzod, OUTPUT); pinMode(cewkaTyl, OUTPUT); } void loop(){ walek = false; if(walek == true){ digitalWrite(cewkaPrzod, HIGH); } if(walek == false){ digitalWrite(cewkaPrzod, LOW); } walek = false; digitalWrite(cewkaTyl, LOW); //digitalWrite(cewkaPrzod, LOW); while(digitalRead(awaria) == HIGH){ if(a == 0 && RPM < 1000) { walek = false; digitalWrite(cewkaTyl, HIGH); delay(500); digitalWrite(cewkaTyl, LOW); a = a + 1; } if(RPM > 3000){ walek = true; a = 0; } } }

Witam, W trakcie robienia projektu (pojazd sterowany pilotem przez Bluetooth) napotkałem problem z nowo kupionym Arduino Nano Every (piny lutowałem sam). Chciałem, aby na pinach cyfrowych (podpiętych do przycisków) odczytywane było napięcie (HIGH lub LOW). Arduino z ustawionymi pinami na INPUT odczytuje stan wysoki - zawsze, choć powinien być stan niski. Wszystko działa dobrze po ustawieniu pinów na OUTPUT. Czy tak powinno być? Z tego co wiem to ustawienie na INPUT służy do odczytu, a odczyt z pinu ustawionego na OUTPUT powinien skończyć się błędem. Dla testu napisałem program: const int pinOut = 6; const int pinIn = 7; void setup() { Serial.begin(9600); pinMode(pinOut, OUTPUT); pinMode(pinIn, INPUT); } void loop() { //Odczyt z pinu 6 if(digitalRead(pinOut) == LOW) { Serial.println("Pin 6: LOW"); } //Odczyt z pinu 7 if(digitalRead(pinIn) == LOW) { Serial.println("Pin 7: LOW"); }else { Serial.println("Pin 7: HIGH"); } delay(1000); } Arduino jest podłączone tylko do komputera, żadne piny nie są połączone. A tutaj wynik: Pin 6: LOW Pin 7: HIGH Pin 6: LOW Pin 7: HIGH Pin 6: LOW Pin 7: HIGH Pin 6: LOW Pin 7: HIGH Pin 6: LOW Pin 7: HIGH Pin 6: LOW Pin 7: HIGH Czy to ja się mylę, czy np. płytka jest uszkodzona? Z góry dziękuję za pomoc.

We wrześniu pojawiła się stabilna wersja Arduino IDE 2.0.0. Osobiście polecam budowanie ze źródeł, ale dostępne są również prekompilowane wersje binarne Wersje prekompilowane: https://arduino.cc/en/software Repozytorium na Github ze źródłami: https://github.com/Arduino/arduino-ide A poniżej, skompilowane i uruchomione przeze mnie środowisko IDE, zrzut ekranu W razie problemów, chętnie pomogę(udzielę porad) w skompilowaniu po OS Linux

Hej, próbuje wysłać przez kolejkę na FreeRTOS strukturę wraz z rozróżnieniem dwóch tasków wysyłających i jednym odbierającym. Tak wygląda mój kod: #include "queue.h" typedef int taskProfiler; typedef enum { eSender1 = 0, eSender2, }DataSource_t; typedef struct { uint8_t ucValue; DataSource_t eDataSource; }Data_t; static Data_t xStructToSend[2] = { (100, eSender1), (50, eSender2) }; QueueHandle_t xQueue; taskProfiler senderTaskProfiler = 0; taskProfiler receiverTaskProfiler = 0; void setup() { // put your setup code here, to run once: Serial.begin(115200); delay(5000); Serial.println(xStructToSend[1].ucValue); xQueue = xQueueCreate(3, sizeof(Data_t)); xTaskCreate(vSenderTask, "Sender Task 1", 8192, &(xStructToSend[0]), 2, NULL); xTaskCreate(vSenderTask, "Sender Task 2", 8192, &(xStructToSend[1]), 2, NULL); xTaskCreate(vReceiverTask, "Receiver Task", 8192, NULL, 2, NULL); } void vSenderTask(void *pvParameters) { BaseType_t xStatus; const TickType_t xTicksToWait = pdMS_TO_TICKS(100); Data_t xReceivedStructure; memcpy(&xReceivedStructure, &pvParameters, sizeof(pvParameters)); while(1) { xStatus = xQueueSend(xQueue, pvParameters, xTicksToWait); if(xStatus != pdPASS) { Serial.println("Could not send to the Queue"); } Serial.println(xReceivedStructure.ucValue); } } void vReceiverTask(void *pvParameters) { Data_t xReceivedStructure; BaseType_t xStatus; while(1) { xStatus = xQueueReceive(xQueue, &xReceivedStructure, 0); if(xStatus == pdPASS) { if(xReceivedStructure.eDataSource == eSender1) { Serial.print("This is from Sender1: "); Serial.println(xReceivedStructure.ucValue); } else { Serial.print("This is from Sender2: "); Serial.println(xReceivedStructure.ucValue); } } else { Serial.println("Could not receive data from the queue"); } } } void loop() { // put your main code here, to run repeatedly: } W "setup()" linia "Serial.println(xStructToSend[1].ucValue);" zwraca mi wartość 0 chociaż teoretycznie powinna 50. Tak samo dzieje się w tasku wysyłającym w linii "Serial.println(xReceivedStructure.ucValue);". Wyglada jakby od samego początku była zła inicjalizacja wartości zmiennych w wysyłanej strukturze. Sam task Receiver zwraca wartość 152 lub 160. Jaki błąd został popełniony w tym kodzie i w jaki sposób prawidłowo mogę zainicjalizować zmienne w strukturze? Z góry dziękuje za pomoc. Pozdrawiam

Witam serdecznie, pracuję nad pewnym projektem i ze względu na niedostateczne umiejętności programowania w C, postanowiłem wykorzystać ArduinoIDE z bliblioteką esp32 do zaprogramowania układu ESP32-C3, zamiast dedykowanego przez producenta frameworka ESP-IDF. Tutaj pojawia się moje pytanie, w jaki sposób przebiega kompilacja takiego projektu w ArduinoIDE ? Czy projekt, który wgrywamy po przez ArduinoIDE de facto też jest zcustomizowanym firmwarem ? czy może to jest instrukcje w c++ uruchamiane są na dedykowanym firmwarze ? Kolejna sprawa: czy gdy wgrywamy nasz program do pamięci płytki to z każdym razem wgrywany jest nowy firmware, czy tylko podmieniany jakiś segment pamięci ? Niestety nie mam specjalistycznej wiedzy w tej materii, dlatego zależy mi na wyjaśnieniu tej kwestii.

Witam wszystkich!!! W poprzednim artykule przedstawiłem swoją wizję platformy Arduino UNO opartej o procesor ATmega 328 THT. Wizja nie do końca doskonała, choć dla mnie na chwilę obecną wystarczająca. Chciałem teraz, aby to było coś wyróżniającego się na tle klonów tej platformy. Coś z powiewem świeżości, nowego!!!. Bo nie sztuką jest zrobić klon 1:1 i to tylko aby zbić cenę a nieraz wykonanie niektórych klonów pod względem jakości jak i działania pozostawiało wiele do życzenia. Pierwsza wersja mojego urządzenia była tak naprawdę tylko wstępem do tego co teraz zamierzałem zrobić, co tym bardziej zachęciło mnie do zrobienia ostatecznej wersji mojego urządzenia. Wersji, która uważam zawiera ciekawe rozwiązania, których mi osobiście brakowało a na pewno znajdą się osoby, które myślą podobnie. Bo czym jest poświęcenie jednej ATmegi, której koszt wynosi mniej niż 10 PLN aby na stałe była zaprogramowana jako programator ISP , dzięki czemu możemy swobodnie wgrywać bootloader do drugiej wymiennej ATmegi, nie używając do tego dedykowanego shielda lub łącząc układ na płytce stykowej. Wygodnie prawda?. Możliwość podłączenia dowolnego konwertera, którego koszt nieraz jest mniejszy niż procesor ATmega 16U2, który dodatkowo trzeba zaprogramować lub inny układ odpowiadający za komunikację. A jako, że takie konwertery są tanie to opłaca się kupić kilka sztuk na tak zwaną "czarną godzinę" lub gdy mamy kilka projektów, które z nich korzystają. Na początku kilka słów samokrytyki!!! Pewne rozwiązania były zrobione na szybko. Owszem działały jednak na przykład: przełączanie zasilania z USB na zasilacz za pomocą przekaźników ogólnie nie jest idealne jak w oryginalnej platformie. Szczerze dla mnie osobiście to akurat było bez znaczenia gdyż tu sugerowałem się posiadanymi przeze mnie elementami oraz tym, że mi osobiście reset procesora nie przeszkadzał w momencie przełączania zasilania z USB za zasilacz i odwrotnie, ale jednak względem oryginalnej platformy, funkcjonalność ta znacznie odbiegała. Tak więc skoro moja wizja ma dorównać a docelowo być lepsza od oryginału i jego klonów, zatem działanie pewnych elementów urządzenia musi być takie samo. Poniżej kilka zdjęć nowej wersji MWuinoUNO-rev3.1 W przedstawionej przeze mnie wersji zrezygnowałem z użycia konwertera, a komunikację z procesorami wykonałem z użyciem układu FTDI232RQ. W plikach urządzenia, przygotowałem łącznie cztery wersje urządzenia. Plik do pobrania jest na końcu artykułu. Pierwszą wersję Rev3.1, którą aktualnie będę przedstawiał z użyciem FTDI 232RQ. Drugą wersja Rev3.2, także z użyciem FTDI232RQ, z tym, że zastosowany jest wydajniejszy stabilizator dla linii 5V - LM340MP-5.0/NOPB o wydajności prądowej 1,5A. Kolejne dwie wersje Rev4.1 oraz Rev4.2 gdzie do komunikacji możemy wykorzystać konwerter, tak jak miało to miejsce w prezentowanej jakiś czas temu pierwszej odsłonie mojego urządzenia, z tym że podobnie jest podobnie jak w Rev3.2, Rev4.2 ma wydajniejszy stabilizator dla linii 5V. Powstanie dodatkowych Rewizji 3.2 oraz 4.2 było podyktowane innymi rolami wyprowadzeń stabilizatora dla linii 5V - LM340MP-5.0/NOPB niż ma stabilizator NCP1117ST50T3G. Zatem obu tych stabilizatorów nie można używać zamiennie w tym przypadku. Podsumowując!!! Poprawiłem pewne niedostatki z wersji pierwszej wprowadzając odpowiednie modyfikację. Przejrzałem dostępne klony platformy UNO R3 z ATmegą 328 THT oraz ciekawe rozwiązania zaadaptowałem w swojej wersji urządzenia oraz dodałem drobne funkcje od siebie. Poniżej zdjęcia prezentujące pierwszą wersję urządzenia MWuinoUNO Rev.1 oraz aktualna prezentowana wersja MWuinoUNO Rev3.1 Uważam, że wszystko jest jak należy i więcej nic nie potrzeba dodawać. Urządzenie jest zbliżonych rozmiarów względem oryginału, a oferuje znacznie więcej niż oryginalna platforma lub jej klony. najważniejszą zaletą jest wygoda!!! W końcu dla hobbystów jak i amatorów wyeliminowanie pewnych rzeczy, które mogą nas irytować uważam że jest ważne. W końcu dla mnie elektronika oprócz zarabiania na życie to pasja, a ta raczej powinna nam zapewnić spokój i skupienie się na tym co robimy. Wiadomo, że nie jesteśmy w stanie wszystkiego przewidzieć, ale zawsze możemy próbować eliminować pewne niedogodności z tym związane. Przejdźmy zatem do omówienia mojego projektu. Porównajmy teraz moją wersję platformy Uno z oryginalną i jej wiernie wykonanymi klonami. Najważniejsze różnice są przedstawione poniżej: Cecha: UNO R3 oraz klony 1:1 MWuinoUNO Rev3.1 MWuinoUNO Rev3.2 MWuinoUNO Rev4.1 MWuinoUNO Rev4.2 Napięcie pracy 5V 5V/3,3V 5V/3,3V 5V/3,3V 5V/3,3V Jumper Bootloader Nie Tak Tak Tak Tak Złącze USB USB B micro USB micro USB nie dotyczy-brak nie dotyczy-brak Włącznik zasilania Nie Tak Tak Tak Tak Wyjście 3,3V* Prąd 150mA Prąd 300/500mA Prąd 300m/500mA Prąd 300/500mA Prąd 300/500mA Wyjście 5V Prąd 1A Prąd 1A Prąd 1,5A Prąd 1A Prąd 1,5A Oscylator Ceramiczny Kwarcowy Kwarcowy Kwarcowy Kwarcowy Wgrywanie bootloaderów Tylko z użyciem shielda Tak Tak Tak Tak lub podłączonego układu na płytce stykowej Sterownik USB ATmega16U2 FT232RQ FT232RQ UART/RS232 TTL UART/RS232 TTL konwerter konwerter Sterowanie diodą (L) wzmacniacz operacyjny MOSFET BSS138 MOSFET BSS138 MOSFET BSS138 MOSFET BSS138 *- Montujemy jeden z dwóch stabilizatorów w zależności od naszych potrzeb. Ze względu na to, że ich wyprowadzenia pełnią taką samą rolę można ich używać zamiennie. W prezentowanej wersji zamontowany jest stablizator o wydajności 300mA, gdyż 500mA na chwilę zamawiania elementów do montażu, nie był dostępny. Napięcie pracy: 5V/3,3V Przełącznik konfiguracji napięcia 3,3V/5V: ustala jakim napięciem jest zasilany mikrokontroler a tym samym z jaka logiką pracuje cały system, do wyboru 3,3V lub 5V. Jumper Bootloader: W trybie ON płytka się zresetuje po podłączeniu napięcia zasilania lub portu USB. W trybie OFF : program zapisany ruszy natychmiast po podłączeniu zasilania, płytka nie zresetuje się po podłączeniu portu USB do PC. Złącze USB: Możliwość użycia popularnego mniejszego kabla micro USB używanego w większości smartphonów, itp. Włącznik zasilania: Aby odłączyć urządzenie od zasilania nie trzeba już wyciągać wtyczki z gniazda. Można to zrobić włącznikiem ON/OFF. Wyjście 3,3V: MWuinoUNO zapewnia wyższą wydajność prądową stabilizatora 3,3V. Wyjście 5V: MWuinoUNO w Rev3.2 oraz Rev4.2 zapewnia wyższą wydajność prądową stabilizatora 5V. Oscylator: Rezonator kwarcowy zapewnia wyższą dokładność taktowania. Wgrywanie bootloaderów: W MWuinoUNO wystarczy do podstawki IC2 włożyć czysty procesor i wykonując odpowiednie czynności wgrać bootloader. Sterownik USB: Układ FT232 w MWuinoUno jest wspierany w każdym popularnym systemie operacyjnym lub wersja bez układu komunikacji FT232, gdzie możemy podłączyć dowolny konwerter UART/RS232 TTL. Sterowanie diodą (L): Sterowanie diodą LED w UNO i klonach podyktowane jest oszczędnością a tym samym wykorzystaniem drugiego wzmacniacza operacyjnego gdyż LMV358 zawiera dwa wzmacniacze. To zastosowanie ma pewne wady takie jak, że wzmacniacz operacyjny nie przenosi pełnego pasma sygnału CLK. Tak więc jasność LED nie będzie dobrze oddawała pinu CLK. Lepiej do tego celu nadaje się tranzystor, który steruje LED-em. Tranzystory MOSFET są sterowane napięciowo, więc podobnie jak wzmacniacz w konfiguracji wtórnika emiterowego, nie obciąża sygnału z pinu CLK. Tutaj też się przyznam, że większość z rozwiązań są skopiowane. Po przejrzeniu klonów platformy UNO wybrałem te użyteczne. Fakt faktem nie było tego dużo, więc wybrałem prawie wszystkie. Moje rozwiązania to tak jak w pierwszej odsłonie projektu zintegrowanie programatora ISP, dzięki, któremu możemy wgrywać bootloader do wymienialnego procesora IC2. Urządzenie posiada także sygnalizację zasilania z USB diodą LED. Rozwiązanie to niesie ze sobą dodatkową korzyść. Jak widać na schemacie załączonym w pliku: MWuinoUNO.zip - na przykład Rev3.1. Dioda LED USB jest sterowana stanem niskim wzmacniacza operacyjnego, pełniącego rolę komparatora. Generalnie do porównywania napięć przeznaczone są do tego celu komparatory. Jako, że nie mam ostatnio czasu bawić się w eksperymenty zastosowałem coś co jest sprawdzone i działa choć tutaj zastosowałem wzmacniacz, który był użyty w poprzedniej wersji do sterowania dioda użytkownika (L). Dobierając wtedy ten wzmacniacz patrzyłem pobieżnie na pewne parametry, ale zaryzykowałem i przy okazji postanowiłem zobaczyć czy się sprawdzi. No i jak widać wszystko działa dobrze. Teraz napiszę na czym polega dodatkowa korzyść z zastosowania diody LED USB oraz jej sterowania z wyjścia wzmacniacza. Rozwiązanie ze wzmacniaczem w roli komparatora jest skopiowane. Przeanalizujmy najpierw działanie wzmacniacza operacyjnego (IC10) w roli komparatora. Opis ten odnosi się do rev3.1 oraz 4.1, gdzie rezystory R18,R19 dzielnika napięć mają jednakową wartość rezystancji-10k. Zatem: Napięcie z zasilacza (VIN) jest podane na dzielnik napięcia złożonego z rezystorów R18, R19 o wartości 10 kOhm każdy, który działa w proporcji 1:2. Napięcie mierzone przez wzmacniacz (na wejściu nieodwracającym +) jest na rezystorze R19 dzielnika i jest porównywane z napięciem wzorcowym 3,3V mierzonym na (wejściu odwracającym -) wzmacniacza, które pochodzi z dodatkowego stabilizatora (IC5). Więc jeśli napięcie zasilania (VIN) jest równe lub nieco wyższe od 6,6V, tranzystor T1 nie jest sterowany z wyjścia wzmacniacza i tym samym nie przewodzi. Dioda LED USB nie świeci i do zasilania całego urządzenia wykorzystywany jest zasilacz. Najprościej rzecz ujmując: Napięcie na rezystorze R19 osiąga wartość 3,3V przy napięciu zasilania równym lub nieco wyższym od (VIN)=6,6V. Wyjście wzmacniacza operacyjnego sterującego tranzystorem T1 i diodą LED USB jest w stanie wysokim przez co tranzystor ten nie przewodzi oraz nie świeci dioda LED USB, co informuje nas, że do urządzenia podłączone jest zewnętrzne zasilanie, które także zasila nam całe urządzenie. Tutaj kluczowa jest też wartość napięcia zasilacza ze względu na minimalną wartość napięcia zasilania stabilizatora 5V. Standardowy stabilizator zastosowany w UNO i niektórych jego klonach na wejściu potrzebuje minimum 6,5V aby na jego wyjściu napięcie stabilizowane, którym zasilane są wszystkie podzespoły urządzenia, wyniosło 5V. W przypadku zastosowania stabilizatora LM340MP-5.0/NOPB minimalne napięcie zasilania tego stabilizatora wynosi 7,5V. Zatem aby urządzenie przełączało nam zasilanie z USB na zasilacz i tym samym aby mieć napięcie 5V na wyjściu tego stabilizatora, musimy zmienić wartość jednego z rezystorów dzielnika napięcia tak aby przy napięciu zasilania z zasilacza - 7,5V na rezystorze R19, napięcie wynosiło 3,3V. Zatem od czego najpierw zaczynamy. Z poniższego rysunku, (aby było nam łatwiej ustalić parametry dzielnika) widzimy, że musimy ustalić: Spadki napięć "UR18", "UR19" na rezystorach, prąd "Ir" płynący przez rezystory naszego dzielnika oraz wartość rezystancji "R18". Pierwszym krokiem będzie ustalenie rozkładu napięcia VIN na poszczególnych rezystorach dzielnika. Jako że wejście nieodwracające (+) wzmacniacza jest podłączone pomiędzy R18 a R19 to znaczy, że wzmacniacz mierzy napięcie na R19. Wiemy, że napięcie na R19 ma wynieść 3,3V przy napięciu zasilania VIN=7,6V. Zatem UR19=3,3V Znając napięcie na R19 Obliczymy teraz spadek napięcia jaki musi być na R18. Wystarczy, że od napięcia VIN odejmiemy napięcie na R19 UR18=VIN-UR19=6,7V-3,3V=4,3V. Zatem spadek napięcia na R18 wynosi 4,3V. Jak widać napięcie VIN jest sumą spadków napięć na poszczególnych rezystorach naszego dzielnika zatem: VIN=UR18+UR19=4,3V+3,3V=7,6V. Ustalamy wartość jednego z rezystorów dzielnika. Jest to istotne aby obliczyć prąd płynący przez dzielnik. Dla ułatwienia wybrałem R19 i niech będzie miał on wartość 10k. Jak widać dzielnik napięcia to po prostu połączone ze sobą dwa rezystory szeregowo. Cechą szeregowego połączenia rezystorów jest to, że płynie przez nie ten sam prąd "Ir". Zatem znając wartość rezystora R19 i spadek napięcia na nim, możemy obliczyć prąd "Ir" płynący przez oba rezystory, korzystając z prawa Ohma I=U/R zatem Ir=UR19/R19=3,3V/10k=0,33mA Z kolei znając wartość prądu płynącego przez rezystory R18, R19 dzielnika oraz spadek napięcia na R18, znów korzystając z prawa Ohma po przekształceniu wzoru I=U/R do postaci R=U/I, obliczmy rezystancję rezystora R18. Zatem R18=UR18/Ir=4,3V/0,33mA=13k Jak widzimy nasz rezystor R18 ma wartość 13k Jak widzimy w tym przypadku wyliczenie wartości potrzebnego nam rezystora jest bardzo łatwe. Dzięki temu nasz układ przełączając się z zasilania USB na zasilacz dostarczy do stabilizatora odpowiednio wysokie napięcie na jego wejście, aby na wyjściu tego stabilizatora uzyskać napięcie 5V potrzebne do zasilania podzespołów naszego urządzenia, a my dzięki diodzie LED USB będziemy wiedzieć czy tak się stało. Właśnie to jest ta zaleta. Oczywiście aby to działało sprawnie musimy obserwować diodę USB oraz ustawić odpowiednią wartość napięcia zasilania na zasilaczu. Po podłączeniu zasilania z zasilacza powinna zapalić się zielona dioda LED PWR, a niebieska USB zgasnąć. Musimy pamiętać, że zasilacze wtyczkowe regulowane przełącznikiem, mają podane na sztywno zakresy przełączanych napięć a nie wszyscy mogą wiedzieć że stabilizator aby dać napięcie 5V na wyjściu, musi mieć podane na wejście konkretną wartość napięcia. Najważniejsze, żeby pamiętać aby nie przekroczyć maksymalnego napięcia zasilania dla stabilizatora, aby tym samym go nie uszkodzić oraz innych elementów naszego urządzenia. W zależności od modelu stabilizatora, napięcie jego zasilania może mieć inną wartość. Jeżeli po podłączeniu zasilacza dioda LED USB nie zgaśnie może się okazać, że nasz zasilacz podaje zbyt niskie napięcie niż jest potrzebne do przełączenia się urządzenia z zasilania USB na zasilanie z zasilacza, a tym samym podania na wejście stabilizatora odpowiedniej wartości napięcia, aby na jego wyjściu uzyskać 5V. Będziemy też wiedzieć czy zasilacz jaki zastosowaliśmy ma odpowiednie napięcie aby zasilić nasze urządzenie. Aby ułatwić sprawę napiszę jaką wartość napięcia zasilania można podać dla danego typu stabilizatora: -stablizator NCP1117ST50T3G 5V, 1A. Producent napisał, że maksymalne napięcie wejściowe to max 20V. Natomiast minimalne to 6,5V -stabilizator LM340MP-5.0/NOPB 5V, 1,5A Producent napisał, że maksymalne napięcie wejściowe to max 35V. Natomiast minimalne to 7,5V Jak też widać pomimo, że mechanizm przełączania zasilania jest identyczny jak w platformie uno i jej klonach, to trochę podrążyłem temat co przedstawiłem powyżej. Być może komuś te informacje okażą się przydatne przy projektowaniu własnego urządzenia z użyciem dzielnika napięcia. Dodanie do obwodu diody led oraz podstawowa wiedza na temat stabilizatorów oraz dzielnika napięcia z zastosowaniem wzmacniacza operacyjnego w roli komparatora, dała nam przydatną funkcję, dzięki której wszystkie elementy urządzenia, jak i te które przyłączymy do niego, będą zasilane odpowiednią wartością napięcia. Podsumowując dzięki diodzie LED USB wiemy, czy nasze urządzenie przełączyło się na zasilanie zewnętrzne (zasilacz) tym samym przełączenie to nastąpiło w momencie, kiedy nasz zasilacz ma odpowiednią wartość napięcia potrzebną do zasilenia stabilizatora, aby ten na wyjściu dał napięcie 5V potrzebne z kolei do zasilania podzespołów urządzenia oraz elementów do niego podłączonych. W największym skrócie - jak widać zależność napięcia wejściowego "VIN" (zasilacz), do którego podłączony jest stabilizator, do napięcia wyjściowego "UR19", które steruje wzmacniaczem operacyjnym w roli komparatora, którego rolą jest przełączanie źródła zasilania jest uzależniona od wartości rezystancji dzielnika napięcia. Znając wartość napięcia potrzebnego do zasilenia stabilizatora oraz fakt, że przy tej wartości napięcie na wyjściu dzielnika ma wynieść 3,3V dobieramy odpowiednią wartość rezystorów dla tego dzielnika. Dodam jeszcze, że zrezygnowałem z połączeń pomiędzy dwoma procesorami na liniach MISO, MOSI, SCK za pośrednictwem diod, tak jak to miało w pierwszej odsłonie urządzenia. Okazało się, że w przypadku linii MISO i MOSI jest to zbędne i urządzenie działa bez problemu. Inaczej jest w przypadku lini SCK, ale tutaj zastosowałem rozwiązanie z poziomu hardware niż softu. Jako, że miałem zamówionych więcej układów analog. MUX/DEMUX, to wolałem użyć go do połączenia pinów SCK procesorów IC1 i IC2 niż bawić się w modyfikację kodu. Efekt działania w końcu jest ten sam tylko metoda prowadząca do tego efektu inna. Kolejną rzeczą choć może mniej istotną jest możliwość uśpienia programatora ISP. Jeżeli na przykład drażnią kogoś świecące się diody led. Co mi rzadko ale bywa, że przeszkadza, szczególnie jak nie używamy programatora ISP aktualnie go do wgrywania bootloderów. Oszczędzanie energii w tym przypadku nie jest specjalnie duże (około 50mA), choć z drugiej strony lepiej mieć mniej niż wcale, szczególnie gdzie port USB ma wydajność 500mA. Aby aktywować uśpienie programatora naciskamy najpierw switch S1-RESET, a następnie przez chwilę przytrzymujemy S6-IC1 SLEEP. Diody: PMODE, HBEAT, ERROR powinny na chwilę zamrugać, a następnie razem z diodami BTLDR i PROGR nie powinny się zapalić. Wtedy programator jest uśpiony. W zależności od potrzeb i upodobań danego użytkownika, przygotowałem kilka różnych wersji zmodyfikowanego sketcha ArduinoISP. Mamy do dyspozycji z przytrzymywaniem switcha S2-SELECT na czas wgrywania bootloadera, z trybem uśpienia jak i bez, oraz bez przytrzymywania switcha S2-SELECT bez funkcji uśpienia. W tej wersji urządzenia, zaraz po zmontowaniu potrzebujemy 1szt. procesora z wgranym już bootloaderem, który będzie pełnił rolę programatora ISP - IC1. Najlepiej niech to będzie ATmega8, ze względu na fakt, że jest to do dziś najtańszy procesor oraz ilość pamięci jaką posiada jest wystarczająca do wgrania skecza ArduinoISP. Sam skecz wykorzystuje około 60% pamięci tego procesora. W poprzedniej wersji urządzenia aby wgrać skecz ArdunoISP, trzeba było najpierw ten procesor umieścić w podstawce IC2. Teraz można umieścić go bezpośrednio w podstawce IC1, dzięki czemu nie ma konieczności przekładania go - niekiedy dość upierdliwa czynność. Po włożeniu procesora do podstawki IC1, zakładamy zworkę na piny IC1PROGR. Zapala na się dioda LED IC1-PROGR. Włączamy środowisko Arduino IDE. O tym jak powinno być ono skonfigurowane dla danej wersji procesora i jak wgrać skecz do procesora opisałem w artykule: https://forbot.pl/forum/topic/19357-mwuinouno-bootloader-programmer-i-arduino-w-jednym/ Aby ułatwić szukanie opisu wgrywania skeczy, szukamy podtytuł (pogrubiona czcionka) "Tak więc:" i w tekście poniżej-siódma linijka tekstu, od zdania zaczynającego się od słów "Dla przykładu". Oczywiście zamiast switcha S2 używamy switch S1 i podstawka IC2 używamy IC1. Tutaj jak widać procesor IC1 musimy zresetować ręcznie switchem S1. Na początku myślałem aby to było robione z układu FTDI232RQ, ale w sumie nikt nie będzie często przeprogramowywał tego procesora ewentualnie raz na jakiś czas o ile zajdzie taka potrzeba, a obwód to raz, że więcej elementów, niepotrzebny koszt i stopień komplikacji urządzenia. Chyba lepsze jest aktualne rozwiązanie. Łatwiej jest raz na jakiś czas przed programowaniem nacisnąć przycisk reset niż bawić się w przekładanie procesora z podstawki do podstawki. Gdybyśmy nie mieli zworki tylko przewód połączeniowy, to jeden koniec przewodu podłączamy do pinu VCC a drugi do pinu złącza IC1PROGR oznaczonego kropką. Oczywiście dla urządzenia z układem FTDI232RQ. w momencie wgrywania skecza do procesora IC2 przed wgraniem następuje jego RESET jak to ma miejsce w platformie UNO i jej klonach. W przypadku wersji wymagającej podłączenia zewnętrznego konwertera jest to uzależnione właśnie od posiadanego przez nas konwertera, czy może on resetować procesor przed wgraniem skecza. Zatem jak widać bazowałem przede wszystkim na rozwiązaniach niespotykanych w oryginalnej platformie, a niektórych klonach tej platformy. Mimo wszystko jest też kilka moich pomysłów oraz co najważniejsze i trudne to zaprojektować PCB tak aby te rozwiązania mogły być zintegrowane oraz samo urządzenie możliwie zbliżone do wymiarów oryginalnej platformy UNO. Jak widać wiązało się to z pewnymi zmianami takimi jak inny układ pinów gniazd procesora IC2. Nie podłączymy co prawda do nich shieldów czyli nakładek zwiększających możliwości naszego urządzenia, lecz dzięki bliskości tych złącz, łącząc układ na płytce stykowej powinny nam wystarczyć przewody jednakowej długości, aby wykorzystać wszystkie piny procesora. Wiedzmy też, że prócz shieldów możemy też kupić funkcjonalne moduły na mniejszych PCB niż zaprojektowane shieldy i przy pomocy przewodów połączeniowych podłączyć je do urządzenia. Tak więc pomimo niestandardowego układu wyprowadzeń, dalej jesteśmy w stanie zbudować potrzebne nam urządzenie. Niewielką rekompensatą tego rozwiązania jest umieszczenie dodatkowych złączy w wersji męskiej. Dzięki czemu możemy stosować przewody połączeniowe z końcówka męską lub żeńską. Jednak postanowiłem jeszcze oprócz samego urządzenia i korzystając z tego, że JLCPB ceny są dość atrakcyjne, zaprojektować trzy nakładki do swojego urządzenia. Pierwsza "adapter shield" to nakładka, która umożliwia przejście z niestandardowego układu pinów mojej wersji platformy uno, na układ pinów zgodny z oryginalną platformą, dzięki czemu można używać dedykowanych shieldów. Zauważyłem, że niektóre shieldy mają dodatkowo złącze ICSP w wersji żeńskiej do podłączenia, jako że nie posiadam takiego shielda, nie jestem w stanie określić czy będzie on działać w pełni po podłączeniu do adapter shield. Jeżeli nie to pozostaje tylko skorzystać modułu w postaci PCB podłączanego do pinów przewodami połączeniowymi. Tak jak mamy na przykład ethernet shield oraz moduł ethernet w postaci małej płytki PCB z wyprowadzeniami podłączanymi przewodami połączeniowymi. To co wyróżnia się najbardziej to otwory na PCB, umieszczone nad diodami USB i PWR MwuinoUNO, dzięki czemu nie ma potrzeby stosowania diod LED na nakładce oraz zawsze niewielka, ale oszczędność pobieranego prądu. Mamy również otwory pod przełącznik napięcia 3,3V/5V oraz na włącznik zasilania Co jest widoczne na zdjęciach poniżej. 1. Wszystkie nakładki - strona BOTTOM 2. Nakładka "adapter shield" strona TOP podłączona do MWuinoUNO Drugą nakładką jest sensor shield. Płytka z pinami do podłączeń, sensorów i różnych modułów PCB, pozwalająca tworzyć nam bardziej zaawansowane układy. To co wyróżnia się najbardziej to otwory na PCB, umieszczone nad diodami USB i PWR MwuinoUNO, dzięki czemu nie ma potrzeby stosowania diod LED na nakładce oraz zawsze niewielka, ale oszczędność pobieranego prądu. Shield ten od większości dostępnych dla oryginalnej platformy UNO, posiada filtrację zasilania składającą się z kondensatorów ceramicznych i elektrolitycznych. Dwie pary kondensatorów. W każdej parze kondensator ceramiczny z kondensatorem elektrolitycznym umieszczone w odpowiedniej odległości aby zapewnić odpowiednią filtrację zasilania modułów, czujników itp. Dzięki temu mamy pewność, że nasz projekt będzie działać niezawodnie i stabilnie. Mamy również otwory pod przełącznik napięcia 3,3V/5V oraz na włącznik zasilania Co jest widoczne na zdjęciach poniżej. Nakładka "sensor shield" strona TOP podłączona do MWuinoUNO Trzecią nakładką jest gniazdo procesora, a dokładniej podstawka testowa ZIF. Umożliwia nam ona szybką wymianę procesora, za pośrednictwem dźwigni dociskającej jego piny do styków podstawki. Domyślnie można na PCB dla podstawki zamontować rezonator kwarcowy z kondensatorami i używać jej kiedy mamy do zaprogramowania dużą ilość procesorów. Możemy także na niej zamontować dodatkowo kondensatory filtrujące zasilanie, dławik, rezystor oraz switch do pinu reset. Mamy tym samym spełnione minimalne podłączenie procesora i możemy podpiąć przewodami połączeniowymi jakiś prosty moduł celem sprawdzenia jego działania z procesorem. Możemy też do jego gniazd włożyć listwę kołkową męską i wystające piny listwy wpiąć na płytkę stykową, nie podłączając elementów wymaganych do samej pracy procesora a podłączać tylko te którymi nasz procesor ma sterować lub te, które mają dostarczać sygnały do niego. Nakładka IC2 socket adapter strona TOP podłączona do MWuinoUNO Na zakończenie dodam, że jest to już ostatni artykuł z serii o Arduino UNO, gdzie starałem przedstawić się zalety jak i swoją wizję tej platformy. Następne moje projekty będą się tyczyć urządzeń zbudowanych a oparciu o platformę UNO. Mam nadzieję, że wszystkie informację, które do tej pory przedstawiłem okazały się pomocne, szczególnie dla osób początkujących, które zdecydowały się na wybór Arduino UNO jako platformy, z którą zaczynają naukę programowania i budowania urządzeń. Plik do pobrania: MWuinoUNO.zip W pliku tym znajdziemy dokumentację oraz wszystkie niezbędne pliki, gdybyśmy chcieli wykonać urządzenie, w tym skecze ArduinoISP do zaprogramowania IC1, a nawet sterownik dla układu FTDI232RQ dla WIN10.

Witam serdecznie, potrzebuję małej pomocy przy przerwaniach programując ESP32 przy pomocy Arduino IDE. Chciał bym liczyć ilość wciśnięć przycisku za pomocą przerwań. Po wciśnięciu przycisku wyświetla się napis że przycisk został wciśnięty. Jednak po puszczeniu przycisku ponownie wyświetlany jest komunikat o wciśnięciu przycisku. Fizycznie przycisk został wciśnięty 7 razy a wyświetla się że był wciśnięty 14 razy. Może ktoś ma pomysł jak rozwiązać wskazany problem? #define DEBOUNCE_TIME 250 volatile uint32_t DebounceTimer = 0; #define PIN_BUTTON 12 uint32_t button_count = 0; void IRAM_ATTR buttonpressed() { if ( millis() - DEBOUNCE_TIME >= DebounceTimer ) { DebounceTimer = millis(); button_count += 1; Serial.printf("Przycisk wciśnięty %u razy.\n", button_count); } } void setup() { Serial.begin(115200); pinMode(PIN_BUTTON, INPUT_PULLUP); attachInterrupt(PIN_BUTTON, buttonpressed, FALLING); } void loop() { }

Cześć Minęło już sporo czasu odkąd kolega deshipu opublikował bardzo ciekawy i inspirujący artykuł traktujący o Micropython. https://forbot.pl/forum/topic/8588-micropython-na-esp8266/?tab=comments#comment-88039 Przez ten czas spora część entuzjastów elektroniki, programowania, majsterkowiczów no i czytelników Forbota wszak, zaznajomiła się przynajmniej na przyzwoitym poziomie z możliwościami zastosowania mikroprocków AVR w swoich projektach. Powstawały przy tym mniej lub bardziej udane konstrukcje, które cieszyły, zaskakiwały i rozwijały twórczo, cokolwiek to oznacza. Jeśli w tym czasie miałem jakiś niedosyt, czy poczucie, że czegoś tu jeszcze brakuje, że można zrobić coś lepiej, coś zmienić lub rozbudować, to tylko z korzyścią dla siebie i dla nas samych, bo chyba nie piszę tu tylko o sobie, prawda? Podstawowy moduł Arduino R3, jakkolwiek bardzo przydatny i udany projekt z czasem zrobił się ciut niewystarczający. Brakowało komunikacji, ta szeregowa, I2C czy SPI to za mało. Apetyt rośnie w miarę jedzenia. Przydałby się Ethernet (powstawały nakładki z modułem Ethernet, samodzielne moduły np. Arduino Yun), przydałaby się sieć WiFi (np. WiDo moduł WiFi WG1300). Jeśli dysponujesz wolnym czasem i kwotą około 30 zł. do wykorzystania, to proponuję zakupić jeden z dostępnych modułów, opartych na ESP32 / ESP8266 i zacząć zabawę z alternatywnym IDE, jakim jest Thonny (z wbudowanym Pythonem), zamiast IDE z Arduino i gcc. Jest w internecie sporo gotowych poradników i rozwiązań opartych na programowaniu modułów ESP za pomocą IDE Arduino, natomiast stosunkowo niewiele można znaleźć o Micropythonie. Znam C i C++(przynajmniej z czasów kiedy wręcz obowiązkową pozycją była "Symfonia C++" Grębosza), poznanie i przyswojenie innych języków, C#, Javy czy shell-a Bash nie sprawia mi szczególnych trudności. Czas zatem zabrać się za Pythona i poznać dla niego konkretne zastosowania praktyczne. Język Python jest stosunkowo prosty i wręcz intuicyjny, sprawia, że można w miarę szybko opanować jego podstawy przynajmniej w zakresie zastosowań do programowania mikrokontrolerów. Mikropython z kolei jest własnie tym czego potrzebujemy. To minimalny, niezbędny podzbiór języka Python, gdzie umieszczono szereg narzędzi i modułów do sterowania i komunikacji z mikrokontrolerami. Przyznaje, że początkowo dość sceptycznie podchodziłem do Pythona, ze względu na wcześniejsze przyzwyczajenia co do deklaracji typów dla obiektów w C, zmiennych tablic i w ogólności składni, a tutaj jest dużo prościej i przejrzyściej, przynajmniej w tym zakresie jaki akurat jest mi potrzebny na tym etapie. Nie chciałbym przy tym rozpoczynać dyskusji na temat wyższości jednego języka nad drugim. Kieruje się tylko chęcią poznania nowego języka i alternatywnych narzędzi dla programowania mikrokontrolera. Micropython to minimalny podzbiór... tylko tyle ile jest niezbędne i tylko tyle aby zostawić dla nas jak najwięcej miejsca w pamięci takiego procka. Tak, micropython flashujemy (wgrywamy)na nasz procek i cały system wraz z szeregiem niezbędnych modułów i poleceń. Trochę to przypomina znaną już malinkę (raspberry pi), gdzie instaluje się jedną z dystrybucji linuxa i mamy tam pełnoprawny system operacyjny w dużym pudełku zapałek. Micropython i ESP32/8266 w dużym uproszczeniu przypomina nieco dystrybucję minilinux z wbudowanym micropythonem. (czy ten osioł przypomina nieco kurę? CK Dezerterzy) 🐴 Jak zacząć? Sporo się zmieniło na plus przez te kilka lat istnienia micropythona. W necie można znaleźć kilka wartościowych poradników jak zainstalować (flashować) procesory... większość zaczyna od instalacji Pythona, potem niezbędnych narzędzi (pip, esptool, ampy, potem jakiegoś środowiska/edytora IDE dla Pythona), co w konsekwencji robi się nieco flustrujące. Dobra wiadomość jest taka, że nie musimy już tego wszystkiego robić. Wystarczy pobrać i zainstalować Thonny IDE dla Pythona. Thonny w wersji 3.2.7 pobierzemy stąd: https://www.downloaddrivers.info/download-thonny-3-2-7/ , przewijamy okno w dół i mamy niebieski odnośnik: Rozpakowujemy pobrane archiwum zip i instalujemy program. Przy instalacji warto ustawić skrót do aplikacji na pulpicie. Na chwilę obecną dysponuję modułem ESP-WROOM-32, dostępnym np. w https://botland.com.pl/pl/moduly-wifi/8893-esp32-wifi-bt-42-platforma-z-modulem-esp-wroom-32-zgodny-z-esp32-devkit.html?search_query=esp32&results=65 , ale nic nie stoi na przeszkodzie aby wykorzystać dowolny moduł oparty na ESP32/8266. Na tym etapie dobrze jest wybrać taki z wbudowanym gniazdem USB, bowiem będziemy mogli bezpośrednio wpinać go do naszego komputera i programować/komunikować się z modułem w locie. Podpinamy nasz moduł kablem USB (powinien wykryć nasz moduł i przypisać do niego nr portu COM). Odpalamy Thonny IDE, i z menu wybieramy Uruchom->Wybierz Interpreter: a tam MicroPython (ESP32) i wybieramy nasz rozpoznany port COM. Następnie musimy pobrać obraz naszego systemu, aby wgrać go do naszego ESP32. Wchodzimy na stronę http://micropython.org i pobieramy z zakładki Download najbardziej odpowiedni obraz dla naszego modułu. Dla nas jest to Generic ESP32 Module i poniżej z listy Firmware with ESP-IDF v3.x wybieramy najlepiej najnowszą stabilną wersję (ja wybrałem esp32-idf3-20200902-v1.13.bin, czyli tą stabilna, bez słowa unstable w nazwie). Po pobraniu pliku obrazu .bin klikamy w Thonny na opcję menu Uruchom->Wybierz Interpreter ... i tam w pole : Otwórz okno dialogowe instalacji lub aktualizacji MicroPython... następnie wybieramy port i ścieżkę z naszym pobranym właśnie plikiem .bin. Klikamy Install Po chwili powinna rozpocząć się procedura flashowania naszego modułu. Uwaga... jeśli program zgłosi niepowodzenie uruchom ponownie Install przytrzymując na chwilę przycisk Reset w naszym module. Po flashowaniu zamykamy aktywne okno. Resetujemy ponownie moduł, zaś w polu Powłoki mamy znak zachęty naszego micropythona: >>> To oznacza, że możemy zacząć zabawę z micropythonem. Okno Thonny składa się z 2 głównych okien - okno powłoki i okno edytora. W górnym oknie możemy tworzyć/edytować skrypty Pythona, a w dolnym - i tu niespodzianka mamy dostęp do powłoki shell naszego micropythona. 😄 Czym szczególnym wyróżnia się ta powłoka? Ano możemy bezpośrednio komunikować się z naszym modułem i wydawać mu polecenia do wykonania, niejako adhoc, czyli w locie!!! Nie trzeba tak jak w Arduino najpierw kompilować całego programu aby zobaczyć w monitorze portu szeregowego "Hello World".... tutaj po prostu po znaku zachęty >>> napisz: print('Hello World') ... i tyle - poniżej otrzymasz odpowiedź z ESP32 😀 Dobra... nie masz pewności czy aby procek odpowiada (bo może to robić sam Thony), więc zrób to: wpisz po znaku zachęty po kolei te linie:(po każdej daj Enter) import machine led = machine.Pin(2, machine.Pin.OUT) led.on() led.off() Będziesz teraz zapalał i gasił wbudowaną diodę Led. Powłoka zapamiętuje wpisane wcześniej polecenia, więc możesz klawiszami strzałka góra/dół wracać do nich, bez konieczności ponownego wpisywania z palucha poleceń. Więcej o możliwościach Thonny doczytasz w Necie. Na chwilę obecną wystarczy zaznajomić się z możliwościami powłoki Micropythona. Planuję kolejny post w tematyce mikropythona, gdzie umieszczę swoje zmagania z tym nowym i dla mnie tematem. W szczególności ciekawy jest proces bootowania (uruchamiania) takiego ESP z wgranym micropythonem, do czego służą pliki boot.py i main.py , jak dodać i wgrać do procka własny skrypt/moduł .py do struktury katalogów i jak z niego korzystać. Kolejne tematy, z którymi ostatnio byłem za pan brat, (całość za pomocą micropythona - czyli alternatywa do tego co już można zrobić za pomocą Arduino IDE) : podpięcie do sieci WiFi, server i klient pobranie akt. czasu (RTC, time, utime) korzystanie z Telegram Bot przy pomocy micropythona i modułu urequests tryb głębokiego uśpienia (deep sleep mode) dla jednego (ext0) i wielu pinów (ext1) własny moduł/biblioteka użytecznych funkcji Pozdrawiam i zachęcam do zabawy z micropythonem, nie zaszkodzi 🍺 Wielkie dzięki dla kol. deshipu !

Witam, Zaczynam czytać kursy Arduino i mam problem. Z uwagi na brak USB, nie potrafię zainstalować na moim tablecie Lenovo, programu Arduino IDE. Mam tylko WiFi i Bluetooth, gdy próbowałem skorzystać z pomocy wujka G, to tylko wskazywana była możliwość przesyłu danych przez WiFi, a nigdzie nie mogłem jeżeli ktoś zna na to jakiś sposób, to proszę o podpowiedź. Pozdrawiam

Mam problem. Od dwóch dni próbuję stworzyć program, który będzie wyświetlał różne animacje. Chciałbym wrzucić kilka animacji do jednego programu, by móc potem zmieniać je poprzez naciśnięcie przycisku. Zaznaczam, że dopiero się uczę Arduino i jeżeli robię jakiś błąd posłucham rady od was. Podczas włączania animacji program nie chce jej odtworzyć, puszcza tylko jedną sekwencję. Chodzi o tryb 2. Trzeba użyć pętli? Jak tak to jak ją napisać? #include "FastLED.h" int buttonPin = 2; bool state = 0; int tryb = 0; //////////////////////////////////////////////////////////////////////////////////////////////////// // // RGB Calibration code // // Use this sketch to determine what the RGB ordering for your chipset should be. Steps for setting up to use: // * Uncomment the line in setup that corresponds to the LED chipset that you are using. (Note that they // all explicitly specify the RGB order as RGB) // * Define DATA_PIN to the pin that data is connected to. // * (Optional) if using software SPI for chipsets that are SPI based, define CLOCK_PIN to the clock pin // * Compile/upload/run the sketch // You should see six leds on. If the RGB ordering is correct, you should see 1 red led, 2 green // leds, and 3 blue leds. If you see different colors, the count of each color tells you what the // position for that color in the rgb orering should be. So, for example, if you see 1 Blue, and 2 // Red, and 3 Green leds then the rgb ordering should be BRG (Blue, Red, Green). // You can then test this ordering by setting the RGB ordering in the addLeds line below to the new ordering // and it should come out correctly, 1 red, 2 green, and 3 blue. // ////////////////////////////////////////////////// #define NUM_LEDS 10 // For led chips like WS2812, which have a data line, ground, and power, you just // need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock, // ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN // Clock pin only needed for SPI based chipsets when not using hardware SPI #define DATA_PIN 7 #define CLOCK_PIN 13 CRGB leds[NUM_LEDS]; void setup() { // sanity check delay - allows reprogramming if accidently blowing power w/leds delay(2000); Serial.begin(57600); Serial.println("resetting"); LEDS.setBrightness(10); pinMode(buttonPin, INPUT_PULLUP); pinMode(LED_BUILTIN, OUTPUT); // Uncomment/edit one of the following lines for your leds arrangement. // ## Clockless types ## // FastLED.addLeds<SM16703, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<TM1829, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<TM1812, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<TM1809, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<TM1804, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<TM1803, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<UCS1903, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<UCS1903B, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<UCS1904, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<UCS2903, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical // FastLED.addLeds<WS2852, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical // FastLED.addLeds<GS1903, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<SK6812, DATA_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical // FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<APA106, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<PL9823, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<SK6822, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<WS2813, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<APA104, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<WS2811_400, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<GE8822, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<GW6205, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<GW6205_400, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<LPD1886, DATA_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<LPD1886_8BIT, DATA_PIN, RGB>(leds, NUM_LEDS); // ## Clocked (SPI) types ## // FastLED.addLeds<LPD6803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical // FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // GRB ordering is typical // FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<WS2803, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // FastLED.addLeds<P9813, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical // FastLED.addLeds<DOTSTAR, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical // FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical // FastLED.addLeds<SK9822, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS); // BGR ordering is typical } void fadeall() { for(int i = 0; i < NUM_LEDS; i++) { leds[i].nscale8(250); } } void loop() { if(digitalRead(2) == HIGH ) // Jezeli wcisniemy przycisk podlaczony pod pin nr 2 { if(tryb != 2) tryb++; else tryb = 0; while(digitalRead(2) == HIGH); } if(tryb == 0) { leds[0] = CRGB(255,0,0); leds[1] = CRGB(255,0,0); leds[2] = CRGB(255,0,0); leds[3] = CRGB(255,0,0); leds[4] = CRGB(255,0,0); leds[5] = CRGB(255,0,0); leds[6] = CRGB(255,0,0); leds[7] = CRGB(255,0,0); leds[8] = CRGB(255,0,0); leds[9] = CRGB(255,0,0); FastLED.show(); delay(1); } if (tryb == 1) { leds[0] = CRGB(255,0,0); leds[1] = CRGB(0,255,0); leds[2] = CRGB(0,0,255); leds[3] = CRGB(0,255,0); leds[4] = CRGB(0,0,255); leds[5] = CRGB(0,0,255); leds[6] = CRGB(255,0,0); leds[7] = CRGB(0,0,255); leds[8] = CRGB(0,255,0); leds[9] = CRGB(0,0,255); FastLED.show(); delay(1); } if(tryb == 2) { static uint8_t hue = 0; Serial.print("x"); // First slide the led in one direction for(int i = 0; i < NUM_LEDS; i++) { // Set the i'th led to red leds[i] = CHSV(hue++, 255, 255); // Show the leds FastLED.show(); // now that we've shown the leds, reset the i'th led to black // leds[i] = CRGB::Black; fadeall(); // Wait a little bit before we loop around and do it again delay(10); } Serial.print("x"); // Now go in the other direction. for(int i = (NUM_LEDS)-1; i >= 0; i--) { // Set the i'th led to red leds[i] = CHSV(hue++, 255, 255); // Show the leds FastLED.show(); // now that we've shown the leds, reset the i'th led to black // leds[i] = CRGB::Black; fadeall(); // Wait a little bit before we loop around and do it again delay(10); } } }

Dzień dobry, Posiadam Arduino UNO. Za pomocą tej płytki robiłem zamieszczony tutaj kurs dla początkujących. Przy pierwszym podłączeniu wszystko było ok. Zrobiłem kilka części kursu(zatrzymałem się na LCD). Problem, jaki pojawił się w pewnym momencie to brak możliwości zaprogramowania płytki poprzez port USB, używając do tego dedykowanego środowiska (ver. 1.8.12). Pracuję na Win10. Sprawdziłem ustawienia i połączenia: 1. Menedżer urządzeń rozpoznaje płytkę -> Porty->Arduino Uno(Com4) 2. W środowisku mam wybrane: płytkę Arduino UNO, port COM4 programator AVRISP mkii Na powyższych ustawieniach pracowałem do tej pory. Wszystko zasilane z USB, ewentualnie z zewnętrznego zasilacza(kurs o serwomechanizmie). Zasilanie sygnalizowane przez zieloną diodę. Zanim napisałem ten post, poczytałem forum odnośnie takich przypadków. W większości ten problem to skasowany bootloader. Zaznaczam, że do programowania płytki używałem tylko połączenia USB(nie posiadam zewnętrznego programatora). Sprawdziłem też inny przewód USB. Postanowiłem też kupić procesor z wgranym już bootloaderem. Po zmianie procesora, problem nadal istnieje. Błąd jaki otrzymuję to: Czy ktoś z Forumowiczów spotkał się z takim problemem? Pozdrawiam, Łukasz

Witam Z góry dziękuję z wszelką pomoc! Na podstawie pewnego projektu z internetu (Ten projekt, tyle że bardzo skrócony. Oryginał też na tej stronie tylko że po Turecku). Program działa na zasadzie zainstalowanej biblioteki do Winamp która wysyła rożne sygnały poprzez port szeregowy. Następnie program w Arduino odczytuje je i w odpowiedni sposób interpretuje. Wizualizacja odbywa się na ekranie LCD 16x2. Ja do własnych celów, do innego projektu chciałbym aby zamiast wyświetlania się danych na ekranie informacje z każdego "słupka" były zapisywane i aktualizowane w "int-ach". Czyli np. pierwszy słupek od lewej int1, następny int2 i tak dalej. Jeśli ktoś pomógłby mi w tym byłbym bardzo wdzięczny. Dodam jeszcze że oryginalny projekt działa u mnie (wszystko zainstalowane poprawnie, chodzi mi tylko o przerobienie programu). Link do stron: https://hase85.wordpress.com/2013/09/25/16x2-lcd-spectrum-analyzer-plugin-for-winamp/ Kod arduino: /* CrownSoft LCD Spectrum Analyzer Interface (c) 2013 CrownSoft Inc. a level-1 b level-2 c level-3 d level-4 e level-5 f level-6 g level-7 h level-8 i set cursor & draw char j set cursor & draw level k clear screen examples: i00H first col first row set 'H' j01b first col second row set level-2 k clear all */ #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); byte custChars[8][8] = { {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B11111}, {B00000, B00000, B00000, B00000, B00000, B00000, B11111, B11111}, {B00000, B00000, B00000, B00000, B00000, B11111, B11111, B11111}, {B00000, B00000, B00000, B00000, B11111, B11111, B11111, B11111}, {B00000, B00000, B00000, B11111, B11111, B11111, B11111, B11111}, {B00000, B00000, B11111, B11111, B11111, B11111, B11111, B11111}, {B00000, B11111, B11111, B11111, B11111, B11111, B11111, B11111}, {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111} }; byte serial_getch() { while (Serial.available() == 0); return Serial.read(); } void setup() { Serial.begin(19200); lcd.begin(16, 2); lcd.clear(); // create custom characters for(int i=0;i<8;i++) { lcd.createChar(i, custChars[i]); } /* for(int i=0;i<8;i++) { lcd.setCursor(i,0); lcd.write(i); }*/ } void loop() { byte rxbyte = serial_getch(); if(rxbyte=='j') // set cursor & draw level { lcd.setCursor(serial_getch()-'0',serial_getch()-'0'); lcd.write((uint8_t)(serial_getch()-'a')); }else if(rxbyte=='i') // set cursor & draw char { lcd.setCursor(serial_getch()-'0',serial_getch()-'0'); lcd.write((char)serial_getch()); }else if(rxbyte=='k') // clear { lcd.clear(); } } Pozdrawiam Piotrek

Witam, na wstępie przepraszam, jeśli podobny temat już był, sam jednak nie mogłem znaleźć tego o co mi chodzi. Mój problem wygląda tak. Podczas jednego z kursów Arduino na Forbocie prawdopodobnie zepsułem swój mikroprocesor. Środowisko pokazuje, że kod został wgrany bez problemów lecz nie wykonuje się on, a na płytce prototypowej miga dioda z podpisem "L". Na szczęście mam drugą atmegę328, lecz kupiłem wersję bez bootloadera ponieważ była tańsza, a sam chciałem wypalić loader przy pomocy Arduino. Teraz skoro atmega nie działa zastanawiam się nad kilkoma opcjami. 1. Kupno nowej atmegi z bootloaderem i wypalenie bootloadera na drugiej. 2. Kupienie programatora. W przypadku programatora mam kilka pytań. Czy przy pomocy programatora da się w jakiś sposób wypalić bootloader na czystej atmedze? Jakiego rodzaju programator byłby dobry na początek i czy potrzeba do niego jakieś szczególne sterowniki (nie ukrywam, że wolałbym mieć coś kompatybilnego z linuxem, ponieważ używam praktycznie tylko tego systemu). Jeśli miałbym programator, to jak wygląda pisanie kodu w czystym C na atmegę? Czy istnieją alternatywne środowiska do Atmel Studio, które działają na systemie z pingwinem? Z góry dziękuje za wszelkie odpowiedzi i pozdrawiam!

MQTT jest popularnym, bo prostym w obsłudze protokołem komunikacji. Najłatwiej jest porównać to do systemu YouTube: są subskrybenci i nadawcy. Nadawca może mieć wielu subskrybentów ale też jedno urządzenie może słuchać wielu nadawców (co - trochę jak w prawdziwym życiu - nie zawsze kończy się dobrze). Cała architektura wygląda w ogólnym przypadku w następujący sposób: W tym artykule zajmiemy się przygotowaniem środowiska oraz wysłaniem “hello world”. Zakładam, że na Raspberry jest zainstalowany raspbian. Jeśli nie to koniecznie sięgnij do odpowiedniego poradnika na Forbocie. Na Raspberry możesz pracować zdalnie lub lokalnie, to nijak nie wpływa na działanie systemu. Ten wpis brał udział konkursie na najlepszy artykuł o elektronice lub programowaniu. Sprawdź wyniki oraz listę wszystkich prac » Partnerem tej edycji konkursu (marzec 2020) był popularny producent obwodów drukowanych, firma PCBWay. Konfiguracja serwera W charakterze serwera posłuży nam Raspberry Pi. W zasadzie każdy model powinien się sprawdzić, ale zalecane jest użycie przynajmniej drugiej wersji. Aby wszystko działało jak trzeba potrzebujemy pakietu Mosquitto. Wydajemy następujące komendy: aktualizacja systemu: sudo apt-get update && sudo apt-get upgrade -y instalacja mosquitto: sudo apt-get install mosquitto -y automatyczne uruchomienie przy starcie: sudo systemctl enable mosquitto.service I… to już. Serwer został zainstalowany. Teraz jeszcze tylko restart i możemy przejść dalej. Potrzebujemy jeszcze dwa urządzenia, które będziemy ze sobą komunikować. Pierwszym z nich będzie Raspberry Pi. Będzie na nim uruchomiona usługa Node-Red dzięki której będziemy mogli w łatwy sposób odczytywać dane i sterować urządzeniami wykonawczymi. Drugie urządzenie to ESP32. Przy jego pomocy będziemy sterować diodą, która potwierdzi poprawne przejście przez instalację. Node-Red Do instalacji potrzebujemy następującej komendy: sudo apt-get install nodered -y Po skończeniu instalacji możemy dodać automatyczne uruchamianie przy starcie: sudo systemctl enable nodered.service Aby wyłączyć automatyczny start wpisujemy: sudo systemctl disable nodered.service Uruchamiamy działanie serwisu poprzez komendę: sudo node-red-start Potrzebujemy teraz poznać IP maliny (jeśli pracujemy lokalnie). Wykonujemy to poprzez: ifconfig Jeśli przechodzisz przez ten artykuł tylko “dla zajawki” to możesz poprzestać na tej komendzie. Jeśli jednak stawiasz to “na stałe” to musisz zrobić jeszcze jedną rzecz, z którą nie bardzo mogę pomóc. Należy ustawić statyczne IP dla maliny. Robi się to na routerze, w panelu administracyjnym. Ze względu na mnogość rozwiązań różnych producentów routerów musisz poszukać odpowiedni poradnik w internecie. Jak wspomniałem, jest to tylko dla osób, które stawiają serwer na stałe. Po instalacji Node-Red przechodzimy do przeglądarki. W pasku na adres url wpisujemy adres IP z portem 1880. Czyli pracując lokalnie na Raspberry wpiszemy: 127.0.0.1:1880 natomiast pracując zdalnie wpiszemy ip:1880. W moim przypadku jest to 192.168.100.194:1880. Powinniśmy dostać taki obraz: Klikamy na trzy paski w prawym górnym rogu i wybieramy opcję “Manage palette”: W oknie dialogowym przechodzimy do zakładki install i wpisujemy dashboard. Wybieramy drugą opcję z góry: Po zatwierdzeniu instalacji czekamy, aż proces się skończy. Ta wtyczka umożliwia nam utworzenie graficznego interfejsu użytkownika. Po zakończeniu instalacji zamykamy okno dialogowe i z listy po lewej stronie wybieramy opcje oraz je łączymy. Wybieramy opcje MQTT (obie) z sekcji network oraz z sekcji dashboard wybieramy switch oraz show notification. Łączymy ze sobą te punkty wg następującego schematu: Następnie dwa razy klikamy w pierwszy obiekt mqtt. Klikamy w ikonkę z ołówkiem która otworzy nam dodatkowy panel. W otrzymanym polu edycji wpisujemy tylko localhost, klikamy Add. Dalej, w polu Topic wpisujemy esp32/message i ustawiamy QoS jako 1. Podobne kroki wykonujemy dla drugiego punktu z mqtt przy czym serwer powinien zostać uzupełniony automatycznie, w polu Topic wpisujemy esp32/gpio, ustawiamy QoS jako 1 i retain jako false. Ostatni punkt w konfiguracji Node-Red to ustawienie przełącznika. Wchodzimy w jego okno dialogowe, dodajemy nową grupę (Klikamy w ołówek koło pola “Group”) znowu klikamy ołówek dalej Add i znowu Add. W ustawieniach schodzimy trochę niżej i ustawiamy On Payload jako typ number (pierwsza rozwijana ikonka) i wpisujemy 1 oraz ustawiamy Off Payload jako number i wpisujemy 0. Klikamy Deploy w prawym górnym rogu i trzymamy kciuki. Po zapisaniu zmian otwieramy nowe okno przeglądarki i wpisujemy ip:1880/ui. Pozostała część adresu zostanie uzupełniona automatycznie. Mając tak przygotowane środowisko przechodzimy do ostatniego punktu czyli modułu ESP32. ESP32 Programować będziemy w Arduino IDE. Aby jednak móc to zrobić musimy przygotować środowisko. Nie będę się zagłębiał w ten temat bo jest wiele dobrych poradników o tym w internecie (np.: tutaj) Dodatkowo w managerze bibliotek instalujemy bibliotekę PubSubClient oraz ESPMQTTClient. W fizycznym podłączeniu warto jest sprawdzić najpierw pinout naszej płytki w internecie oraz ewentualnie zmienić numer pinu w kodzie. Następnie wybieramy odpowiednią płytkę, wgrywamy przykładowy szkic i… nie działa. Po pierwsze dlatego, że należy zmienić ssid (czyli nazwy sieci, do której jest podłączone też raspberry pi), hasło oraz adres IP serwera na adres maliny. Po drugie dlatego, że często są problemy z tymi płytkami (o tym w kolejnym akapicie). Jeśli jednak udało się wszystko wgrać powinniśmy dostać wiadomość w panelu sterowania oraz możemy sterować diodą przez przełącznik. Kod testowy prezentuje się następująco: #include <WiFi.h> #include <PubSubClient.h> const char* ssid = "Nazwa wifi"; //ZMIENIC na swoje const char* password = "haslo do wifi"; //ZMIENIC na swoje const char* mqtt_server = "IP Raspberry Pi"; //ZMIENIC na swoje const char* deviceName = "ESP32"; //poki co nie trzeba zmieniac //ale przy wiekszej ilosci urzaden kazde musi miec swoja nazwe const char* startMessageTopic = "esp32/message"; //temat do wyslania wiadomosci const char* pinTopic = "esp32/gpio"; //temat do odbioru wiadomosci const int ledPin = 27; //numer pinu diody, ZMIENIC JESLI TRZEBA WiFiClient espClient; PubSubClient client(espClient); void reconnect() { bool ctd = false; //funkcja jest wywolywana jesli utracono polaczenie z serwerem Serial.println("Rozlaczono!"); while(!ctd) { Serial.print("Laczenie z serwerem..."); if(client.connect(deviceName)) { ctd = true; Serial.println("Polaczono!"); } else { Serial.print("."); delay(1000); } } } void odbiorWiadomosci(String temat, byte* zawartosc, unsigned int dlugosc) { String pomoc; Serial.println("Odebrano wiadomosc:"); Serial.print("\tTemat: "); Serial.println(temat); Serial.print("\tTresc: \""); for(int i=0; i<dlugosc; i++) { Serial.print((char)zawartosc[i]); pomoc += (char)zawartosc[i]; } Serial.println("\""); if(temat == pinTopic) { if(pomoc == "1") { digitalWrite(ledPin, HIGH); Serial.println("LED1: ON"); } else if(pomoc == "0") { digitalWrite(ledPin, LOW); Serial.println("LED1: OFF"); } else Serial.println("Nieznana komenda, nie wiem co mam z tym zrobic"); } } void ustawienieWifi() { delay(10); Serial.println(); Serial.print("Laczenie z "); Serial.println(ssid); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.print("Polaczona z wifi.\nESP otrzymalo adres IP: "); Serial.println(WiFi.localIP()); } void setup() { Serial.begin(115200); pinMode(ledPin,OUTPUT); ustawienieWifi(); //polaczenie z wifi delay(1000); client.setServer(mqtt_server, 1883); //ustawienie serwera mqtt client.connect(deviceName); //polaczenie z podana nazwa client.subscribe(pinTopic); //ustawienie nasluchiwania w podanym temacie client.setCallback(odbiorWiadomosci); //ustawienie funkcji do odbioru wiadomosci client.publish(startMessageTopic, "Hello from ESP32"); //wyslanie pierwszej wiadomosci } void loop() { if (!client.connected()) //jesli klient zostal rozlaczony { reconnect(); //polacz ponownie client.publish(startMessageTopic, "Hello from ESP32"); //wysliij wiadomoc powitalna } if(!client.loop()) client.connect(deviceName); //upewnienie sie, ze klient jest stale podlaczony } Jako, że jest to pierwszy kontakt z tym protokołem i programem pozwolę sobie nie zagłębiać się w szczegóły. Starałem się wszystko opisać w komentarzach kodu. Dodatkowo dużo rzeczy jest wyświetlanych w konsoli, więc warto tam zajrzeć. Problemy, problemy, problemy Często zdarza się tak, że płytki z rodziny ESP nie współpracują ze wszystkimi komputerami. W moim przypadku na 4 komputery bez problemu mogę podłączyć się z dwóch. Z jednego muszę używać programatora FTDI a jeden (najnowszy) działa trochę jak ślepy koń: nie widzi przeszkód (a w zasadzie nie widzi płytek). Jeśli natomiast są problemy przy wygrywaniu można spróbować wybrać inną płytkę w ustawieniach IDE lub pomajstrować z ustawieniami wybranej płytki (znowu odsyłam do internetu, źródeł trochę jest). Osobiście pracowałem na płytce Esp32 Wroom, a wgrywanie działało przy ustawieniach dla płytki LOLIN D32.