Przeszukaj forum

Witam, mam problem z zasileniem arduino oraz serwomechanizmu. Otóż wymyśliłem to tak, że użyję akumulator Li-Po 1s w połączeniu z przetwornicą step-up (maksymalny prąd to 2A). Jednak po włączeniu wszystkiego serwo oraz arduino wariują. Natomiast gdy podłącze arduino do komputera poprzez usb a serwo do baterii lub zasilacza to wszystko działa poprawnie. Dodam też, że prędkość i kąt wychylenia serwa są sterowane poprzez moduł BT i gdy wszystko jest zasilane jest właśnie z baterii lub jednego zasilacza(atx) to moduł wysyła informacje z dużo wyższą częstotliwością (dioda TX miga znacznie szybciej i widać to na monitorze portu szeregowego).

Witam serdecznie, robię coś "ala inteligentny dom" i brakowało mi gpio na malince. Podłączyłem mcp23017 i działa:) Działa jako wyjście:/ Jak zrobić żeby działało jako wyjście? A takie ważniejsze i chyba trudniejsze pytanie (jak dla mnie) to: Jak połączyć malinkę z arduino przez usb?? tak żeby arduino działało jako we/wy?? Nie liczę na gotowca, ale jakieś wskazówki. Nie jestem też jakimś tam hiper, biper, diker informatykiem. Skoro potrafiłem podłączyć mcp23017 i "ledami mrugać" to myślę że arduino podłączę jako we/wy do malinki;) Pozdrawiam serdecznie;) p.s. Zapomniałem dodać, że to wszystko obsługuję na domoticz.

Witam Jestem bardziej niż początkującym w tematach mikrokontrolerów i elektroniki, więc proszę o wyrozumiałość. Od jakiegoś czasu planuje zrobić robota wykorzystującego czujnik ultradźwiękowy (między innymi) do mapowania terenu. Ale dopiero od paru dni zacząłem szperać i czytać jak to zrobić krok po kroku. Ha. Nawet znalazłem coś podobnego na forum https://forbot.pl/forum/topic/11454-prosty-ultradzwiekowy-skaner-otoczenia-2d-360-stopni/ Rozbiłem się już na początkowych pytaniach, ale w tym temacie chciałbym zapytać konkretnie o jeden z nich: 1. Mianowicie jeżeli mam już arduino (z kursu arduino, który do teraz zbierał u mnie kurz) to co mi jest potrzebne prócz serwa pracy ciągłej do zbudowania obrotowej wieżyczki na której będą zamontowane czujniki ultradźwiękowe? Rozumiem, że zależy od serwa, ale łączy się je przez shieldy, albo tworzy się jakieś układy, albo zasila niezależnie od arduino? Czy to przez pobór prądu? 2. Czy dostępne w różnych sklepach ( botland, kamami) shieldy do silników obsłużą też serwo? Czy muszę mieć konkretnie shield ze sterownikiem serw? 3. Czy jeżeli servo będzie miało duży pobór prądu to nie zakłóci w jakiś sposób pracy czujników? Wiem, że pytania banalne, ale może Panowie potraficie mnie choć naprowadzić na trop. Sam w miarę czasu i możliwości w chwilach wolnych od roboty staram się szperać po książkach i necie, ale temat niby prosty a jednak masę wiedzy należy sobie gdzieś ze szkoły przypomnieć, a większości przypadków od zera się uczyć.

Witam, Dopiero zaczynam moją przygodę z Arduino i mam zamiar zrealizować projekt systemu sterowania rozjazdami na mojej makiecie kolejowej. Każdy rozjazd ma być przesuwany za pomocą zamontowanego pod makietą serwomechanizmu SG90 (razem 10 serwomechanizmów). Każde serwo reagować ma na zmianę pozycji swojego przełącznika dwupozycyjnego - w momencie przełączenia, zmienić pozycję o około 30 stopni i w niej pozostać, przy zmianie pozycji przełącznika do pierwotnej - serwo również ma wrócić do pozycji pierwotnej. Dodatkowo, przy każdym przełączniku mają być dwie diody, zawsze świecić ma się jedna z nich w zależności od pozycji, w jakiej znajduje się dany serwomechanizm. Posiadam Arduino Uno, oraz Adafruit servo shield pozwalający na podłączenie do 16 serw. Stąd moje pytanie do bardziej doświadczonych kolegów: czy przy użyciu Adafruit mogę coś takiego zrobić? Czy w ogóle przełączniki dwupozycyjne z dźwignią są do zastosowania w tego typu projekcie? Uwagi dotyczące połączeń i zaprogramowania mile widziane, za każdą pomoc z góry dziękuję

Cześć Niedawno kupiłem na Botlandzie moduł radiowy nadajnik FS100A + odbiornik 433 MHz. Cały dzień pracowałem nad jego podłączeniem. Korzystałem z przykładów biblioteki VirtualWire.h oraz podłączyłem nadajnik do pinu 12 i odbiornik do pinu 11 (do osobnych płytek). Nie potrafiłem odebrać komunikatu. Czy błąd leży gdzieś po mojej stronie czy zwyczajnie nadajnik i odbiornik nie współpracują ze sobą i powinienem dokonać zwrotu? Przykład z biblioteki VirtualWire //NADAJNIK // transmitter.pde // // Simple example of how to use VirtualWire to transmit messages // Implements a simplex (one-way) transmitter with an TX-C1 module // // See VirtualWire.h for detailed API docs // Author: Mike McCauley (mikem@open.com.au) // Copyright (C) 2008 Mike McCauley // $Id: transmitter.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $ #include <VirtualWire.h> #undef int #undef abs #undef double #undef float #undef round void setup() { Serial.begin(9600); // Debugging only Serial.println("setup"); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec } void loop() { const char *msg = "hello world"; digitalWrite(13, true); // Flash a light to show transmitting vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx(); // Wait until the whole message is gone digitalWrite(13, false); Serial.println("Wyslano!"); delay(200); } //ODBIORNIK // receiver.pde // // Simple example of how to use VirtualWire to receive messages // Implements a simplex (one-way) receiver with an Rx-B1 module // // See VirtualWire.h for detailed API docs // Author: Mike McCauley (mikem@open.com.au) // Copyright (C) 2008 Mike McCauley // $Id: receiver.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $ #include <VirtualWire.h> #undef int #undef abs #undef double #undef float #undef round void setup() { Serial.begin(9600); // Debugging only Serial.println("setup"); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running } void loop() { uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) // Non-blocking { int i; digitalWrite(13, true); // Flash a light to show received good message // Message with a good checksum received, dump it. Serial.print("Got: "); for (i = 0; i < buflen; i++) { Serial.print(buf[i], HEX); Serial.print(" "); } Serial.println(""); digitalWrite(13, false); } } Mój moduł: Przykład z poradnika na YT

Cześć! Mam taki problem: próbuje podłączyć duży przycisk tact switch(12x12mm) do Arduino i sprawdzić czy jest naciśnięty. Wykorzystuję do tego taki kod: void setup() { pinMode(2, INPUT_PULLUP); } void loop() { if(digitalRead(2) == LOW) { Serial.println("CLICKED!"); } } i tak podłączyłem układ Wydaję mi się, że wszystko jest dobrze. Jednak, gdy podłączam płytkę do komputera, monitor portu szeregowego sugeruje, że cały czas naciskam przycisk. Problem znika po zmianie przycisku na mały (tact switch 6x6mm).

Witam, chciałbym zrobić domowy Webserver na Raspberry Pi Zero W, napisany w Node.js. O ile potrafię pobrać dane z bazy danych za pomocą Node'a, nie wiem w jaki sposób miałbym przekazać dane z czujników podłączonych do Arduino, do RPi. Przykład: Mam czujnik tempratury Dallas, Arduino, oraz moduł WIFI (ESP8266), lub też Ethernet (Enc28j60). Bez problemu umiem pobrać dane z czujników i wyświetlić je klasycznie w monitorze portu szeregowego, ale jak przekazać je do RaspberryPi, tak aby dało się je pobrać za pomocą Node'a (konkretnie). Preferuję komunikację bezprzewodową, ale jakikolwiek sposób na start naprawdę by mnie zadowolił. Jestem również bardzo otwarty na propozycje, jedyna rzecz przy której się trzymam to Webserver napisany w Node.js Byłbym bardzo wdzięczny za podanie bibliotek, różnych sposobów komunikacji, oraz gotowych przykładów.

Witam chciałbym się zapytać czy ktoś może mi pomóc przerobić kod do arduino na sterowanie 2 serwami zdalnie za pomocą joysticka kod odbiornika : #include <Servo.h> #include <SPI.h> #include "RF24.h" Servo myServo; Servo myServo2; RF24 radio(5,10); const uint64_t pipe = 0xE8E8F0F0E1LL; int msg[2]; void setup(){ myServo.attach(3); myServo2.attach(4); radio.begin(); radio.openReadingPipe(1, pipe); radio.startListening(); } void loop(){ if(radio.available()){ bool done = false; while (!done) { done = radio.read(msg, sizeof msg); myServo.write(msg[0]); myServo2.write(msg[1]); } } } i kod nadajnika : #include <SPI.h> #include "RF24.h" int msg[2]; int xValue; int yValue; RF24 radio(5,10); const uint64_t pipe = 0xE8E8F0F0E1LL; void setup(void){ radio.begin(); radio.openWritingPipe(pipe); } void loop(void){ xValue = analogRead(0); xValue = map(xValue, 0, 1023, 0, 179); msg[0] = xValue; radio.write(msg, sizeof msg); yValue = analogRead(1); yValue = map(yValue, 0, 1023, 0, 179); msg[1] = yValue; radio.write(msg, sizeof msg); } ten kod mam z tego filmiku tylko go przerobiłem : a chciałbym tam wcisnąć ten kod żeby to działało mniej więcej tak : czyli jak dam joystick w prawo to będzie się servo powoli obracało w tamtą stronę a jak puszcze joystick to nie będzie wracało do punktu startowego .Czyli będzie to działało to jak tu : #include <Servo.h> Servo servo1; Servo servo2; int x_key = A1; int y_key = A0; int x_pos; int y_pos; int servo1_pin = 8; int servo2_pin = 9; int initial_position = 90; int initial_position1 = 90; void setup ( ) { Serial.begin (9600) ; servo1.attach (servo1_pin ) ; servo2.attach (servo2_pin ) ; servo1.write (initial_position); servo2.write (initial_position1); pinMode (x_key, INPUT) ; pinMode (y_key, INPUT) ; } void loop ( ) { x_pos = analogRead (x_key) ; y_pos = analogRead (y_key) ; if (x_pos < 300){ if (initial_position < 10) { } else{ initial_position = initial_position - 20; servo1.write ( initial_position ) ; delay (100) ; } } if (x_pos > 700){ if (initial_position > 180) { } else{ initial_position = initial_position + 20; servo1.write ( initial_position ) ; delay (100) ; } } if (y_pos < 300){ if (initial_position1 < 10) { } else{ initial_position1 = initial_position1 - 20; servo2.write ( initial_position1 ) ; delay (100) ; } } if (y_pos > 700){ if (initial_position1 > 180) { } else{ initial_position1 = initial_position1 + 20; servo2.write ( initial_position1 ) ; delay (100) ; } } } czy w ogóle dało by się coś takiego wykonać ?

Witam chciał bym zaprezentować , drugą "lepszą wersję " kierownicy do komputera opartej na Arduino Leonardo. Film pokazujący jak dziala kierownica i Force Feedback: Jest to wersja elektronicznie taka sama jak poprzednia, wszystko opisane wcześniej link do poprzedniej tutaj : W tej wersji zmieniłem obudowę na znacznie mniejszą , lżejszą , łatwa do zamocowania przy stole, biurku itp. Obudowa została wykorzystana z kupionej przeze mnie za 50 zł kierownicy Logitech Formula Force Ex o obrocie 180* i Force Feedback. Dzięki temu że kierownica miała już przekładnie i ogólnie jest prosta w budowie , bardzo łatwo i tanio można ją przerobić tak aby miala kąt skrętu taki jak ustawimy sobie w programie np 720*,900* i Force Feedback do tego kąta obrotu. Tutaj link do gotowego software na Arduino Leonardo , od razu mówię że na Arduino Uno nie zadziała , link do pobrania w opisie filmu: Ja zrobiłem to tak: Na początku przez środek starej przekładni , dodałem pręt gwintowany o średnicy 10mm ,do którego z jednej strony mocowana jest kierownica, a z drugiej enkoder z drukarki canon ip2770. Aby zamocować enkoder musiałem wyciąć dziure jak widać na zdjęciu poniżej : Aby enkoder nie tarł o blat , dodałem plastikowe podkładki : A tak wygląda już gotowa sama kierownica: Wyjścia enkodera i do silnika , zostały przerobione na standardowych wyjściach które były w kierownicy i wchodzą do dodatkowej skrzynki w której znajduje się reszta elektroniki czyli w sumie tylko Arduino Leonardo i sterownik silników BTS7960: Jeszcze pedal box został przerobiony na taki aby miał 3 jednakowe pedały więc musiałem dokupić drugie takie same i wyciąć jeden i dokleić tak jak na zcjeciach . Schemat podłączenia wszystkiego w linku do wcześniejszej wersji. Efekt końcowy (pedały jeszcze stare): To by było na tyle , jeśli czegoś ktoś potrzebuje , śmiało pisać

Witam! Na samym wstępie się może przedstawię, jako że jestem nowy na tym forum. Mam na imię Mikołaj, 17 lat, uczę się jako technik mechatronik i elektroniką samą w sobie zajmuję się dopiero niespełna rok. ============================================================================================ Chciałbym przedstawić swoje pierwszą własną konstrukcje - Miarę ultradźwiękową "Gacek". Podobne urządzenie było przedstawiane w kursach arduino i na bazie jego działania oparłem swoje. Całość chciałem wykonać na podstawie tego co do tej pory się nauczyłem oraz nie mam jeszcze za dużo doświadczenia w robieniu tego typu projektów, dlatego niektóre rozwiązania mogą się wydawać amatorskie. Gabarytowo wyszło mi trochę za wielkie przez to, że kupiłem za dużą obudowę. Wymiary(cm): 11 x 15 x 7 Lista komponentów: Arduino UNO Wyświetlacz lcd 16x2 Czujnik ultradźwiękowy US-015 2x Potencjometry 3x Przyciski Przełącznik Żółty 3mm led Rezystor 1000Ω Obudowa uniwersalna Płytka uniwersalna Wtyk DC do arduino Koszyk na baterię 9V Trochę kabli Większość potrzebnych rzeczy już miałem, musiałem tylko dokupić parę drobiazgów oraz obudowę, w sumie wydałem +/- 70 zł. Całość mieści się w granicach 150-200 zł. Schemat połączeniowy: Kod programu: /////////////////////////////////////////// // Miara ultradźwękowa - "Gacek" // /////////////////////////////////////////// #include <LiquidCrystal.h> // Dodanie biblioteki LiquidCrystal lcd(2, 3, 4, 5, 6, 7); // Piny wyświetlacza #define przycisk1 13 #define przycisk2 12 #define przycisk3 11 #define trig 8 #define echo 9 #define led 10 //////////////////////////////////////////////////////// byte prostokat[8] = { B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111 }; // Wypełniony prostokąt byte strzalkaP[8] = { B01000, B01100, B01110, B01111, B01110, B01100, B01000, B00000 }; // Strzałka w prawo byte strzalkaL[8] = { B00010, B00110, B01110, B11110, B01110, B00110, B00010, B00000 }; // Strzałka w lewo //////////////////////////////////////////////////////// Dodanie tablic specjalnych znaków boolean kolejnosc1 = false; boolean kolejnosc2 = false; boolean start = false; int tryb = 1; int opcja = 0; int jednostka = 0; int odcinek = 0; //////////////////////////////////////////////////////// Zmienne globalne void setup() { //////////////////////////////////////////////////////// lcd.begin(16, 2); // rozmiar ekranu lcd lcd.createChar(0, prostokat); lcd.createChar(1, strzalkaP); lcd.createChar(2, strzalkaL); // Stworzenie specjalnych znaków na bazie powyższych tablic lcd.clear(); ///////////////////////////////// pinMode(przycisk1, INPUT_PULLUP); pinMode(przycisk2, INPUT_PULLUP); pinMode(przycisk3, INPUT_PULLUP); pinMode(trig, OUTPUT); pinMode(echo, INPUT); pinMode(led, OUTPUT); digitalWrite(led, LOW); //////////////////////////////////////////////////////// Ustawienie pinów lcd.setCursor(0, 0); lcd.write(byte(0)); // wyświetlenie specjalnego znaku (prostokąta) lcd.setCursor(3, 0); lcd.print("GACEK v1.0"); lcd.setCursor(15, 0); lcd.write(byte(0)); ///////////////////////////////////// Ekran powitalny } void loop() { //////////////////////////////////////////////////////// float wynik; int pomiar1, pomiar2, pole, odczyt; pole = 0; odczyt = 0; pomiar1 = 0; pomiar2 = 0; //////////////////////////////////////////////////////// Zmienne lokalne if (start == false) { // Warunek odpowiadający za jednorazowe wyświetlenie delay(3000); // ekranu startowego przy włączeniu urządzenia start = true; } if (tryb < 1) { // Warunki zmniejszące przedział zmiennej do 1-3 tryb = 1; } if (tryb > 3) { tryb = 3; } lcd.clear(); // Czyszczenie ekranu przy powrocie do menu //////////////////////////////////////////////////////// switch (tryb) { case 1: lcd.setCursor(2, 0); lcd.print("Tryb"); lcd.setCursor(2, 1); lcd.print("Miary"); lcd.setCursor(15, 0); lcd.write(byte(1)); lcd.setCursor(15, 1); lcd.print("B"); break; case 2: lcd.setCursor(0, 0); lcd.write(byte(2)); lcd.setCursor(0, 1); lcd.print("A"); lcd.setCursor(2, 0); lcd.print("Tryb"); lcd.setCursor(2, 1); lcd.print("Pomiaru Pola"); lcd.setCursor(15, 0); lcd.write(byte(1)); lcd.setCursor(15, 1); lcd.print("B"); break; case 3: lcd.setCursor(0, 0); lcd.write(byte(2)); lcd.setCursor(0, 1); lcd.print("A"); lcd.setCursor(2, 0); lcd.print("Tryb"); lcd.setCursor(2, 1); lcd.print("Nastawny"); break; } //////////////////////////////////////////////////////// Wybór trybu while (digitalRead(przycisk1) == HIGH && digitalRead(przycisk2) == HIGH && digitalRead(przycisk3) == HIGH) {} // Czekania na wybór operatora //////////////////////////////////////////////////////// if (digitalRead(przycisk1) == LOW) { // Przesuń w lewo tryb = tryb - 1; while (digitalRead(przycisk1) == LOW) {} } if (digitalRead(przycisk2) == LOW) { // Przesuń w prawo tryb = tryb + 1; while (digitalRead(przycisk2) == LOW) {} } if (digitalRead(przycisk3) == LOW) { // Wybierz ten tryb opcja = tryb; while (digitalRead(przycisk3) == LOW) {} } ////////////////////////////////////////////////////////// Sterowanie w menu if (opcja > 0) { // Jeśli wybrano tryb... lcd.clear(); //////////////////////////////////////////////////////// while (opcja == 1) { // Tryb miary //////////////////////////////////////////////////////// pomiar(); if (wynik == pomiar()) { }else{ if (wynik == pomiar() * 0.39) { }else{ if (wynik == pomiar() / 100.0) { }else{ lcd.clear(); } } } //////////////////////////////////////////////////////// Filtr przełączania liczb na ekranie lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Pomiar"); lcd.setCursor(7, 0); lcd.write(byte(0)); lcd.setCursor(9, 0); lcd.print("="); //////////////////////////////////////////////////////// switch (jednostka) { case 0: lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("cm"); lcd.setCursor(3, 1); lcd.write(byte(0)); wynik = pomiar(); lcd.setCursor(11, 0); lcd.print(wynik, 0); break; case 2: lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("cal"); lcd.setCursor(4, 1); lcd.write(byte(0)); wynik = pomiar(); wynik = wynik * 0.39; lcd.setCursor(12, 0); lcd.print(wynik, 2); break; case 1: lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("m"); lcd.setCursor(2, 1); lcd.write(byte(0)); wynik = pomiar(); wynik = wynik / 100.0; lcd.setCursor(11, 0); lcd.print(wynik, 2); break; } //////////////////////////////////////////////////////// Wybór jednostki delay(50); if (digitalRead(przycisk3) == LOW) { jednostka = jednostka + 1; lcd.clear(); if (jednostka > 2) { jednostka = 0; } while (digitalRead(przycisk3) == LOW) {} } if (digitalRead(przycisk1) == LOW) { // wyjście do menu opcja = 0; while (digitalRead(przycisk1) == LOW) {} } } //////////////////////////////////////////////////////// Sterowanie wyborem jednostki oraz przycisk wyjścia do menu //////////////////////////////////////////////////////// while (opcja == 2) { // Tryb pomiaru pola //////////////////////////////////////////////////////// lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Pomiar1"); lcd.setCursor(8, 0); lcd.write(byte(0)); lcd.setCursor(10, 0); lcd.print("="); lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("Pomiar2"); lcd.setCursor(8, 1); lcd.write(byte(0)); lcd.setCursor(10, 1); lcd.print("="); //////////////////////////////////////////////////////// if (digitalRead(przycisk1) == LOW) { opcja = 0; pomiar1 = 0; pomiar2 = 0; kolejnosc1 = false; kolejnosc2 = false; pole = 0; while (digitalRead(przycisk1) == LOW) {} } //////////////////////////////////////////////////////// Wyjście do menu if (digitalRead(przycisk2) == LOW) { lcd.clear(); pomiar1 = 0; pomiar2 = 0; kolejnosc1 = false; kolejnosc2 = false; while (digitalRead(przycisk2) == LOW) {} } //////////////////////////////////////////////////////// Reset if (digitalRead(przycisk3) == LOW) { pomiar(); if(pomiar() == 0){ pomiar(); } if(pole > 0){ pole = 0; } while (kolejnosc1 == true && kolejnosc2 == true) { lcd.clear(); pole = pomiar1 * pomiar2; lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Pole"); lcd.setCursor(5, 0); lcd.write(byte(0)); lcd.setCursor(7, 0); lcd.print("="); lcd.setCursor(9, 0); lcd.print(pole); lcd.setCursor(0, 1); lcd.print("B"); lcd.setCursor(2, 1); lcd.print("-"); lcd.setCursor(4, 1); lcd.print("RESET"); while (digitalRead(przycisk2) == HIGH && digitalRead(przycisk1) == HIGH) {} if (digitalRead(przycisk1) == LOW) { opcja = 0; pomiar1 = 0; pomiar2 = 0; kolejnosc1 = false; kolejnosc2 = false; pole = 0; lcd.clear(); break; } if (digitalRead(przycisk2) == LOW) { kolejnosc1 = false; kolejnosc2 = false; pomiar1 = 0; pomiar2 = 0; lcd.clear(); break; } } if (kolejnosc1 == true && kolejnosc2 == false && pole == 0) { pomiar2 = pomiar(); lcd.setCursor(12, 1); lcd.print(pomiar2); kolejnosc2 = true; } if (kolejnosc1 == false && pole == 0) { pomiar1 = pomiar(); lcd.setCursor(12, 0); lcd.print(pomiar1); kolejnosc1 = true; } while(digitalRead(przycisk3) == LOW){} while (digitalRead(przycisk1) == HIGH && digitalRead(przycisk2) == HIGH && digitalRead(przycisk3) == HIGH && pole == 0) {} } } ////////////////////////////////////////////////////////// // Opcja nr.2 - Pomiar pola ////////////////////////////////////////////////////////////////// while (opcja == 3) { lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Odcinek"); lcd.setCursor(8, 0); lcd.write(byte(0)); lcd.setCursor(10, 0); lcd.print("="); lcd.setCursor(12, 0); lcd.print(odcinek); ///////////////////////////////////////////////// while (digitalRead(przycisk2) == LOW) { odcinek = odcinek + 1; delay(100); lcd.setCursor(12, 0); lcd.print(odcinek); } if (digitalRead(przycisk1) == LOW) { opcja = 0; odcinek = 0; while (digitalRead(przycisk1) == LOW) {} } while (digitalRead(przycisk3) == LOW) { odcinek = odcinek - 1; if(odcinek < 0){ odcinek = 0; } delay(100); lcd.setCursor(12, 0); lcd.print(odcinek); if(odcinek - 1 == 8 || odcinek - 1 == 98 || odcinek - 1 == 998){ // Łatka naprawaiająca mieszanie się liczb na wyświetlaczu lcd.clear(); lcd.setCursor(0, 0); lcd.write(byte(0)); lcd.setCursor(1, 0); lcd.print("Odcinek"); lcd.setCursor(8, 0); lcd.write(byte(0)); lcd.setCursor(10, 0); lcd.print("="); } } if (odcinek > 0) { pomiar(); if (odczyt >= 10 && pomiar() < odczyt || odczyt >= 100 && pomiar() < odczyt){ lcd.clear(); } lcd.setCursor(0, 1); lcd.write(byte(0)); lcd.setCursor(1, 1); lcd.print("Obecnie"); lcd.setCursor(8, 1); lcd.write(byte(0)); lcd.setCursor(10, 1); lcd.print("="); if(pomiar() < 1000){ odczyt = pomiar(); lcd.setCursor(12, 1); lcd.print(odczyt); } if(odcinek == odczyt) { digitalWrite(led, HIGH); }else{ digitalWrite(led, LOW); } if (digitalRead(przycisk1) == LOW) { digitalWrite(led, LOW); lcd.clear(); odcinek = 0; opcja = 0; odczyt = 0; while (digitalRead(przycisk1) == LOW) {} } delay(25); } } ////////////////////////////////////////////////////////////////// // Tryb nr. 3 - Pomiar wymiarowy } } //////////////////////////////////////////////////////// int pomiar() { long czas, dystans; digitalWrite(trig, LOW); delayMicroseconds(2); digitalWrite(trig, HIGH); delayMicroseconds(10); digitalWrite(trig, LOW); czas = pulseIn(echo, HIGH); dystans = czas / 58; dystans = dystans + 11; delay(100); Serial.println(dystans); return dystans; //////////////////////////////////////////////////////// // Program wykonujący pomiary czujnikiem } Po uruchomieniu urządzenia wyświetla się menu wyboru trybu, którym steruje się przyciskami A oraz B, natomiast guzik C zatwierdza wybór. Potencjometry regulują jasność oraz kontrast wyświetlacza lcd. Miara ma trzy tryby pomiarów: Pierwszy z nich to mierzenie ciągłe z dodatkową opcją przeskalowania jednostki na metry oraz cale (w planie miałem także zamiar dodać milimetry, ale pomiary wychodziły bardzo niedokładnie, dlatego zrezygnowałem z tego pomysłu). Jak widać na nagraniu pomiar czasami może się różnić o 1 cm niż w rzeczywistości, może to być wina arduino, które przeskalowuje wynik z czujnika na centymetry przy czym przybliża go do pełnych liczb. Punkt zero znajduje się z tyłu obudowy, a co za tym idzie pomiar nie może być mniejszy niż 14 cm. Aby wrócić do menu wyboru wystarczy przytrzymać przycisk A. Następna opcja to pomiar pola, polega ona na zebraniu dwóch pomiarów, aby następnie na ich podstawie wyliczyć pole. Przy tworzeniu tego trybu napotkałem kilka błędów typu jakieś wyskakujące znikąd zera czy też liczby, ale ostatecznie doszedłem to tego, że problem leży w odświeżaniu wyświetlacza i załatałem ten problem. Ostatnim, trzecim trybem jest miara nastawna, działa ona w ten sposób, że najpierw ustala się na jakiej odległości ma znajdować się mierzony obiekt, po czym manewrujemy tym przedmiotem aż do momentu gdy pomiar czujnika będzie się zgadzał z wcześniej ustaloną wartością o czym poinformuje dioda. W planach mam jeszcze wprowadzenie nowych trybów oraz oczywiście zminiaturyzowania całego urządzenia. Pozdrawiam!

W tym projekcie chciałbym opisać krok po kroku proces podłączenia licznika samochodowego od Forda Galaxy do naszego Arduino. Potrzebne elementy: Zasilacz 12V Arduino Przewody męsko-żeńskie Licznik samochodowy Zestaw wskaźników od Forda Galaxy posiada 2 wtyczki - czerwoną oraz czarną. Nas w tym projekcie interesuje tylko czerwona wtyczka gdyż znajdują się w niej piny zasilające oraz dostarczające dane do silników krokowych w liczniku. Najpierw zajmijmy się zasilaniem. Do pinu 3 oraz do pinu 4 na liczniku wpinamy 2 przewody i podłączamy je do minusa na naszym zasilaczu a kolejne 2 przewody wpięte w pin 14 oraz w pin 15 podłączamy do +. Jako zasilacz może nam posłużyć zwykły zasilacz komputerowy kub jakikolwiek o napięciu 12V. Dalej zajmijmy się podłączeniem silniczków od wskazówek. obrotomierz - 10 pin prędkościomierz - 27 pin wskaźnik poziomu paliwa - 21 pin wskaźnik temperatury cieczy - 23 pin (pin 1 jest w lewym dolnym rogu wtyczki) Następnie przewody te wpinamy w wejścia cyfrowe do Arduino. W moim przypadku obrotomierz wpiąłem w wejście oznaczone 2, prędkościomierz w wejście nr 3, wskaźnik poziomu paliwa 4 a temp. cieczy w wejście 5. Jeżeli po podpięciu zasilania licznik zadziała (wskazówki ustawią się w położeniu 0 oraz włączy się podświetlenie) to możemy przejść do konfiguracji. Pobieramy oprogramowanie SimHub i instalujemy je. Po uruchomieniu programu przechodzimy do zakładki Arduino a następnie klikamy na zakładkę "My hardware". Wybieramy "Single Arduino" i klikamy "Open arduino setup tool". Następnie definiujemy w jakie wejścia wpięliśmy nasze wskaźniki. Wybieramy z jakiego arduino korzystamy (w moim przypadku jest to UNO) oraz wybieramy port komunikacyjny. Gdy wszystko mamy już zrobione klikamy Upload to arduino i czekamy aż program zostanie wgrany na Arduino. Jeżeli program wgrał się poprawnie przechodzimy do zakładki "Gauges" i kalibrujemy nasz licznik. Wartości liczbowe są indywidualne dla każdego licznika ale to co musimy ustawić do każdego licznika to MAX Tachometer RPM na 7 (jeżeli zakres na tarczy obrotomierza jest inny to podajemy maksymalną liczbę, jeśli jest to 5 to podajemy 5) oraz tachometer cylinders na 6. Warto zaznaczyć opcję "Always use tachometer full range" jednak jeśli sprawia ona problemy możemy ją wyłączyć. Resztę wartości musimy ustawić tak, żeby wskazówka poprawnie wskazywała położenie min i max. Niestety nie ma uniwersalnych wartości i prędkościomierz u mnie wskazuje poprawnie 240 km/h przy wartości 222 (speedo gauge maximum output) jednak w innym liczniku może być to wartość ciut większa lub mniejsza. Na samym końcu wybieramy grę w którą chcemy zagrać z zakładki "Games". Następnie uruchamiamy naszą grę i cieszymy się rozgrywką z naszym licznikiem. Ktoś mi może powiedzieć "Przecież można napisać kod", zgodzę się z tym tylko ja gram od ETS 2 przez Dirt 4 na Forzie kończąc. O wiele łatwiej jest jednym kliknięciem zmienić grę w simhubie niż pisać osobny kod eksportujący dane z telemetrii do Arduino. Jeżeli ktoś potrzebuje tylko licznika do jednej gry to ma to sens jednak w moim przypadku mija się to z celem. Koszt takiego licznika może zamknąć się w okolicach 50 zł. Możemy wykorzystać klona arduino (klon nano możemy kupić za mniej niż 15zł), a licznik możemy znaleźć na portalach aukcyjnych za ok 20zł. Jest to niedrogi i fajny bajer a na dodatek jest bardzo praktyczny. Poniżej znajdują się zdjęcia i gif pokazujący pracę urządzenia.

Witam, jaki jest najlepszy sposób na przesłanie danych z czujnika (załóżmy temperatury, Dallas) do Arduino. Chciałbym bezprzewodowo wysłać dane z czujnika do Arduino żeby później przekazać je Raspberry Pi. Czy mógłby mi ktoś konkretnie wytłumaczyć jak mógłbym zrobić to z ESP8266, lub NRF24l01?

Witam. Chcę zrobić kierownice tylko trochę bardziej rozbudowaną czyli: kierownica 900*, sprzęgło, hamulec, gaz, skrzynia biegów 8+R (8 ponieważ gram w forze i tam niektóre samochody mają 7 lub 8 biegów), hamulec ręczny, kierunkowskaz, do tego boczny panel z max 20 guzikami + 2 analogowe joysticki (do grania w farming simulator). Teraz moje pytanie, ponieważ jedno arduino leonardo nie starczy do tego projektu to co zrobić my mieć tyle wejść w arduino. Jest jakich shield rozszerzający czy dokupić drugie arduino leonrado lub jakieś mini które komunikuje się przez usb też? I czy 2 rożne lub te same arduino można spiąć w jedno tak aby tylko jedno wysyłało dane do pc? Czy jesli kupie 3 pozycyjny przelacznik ( 1, 0 ,2) to czy będzie on mógł rozłączyć kierunkowskazy w grze. W farming simulator aby wyłączyć np. lewy kierunek trzeba kliknąć jeszcze raz guzik którym się włączało. Lub czy dał radę taki przełącznik jak jest w skuterach (gdy przełącznik jest w pozycji środkowej trzeba kliknąć go do środka aby się wyłączył) Mam pobrany program wheelConfig lecz bez podłączonego arduino nie mam tam wszystkich opcji dostępnych więc pytanie czy obsłuży on to wszystko co wymieniłem na początku. (EMC Utility Pro jest płatne a nie mam paypala). Jeśli wheel config nie podoła wszystkiemu to np. jeśli zainstaluje program do obsługi tego "bocznego panelu" to nie będzie się on gryzł w grze z wheel configiem? Tutaj temat na którym trochę się wzoruję i schemat do podłączenia połowy rzeczy których chcę

Od dawna interesowały mnie pomiary warunków meteorologicznych w mojej miejscowości, pierwsza stacja meteorologiczna, którą zbudowałem około roku 2010, wykonana była na mikrokontrolerze Atmega32. Do komunikacji z światem wykorzystywała moduł LAN Wiznet 7010a. Stacja ta była oprogramowana w języku BASCOM. Projekt który chcę zaprezentować dzisiaj działa już od roku 2018 i został oprogramowany w środowisku Arduino. Stacja została podzielona na 2 moduły, pierwszy pomiarowy oparty jest na klonie Arduino Nano oraz drugi odbiorczy którego sercem jest ESP8266 NodeMCU v3, służy on również do wyświetlania aktualnych pomiarów na wyświetlaczu LED dot matrix o wymiarach 8x56 punktów. Na pracach stolarskich się nie będziemy skupiać napiszę tylko że klatka meteorologiczna została wykonana z drewna sosnowego i umieszczona na wysokości 2 m. Moduł Pomiarowy Czujniki jakie zastosowałem to dwie sztuki DS18B20 pierwszy zajmuje się pomiarem temperatury przy gruncie na wysokości 5cm, drugi pełni rolę zapasowego czujnika temperatury na wypadek uszkodzenia się głównego czujnika BME280. Do pomiaru prędkości wiatru wykorzystuję wiatromierz firmy Maplin na jeden obrót wiatromierza przypadają 2 impulsy z kontaktronu który jest w nim zamontowany, producent dostarcza również odpowiedni wzór według którego można obliczyć rpm oraz prędkość wiatru w km/h. Dane mierzone przez wiatromierz możemy podzielić na dwie wartości, pierwsza to chwilowa prędkość, druga prędkość w porywach, aby uśrednić wartości mierzone program zlicza impulsy z 5s a następnie dokonuje odpowiednich obliczeń. Zebrane dane przesyłane są do drugiego urządzenia poprzez moduły radiowe które działają na częstotliwości 433,92 MHz. W tym celu zastosowana została biblioteka RCSwitch. Każda mierzona wartość jest wysyłana jako osobna transmisja. aby rozróżnić pomiary z konkretnych czujników mierzona wartość mnożona jest przez 100 a następnie dodawana jest liczba 100 000 dla pierwszego czujnika, 200 000 dla drugiego itd. Przykład kodu który realizuje tę funkcję poniżej: // temperatura sensor BME codetosend = temp * 100 + (1 * 100000); mySwitch.send(codetosend, 24); // wilgotnosc sensor BME codetosend = hum * 100 + (2 * 100000); mySwitch.send(codetosend, 24); Moduł Wewnętrzny Obudowa, która idealnie nadawała się do implementacji wewnętrznego modułu pochodzi z tunera IPTV Motorola VIP1910-9. Przedni panel został wykonany z ciemnego półprzepuszczalnego plastiku który idealnie nadaje się do umieszczenia w nim wyświetlacza. Sercem urządzenia jest układ ESP8266. "Moduł wewnętrzny" został również wyposażony w czujnik temperatury oraz wilgotności DHT22, dodatkowo w celu prezentacji zmierzonych wartości dołączone zostało 7 szt. modułów wyświetlacza LED dot matrix z układem MAX7219. Do obsługi tej matrycy zastosowałem bibliotekę Max72xxPanel.h która współpracuje z biblioteką Adafruit_GFX.h w ten sposób nie byłem zmuszony implementować do rozwiązania własnych czcionek. Matryca ta oprócz modułowej konstrukcji umożliwia również sterowaniem jasnością podświetlania, w tym celu aby uprzyjemnić użytkowanie w porach nocnych odbiornik został wyposażony w fotorezystor dzięki któremu potrafi określić natężenie oświetlenia otoczenia i odpowiednie ustawienie podświetlenia. Na wyświetlaczu w pierwszej kolejności wyświetlam aktualną godzinę oraz temperaturę wewnątrz pomieszczenia oraz wilgotność, po około jednej minucie wyświetlane są informacje odczytane z stacji meteo czyli temperatura wilgotność i ciśnienie, postanowiłem nie wyświetlać tutaj informacji dotyczących prędkości wiatru oraz temperatury przy gruncie. Decyzję tą podjąłem na podstawie użytkowania innego podobnego rozwiązania, akurat jak chcemy odczytać godzinę to wyświetlane są inne informacje. Dodatkowo w godzinach nocnych, które zostały ustawione w sztywnych ramach czasowych między 21:00 a 7:00 informacje odczytane z stacji meteo zostały okrojone tylko do temperatury. W projekcie zostały zastosowane 2 rodzaje animacji pierwsza z nich, przesuwa tekst z prawej strony wyświetlacza na lewą, z możliwością zatrzymania w interesujących momentach. Drugi rodzaj to pionowa animacja. Mikrokontroler również poprzez protokół NTP i bibliotekę time.h pobiera aktualną godzinę i datę. Za odbiór danych z pierwszego układu odpowiedzialny jest moduł radiowy którego obsługą tak jak w poprzednim module zajmuje się biblioteka RCswitch. Poniżej fragment programu który demonstruje w jaki sposób odbierane i dekodowane są dane: rc = mySwitch.getReceivedValue(); // czujnik temperatury powietrza BME280 if (abs(rc)>=50000&& abs(rc)<150000) { rc=(rc-100000)/100; if (rc > -50 and rc < 60) { temp1 = rc; Serial.print("Czujnik BME280 - temperatura: \t"); Serial.println(rc); matrix.drawPixel(55,0,1); matrix.write(); } } // czujnik wilgotności BME280 if (abs(rc)>=150000 && abs(rc)<250000) { rc=(rc-200000)/100; if (rc > 5 and rc <= 100) { hum = rc; Serial.print("Czujnik BME280 - wilgotnowsc: \t"); Serial.println(rc); matrix.drawPixel(55,1,1); matrix.write(); } } Dzięki zastosowaniu zewnętrznej anteny oraz odbiornika opartego na superheterodynie, zasięg w otwartym terenie to około 250 m. Po odebraniu danych z pierwszego układu poprzez moduł radiowy następuje przekazanie ich do serwera z systemem Domoticz. Domoticz to bardzo lekki system automatyki domowej, który pozwala monitorować i konfigurować różne urządzenia, przełączniki, czujniki takie jak temperatura, opady deszczu, wiatr, promieniowanie ultrafioletowe (UV), zużycie energii elektrycznej, zużycie gazu, zużycie wody i wiele więcej. Wykresy dostępne są również na stronie www http://meteo.palowice.net Poniżej film z działania odbiornika, smużenie animacji które występuje na filmiku ludzie oko nie rejestruje. Gdyby kogoś interesował kod to również zamieszczam: meteo.zip

Sprawa taka . w sklepie Botland zamówiłem sobie dwa takie moduły. https://botland.com.pl/pl/seria-gravity/10830-dfrobot-gravity-analogowy-czujnik-tds-czystosci-wody-dla-arduino.html Jeśli chodzi o sklep to wszystko w najlepszym porządku. Jest jednak maleńki problem. Podają tam link do strony producenta a tenże producent podaje kod który się nie kompiluje. Lekko mnie to skonsternowało dlatego zwracam się o pomoc w znalezieniu odpowiedzi na pytanie - co jest z tym kodem nie tak. Tu link do kodu: https://wiki.dfrobot.com/Gravity__Analog_TDS_Sensor___Meter_For_Arduino_SKU__SEN0244 /*************************************************** DFRobot Gravity: Analog TDS Sensor / Meter For Arduino <https://www.dfrobot.com/wiki/index.php/Gravity:_Analog_TDS_Sensor_/_Meter_For_Arduino_SKU:_SEN0244> Created 2017-8-22 By Jason <jason.ling@dfrobot.com@dfrobot.com> GNU Lesser General Public License. See <http://www.gnu.org/licenses/> for details. All above must be included in any redistribution /***********Notice and Trouble shooting*************** 1. This code is tested on Arduino Uno and Leonardo with Arduino IDE 1.0.5 r2 and 1.8.2. 2. More details, please click this link: <https://www.dfrobot.com/wiki/index.php/Gravity:_Analog_TDS_Sensor_/_Meter_For_Arduino_SKU:_SEN0244> ****************************************************/ #define TdsSensorPin A1 #define VREF 5.0 // analog reference voltage(Volt) of the ADC #define SCOUNT 30 // sum of sample point int analogBuffer[SCOUNT]; // store the analog value in the array, read from ADC int analogBufferTemp[SCOUNT]; int analogBufferIndex = 0,copyIndex = 0; float averageVoltage = 0,tdsValue = 0,temperature = 25; void setup() { Serial.begin(115200); pinMode(TdsSensorPin,INPUT); } void loop() { static unsigned long analogSampleTimepoint = millis(); if(millis()-analogSampleTimepoint > 40U) //every 40 milliseconds,read the analog value from the ADC { analogSampleTimepoint = millis(); analogBuffer[analogBufferIndex] = analogRead(TdsSensorPin); //read the analog value and store into the buffer analogBufferIndex++; if(analogBufferIndex == SCOUNT) analogBufferIndex = 0; } static unsigned long printTimepoint = millis(); if(millis()-printTimepoint > 800U) { printTimepoint = millis(); for(copyIndex=0;copyIndex<SCOUNT;copyIndex++) analogBufferTemp[copyIndex]= analogBuffer[copyIndex]; averageVoltage = getMedianNum(analogBufferTemp,SCOUNT) * (float)VREF / 1024.0; // read the analog value more stable by the median filtering algorithm, and convert to voltage value float compensationCoefficient=1.0+0.02*(temperature-25.0); //temperature compensation formula: fFinalResult(25^C) = fFinalResult(current)/(1.0+0.02*(fTP-25.0)); float compensationVolatge=averageVoltage/compensationCoefficient; //temperature compensation tdsValue=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value //Serial.print("voltage:"); //Serial.print(averageVoltage,2); //Serial.print("V "); Serial.print("TDS Value:"); Serial.print(tdsValue,0); Serial.println("ppm"); } } int getMedianNum(int bArray[], int iFilterLen) { int bTab[iFilterLen]; for (byte i = 0; i<iFilterLen; i++) bTab[i] = bArray[i]; int i, j, bTemp; for (j = 0; j < iFilterLen - 1; j++) { for (i = 0; i < iFilterLen - j - 1; i++) { if (bTab[i] > bTab[i++ 1]) { bTemp = bTab[i]; bTab[i] = bTab[i++ 1]; bTab[i+1] = bTemp; } } } if ((iFilterLen & 1) > 0) bTemp = bTab[(iFilterLen - 1) / 2]; else bTemp = (bTab[iFilterLen / 2] + bTab[iFilterLen / 2 - 1]) / 2; return bTemp; } to ten pierwszy.

Witam wszystkich! Dzisiaj przedstawię mój kolejny projekt robota z "recyklingu", ponieważ znalazłem spisany na straty, kompletnie zniszczony samochód RC w skali 1:16. Z tej zabawki udało mi się odzyskać przedni, tylny układ napędowy i kilka mniejszych części mechanicznych. Proto ma napęd 4x4 i skrętną przednią oś. Z tego wszystkiego wyszedł całkiem szybki i zwinny robot, więc chce się nim pochwalić. Mechanika Proto: Plastikowa płytka trzymająca cały samochód w kupie była dość mocno pęknięta, a usztywnienia nie znalazłem. Postanowiłem więc samodzielnie zaprojektować i wydrukować w 3D wszystkie potrzebne części za pomocą mojej Anet A6. Dodatkowo płyta, którą wydrukowałem, okazała się trochę za długa i musiałem zaprojektować przedłużenie wała napędowego, aby zachować napęd na cztery koła. Silnik który pasował do konstrukcji to silnik typu 500 zasiany napięciem 12V, a serwo to zwykłe serwo typu standard. Uznałem, że najlepsza metoda montażu pcb z elektroniką i pakietu zasilającego to rzepy, żeby dało się szybko wymieniać te elementy. Elektronika i zasilanie: Płytkę PCB zaprojektowałem i wytrawiłem samemu, znajduje się na niej już używane przeze mnie czyli połączenie czyli H-bridge VNS2sp30, Arduino NANO i moduł bluetooth XM-15B. Ten zestaw wydaje się najwydajniejszy nawet jeśli weźmie się pod uwagę to że używam tylko jednego z dwóch sterowników na czerwonej płytce. Dodatkowo na PCB znalazł się buzzer (klakson i alarm), przycisk i dodatkowe wyprowadzenia (nie wyprowadzałem wszystkich pinów, ale teraz wiem że to lepiej było wyprowadzać wszystkie dostępne, poprawię to kiedyś). Płyta główna jest osadzona na kolejnym wydrukowanym stelażu z rzepem. Zasilanie robota to trzy ogniwa 18650 o pojemności 1000mAh każde. Projekt koszyka na ogniwa ukradłem z Thingiverse. Baterie dają napięcie ~12V i wystarczają w zupełności do prawidłowego funkcjonowania robota. Dodatkowo z tyłu zamontowany jest woltomierz do monitorowania napięcia. Aplikacja do sterowania przed Bluetooth to keuwl, moim zdaniem to jedna z najlepszych aplikacji tego typu. Na koniec pokarze jeszcze kilka fotek całego projektu i film na YouTube: Mam nadzieję że robot Proto spodoba się wszystkim użytkownikom. Pozdrawiam, Technowsky

Witam Mam problem z paskiem led z diodami WS2812B i arduino uno. Pasek wyświetla błędne kolory, da przykładu kiedy chcę aby trzy diody zapaliły się na kolor czerwony to uzyskuję kolor czerwony niebieski oraz zielony. Dałem już rezystor na sygnał sterowania, ale nic to nie pomogło. Diody zasilałem zewnętrznym zasilaczem 5V i oczywiście GND spięte z GND arduino. Próbowałem też zmian w kodzie i dwóch różnych bibliotek ale cały czas mam ten sam problem.

Dawno, dawno temu, kiedy Internet jeszcze raczkował... Miałem niesamowite szczęście — zostaliśmy zaproszeni do zwiedzenia Studia Hensona. My — to znaczy cały zespół pewnego teatru. Łazilismy po tym studio, nasi artyści rozmawiali z ichniejszymi artystami... a ja się nudziłem jak mops. Na szczęście Cheryl Henson to zauważyła, i po mojej informacji że jestem technikiem a nie aktorem — zaprowadziła mnie do pracowni. Dużo mógłbym na tem temat mówić (nie wiem czy mi wolno, ale technologie chyba nie są już tajemnicą), w każdym razie szczękę z podłogi zbierałem jakiś tydzień. Kermit na selsynach (kto pamięta co to?), kostium misia (tego z reklamy Coli) nafaszerowany elektroniką chyba bardziej niż skafander Armstronga, tajemniczy proces tworzenia skóry Piggy czy czterdziestocalowy kineskopowy monitor w montażowni... Wtedy postanowiłem sobie, że też muszę zrobić lalkę. Może nie jestem mistrzem w konstrukcji lalek, ale coś na ten temat wiem... Problem był prosty: o ile lalki Hensona przeznaczone są do filmu (czyli trzy osoby animujące Kermita, akumulatory wystarczające na kilka minut i zasada "czego nie widzi kamera tego nie ma") — o tyle ja chciałem zrobić lalkę teatralną. Dla niezorientowanych mam proste porównanie. Lalka Hensona jest jak wyścigowy bolid, który zasuwa najszybciej jak może (ale co okrążenie trzeba mu wymienić opony razem z kołami, zatankować, najlepiej zrobić pełny przegląd a do jazdy potrzebna jest kilkuosobowa ekipa). Lalka teatralna przypomina bardziej terenówkę — wjedzie wszędzie, tankuje się raz na jakiś czas jeśli gdzieś w pobliżu jest stacja benzynowa, przegląd się robi raz przed wyjazdem, a do prowadzenia jest potrzebny kierowca sztuk jeden. A jednak postanowiłem, że coś tam podpatrzę z Hensona, coś z typowych teatralnych lalek, i może coś wyjdzie. Wybór padł na jawajkę z dwóch powodów: po pierwsze jest stosunkowo prosta w konstrukcji, po drugie osoba która miała ową lalkę animować specjalizuje się właśnie w jawajce. Od razu uprzedzam ewentualne pretensje i aluzje do worklogów: moim celem było zrobienie pełnej konstrukcji i sprawdzenie, czy animacja jest w ogóle możliwa. Ubranie i makijaż to inna sprawa, muszę wybrać czy będę płacić, czy nauczę się szyć (to drugie chyba bardziej mi odpowiada) czy w ogóle zostawię lalkę taką jaka jest na pamiątkę i wezmę się za następną; w każdym razie projekt jest z mojej strony skończony. Zacząłem od założeń. Przede wszystkim postanowiłem trochę zmienić zasady ruchu głowy. W najprostszej jawajce głowa jest nieruchoma. Dodatkowe możliwości to ruch obrotowy, ew. możliwość skłonu. O ile z ruchem obrotowym nie ma problemu, o tyle różne mechanizmy przenoszące napęd na głowę bywają chimeryczne i awaryjne (a to zerwie się gumka prostująca głowę, a to coś stanie się z linką). Dodatkowo aby zmusić lalkę do skłonu głowy potrzebna jest stosunkowo duża siła. Tak więc naturalne mi się wydało zastąpienie takiego mechanizmu elektronicznym. Chciałem również wyposażyć lalkę w możliwości w jawajkach rzadko spotykane: możliwość poruszania oczami oraz przynajmniej jedna chwytna ręka. Tu też z uwagi na samą konstrukcję jawajki i sposób animacji nie jest możliwe zrobienie tego poprzez czysto mechaniczne rozwiązania. I tak mam zaszczyt przedstawić: Maestro Zittaurus, mistrza obojga magii, dla znajomych Ziutek (dla dalszych znajomych pan Ziutek). "Kręgosłup" lalki (zastępujący tradycyjny kij) został wykonany z dwóch rurek: wewnętrzna grubościenna rurka wodociągowa PCW 17mm przenosi ruch obrotowy na głowę, a jej sztywność wystarczy aby się nie uginała w czasie poruszania lalką. Zewnętrzna to zwykła cienkościenna rurka instalacyjna, na której spoczywa ciężar głowy i do której mocowane są ramiona. Głowę zaprojektowałem w programie FaceGen 3d Print (bardzo dobrze działa pod Wine) jako solid model i OpenSCAD-em wyciąłem w niej miejsca na oczy oraz mechanizmy napędowe.Przewody do serw biegną wewnątrz rurki. Użyłem tu zwykłych serw micro TowerPro SG90 przede wszystkim ze względu na ich popularność (a poza tym kilka ich miałem). Niestety — z kilku przyczyn nie było to dobry wybór, ale o tym później. Trochę problemu sprawił mi mechanizm dłoni. Nawet najmniejsze dostępne serwa są za wielkie, aby umieścić je wewnątrz dłoni. Tym samym umieszczając serwo w przedramieniu musiałem zmienić tradycyjny sposób mocowania dłoni (sznurek) na jakiś sztywny. Myślałem na początku o czymś w rodzaju bowdena, ale w mońcu wpadłem na pomysł zastosowania podwójnego przegubu kulowego. Kule zostały wydrukowane, łączący je pręt to ucięty kawałek śruby M4 przewiercony wzdłuż wiertłem 1.8 mm. Przycisk wyzwalający zamknięcie dłoni został umieszczony w rękojeści czempuritu. Początkowo projektowałem sterowanie proporcjonalne — ale szybko zdałem sobie sprawę, że nie ma to żadnego sensu: układ dłoni animatora na rękojeściach nie pozwala na tego typu sterowanie, dużo lepszym rozwiązaniem jest po prostu przycisk, po którego naciśnięciu zmienia się stan dłoni (zamknięta/otwarta). W rękojeści została umieszczona cała elektronika: akumulator 18650 2600 mAh, ładowarka z zabezpieczeniem, przetwornica MT 3608 oraz Arduino Pro Mini. Do sterowania ruchami głowy i oczu służy płaski joystick oraz pierścień (żółty na zdjęciu) do obracania głową na boki. Joystick został umieszczony zgodnie z życzeniem animatorki — tak jest jej najwygodniej operować. Do kontroli stanu akumulatora słuzy dioda — jeśli zaczyna migać, warto rozejrzeć się za jakąś ładowarką. Nie zamieszczam schematu — w końcu to trywialne podłączenie joysticka, przycisku i trzech serw do małego Arduino. Kod jest bardzo prosty, od typowego różni się wyłącznie klasą MyServo automatycznie odłączającą serwomechanizm jeśli nie jest używany przez co najmniej sekundę: #include <Servo.h> class MyServo: public Servo { public: MyServo(int pin); void writePos(int pos); void heartbeat(void); private: bool rlyAttached; int lastPosition; int servoPin; uint32_t lastMillis; }; MyServo::MyServo(int pin) { servoPin = pin; rlyAttached = 0; lastPosition = -1; } void MyServo:: writePos(int pos) { pos = constrain(pos, 0, 180); if (pos != lastPosition) { if (!rlyAttached) { rlyAttached = true; attach(servoPin); } write(pos); lastPosition = pos; lastMillis = millis(); return; } heartbeat(); } void MyServo:: heartbeat(void) { if (rlyAttached && millis() - lastMillis > 1000UL) { detach(); rlyAttached = 0; } } #define OCZY_PIN A1 #define GLOWA_PIN A0 #define REKA_PIN A2 #define VOLT_PIN A3 #define OCZY_SRV 11 #define GLOWA_SRV 10 #define REKA_SRV 12 #define LED_PIN 13 MyServo reka(REKA_SRV), glowa(GLOWA_SRV), oczy(OCZY_SRV); #define MINVOLT 675 #define MAXVOLT 775 void setup() { reka.writePos(90); oczy.writePos(90); glowa.writePos(180); pinMode(LED_PIN, OUTPUT); pinMode(REKA_PIN, INPUT_PULLUP); } uint32_t handStateChanged; bool handState; int handLevel = 180; int headLevel = 180; int eyesLevel = 90; #define OKO_BL 500 #define OKO_BU 550 #define OKO_LL 250 #define OKO_LU 810 void getInput(void) { int v_oko = analogRead(OCZY_PIN); int v_glowa = analogRead(GLOWA_PIN); int v_volt = analogRead(VOLT_PIN); bool v_reka = digitalRead(REKA_PIN); v_volt = constrain(v_volt, MINVOLT, MAXVOLT); v_volt = map(v_volt, MINVOLT, MAXVOLT, 100, 1000); digitalWrite(LED_PIN, (millis() % 1000) < v_volt); v_glowa = constrain(v_glowa, 220,490); v_glowa = map(v_glowa, 490,220,180,0); if (v_glowa == 180 || v_glowa == 0 || abs(v_glowa - headLevel) >10) { headLevel=v_glowa; } v_oko = constrain(v_oko, OKO_LL, OKO_LU); if (v_oko < OKO_BL) v_oko = map(v_oko,OKO_LL, OKO_BL,0,90); else if (v_oko > OKO_BU) v_oko = map(v_oko,OKO_BU, OKO_LU,90,180); else v_oko = 90; if (v_oko == 0 || v_oko == 180 || v_oko == 90 || abs(v_oko - eyesLevel) >= 6) { eyesLevel = v_oko; } if (v_reka == handState) return; if (millis() - handStateChanged < 200UL) return; handState = v_reka; handStateChanged = millis(); if (!handState) { handLevel=handLevel?0:180; } } void loop() { getInput(); reka.writePos(map(handLevel,0,180,0,90)); glowa.writePos(headLevel); oczy.writePos(180-eyesLevel); } Ziutek wyszedł mi całkiem nieźle (tzn. realizuje wszystko co założyłem), a teraz kolej na możliwe poprawki: W rękojeści powinien się znaleźć wyłącznie stosunkowo ciężki akumulator wraz z ładowarką. Arduino i przetwornicę należałoby podwiesić do rurki na wysokości tułowia lalki. W tym przypadku nie wchodzi już w grę przeprowadzenie przewodów wewnątrz rurki, ale rozwiązanie tego nie powinno być problemem. Dodatkowo należałoby wyprowadzić na jakimś gnieździe interfejs UART. Przycisk sterujący otwarciem/zamknięciem dłoni powinien być zdublowany na rękojeści. Sterowanie ruchami głowy powinno być możliwe za pomocą jednego palca. W ten sposób uzyskam pewniejszy chwyt rękojeści i możliwość łatwiejszego operowania manipulatorami oczu i dłoni. Sama rękojeść powinna być dopasowana do dłoni konkretnego animatora. No i oczywiście należy zastosować inne serwa; jakie — o to już będę pytał we właściwym dziale. W razie pytań jestem do dyspozycji.

Witam, od kilku dni próbuję podziałać coś z moim ESP8266. Chodzi mi o to aby wgrać do niego obsługę komend AT abym mógł go połączyć z Arduino i sterować nim za pomocą Blynka. Broblem w tym że w żaden sposób nie mogę tego zrobić. Gdy chcę przetestować wpisując "AT" w monitorze portu szeregowego to nie mogę tego zrobić bo ESP jak głupie wali cały czas czymś takim jak na zdj. Dioda od ESP cały czas szybko miga. Proszę o pomoc bo już nie mam siły.

Witam, ostatnio wszedłem w posiadanie czterech 13,5 V paneli słonecznych i chcę z nich zrobić zasilanie do stacji pogodowej arduino. Rozumiem że będę potrzebować zasilania kiedy pogoda nie będzie sprzyjać. Jestem zielony jeżeli chodzi o elektrotechnikę i mam parę pytań: Jaką baterię polecacie do utrzymania takiej stacji pogodowej? W jaki sposób powinienem połączyć panele tak aby były w stanie najwydajniej ładować baterię? Jaki moduł ładowania byłby odpowiedni do mojego zastosowania? Czy ten moduł byłby ok gdybym zastosował przetwornicę step-down (do 5,5 V) gdy panele generują 13,5 V przy maksymalnym słońcu? Wiem że te panele mogą być trochę za mocne na ten projekt, ale na prawdę nie mam na nie pomysłu. Może zamiast stacji pogodowej powinienem coś innego z nimi zrobić?

Cześć, mam problem z moim pojazdem sterowanym przez podczerwień, jeśli za komentuję funkcje od kierunku jazdy program bez problemu rozpoznaje przyciski i wysyła komunikat jaki przycisk jest wciśniety. Natomiast jeśli od komentuję funkcje wykrywa dobrze tylko pierwszy wciśnięty przycisk a wartości następnych przycisków są inne niż powinny być. Wszystko widać na zdjęciach. Sprzęt Arduino UNO + L293D Shield Motor +IR Receiver z ali . Proszę o pomoc i z góry dziękuję. Do sterownia pojazdu używam pięciu przycisków przycisk 2 (551486205) -> do przód przycisk 4 (551542815) -> w lewo przycisk 5 (551494365) -> stop przycisk 6 (551510175) -> w prawo przycisk 8 (551518845) -> do tyłu Niestety nie mogłem wysłać tutaj zdjęć, wyskakiwał jakiś błąd https://ibb.co/th1Krv2 https://ibb.co/cc5rtLC #include <IRremote.h> #include <AFMotor.h> #define irPin 9 //initial motors pin AF_DCMotor motor1(1); AF_DCMotor motor2(2); AF_DCMotor motor3(3); AF_DCMotor motor4(4); IRrecv irrecv(irPin); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); } void loop() { if (irrecv.decode(&results)) { Serial.println(results.value); switch (results.value) { case 551542815: //left(); Serial.println("w lewo"); break; case 551486205: //forward(); Serial.println("w gore"); break; case 551510175: //right(); Serial.println("w prawo"); break; case 551518845: //back(); Serial.println("w dol"); break; case 551494365: //Stop(); Serial.println("srodek"); break; } irrecv.resume(); } } void forward() { motor1.setSpeed(255); //Define maximum velocity motor1.run(FORWARD); //rotate the motor clockwise motor2.setSpeed(255); //Define maximum velocity motor2.run(FORWARD); //rotate the motor clockwise motor3.setSpeed(255);//Define maximum velocity motor3.run(FORWARD); //rotate the motor clockwise motor4.setSpeed(255);//Define maximum velocity motor4.run(FORWARD); //rotate the motor clockwise } void back() { motor1.setSpeed(255); //Define maximum velocity motor1.run(BACKWARD); //rotate the motor anti-clockwise motor2.setSpeed(255); //Define maximum velocity motor2.run(BACKWARD); //rotate the motor anti-clockwise motor3.setSpeed(255); //Define maximum velocity motor3.run(BACKWARD); //rotate the motor anti-clockwise motor4.setSpeed(255); //Define maximum velocity motor4.run(BACKWARD); //rotate the motor anti-clockwise } void left() { motor1.setSpeed(255); //Define maximum velocity motor1.run(BACKWARD); //rotate the motor anti-clockwise motor2.setSpeed(255); //Define maximum velocity motor2.run(BACKWARD); //rotate the motor anti-clockwise motor3.setSpeed(255); //Define maximum velocity motor3.run(FORWARD); //rotate the motor clockwise motor4.setSpeed(255); //Define maximum velocity motor4.run(FORWARD); //rotate the motor clockwise } void right() { motor1.setSpeed(255); //Define maximum velocity motor1.run(FORWARD); //rotate the motor clockwise motor2.setSpeed(255); //Define maximum velocity motor2.run(FORWARD); //rotate the motor clockwise motor3.setSpeed(255); //Define maximum velocity motor3.run(BACKWARD); //rotate the motor anti-clockwise motor4.setSpeed(255); //Define maximum velocity motor4.run(BACKWARD); //rotate the motor anti-clockwise } void Stop() { motor1.setSpeed(0); //Define minimum velocity motor1.run(RELEASE); //stop the motor when release the button motor2.setSpeed(0); //Define minimum velocity motor2.run(RELEASE); //rotate the motor clockwise motor3.setSpeed(0); //Define minimum velocity motor3.run(RELEASE); //stop the motor when release the button motor4.setSpeed(0); //Define minimum velocity motor4.run(RELEASE); //stop the motor when release the button }

Witam, Mam problem i to dosyć spory, ponieważ zepsułem swoje arduino leonardo w taki sposób, że podłączyłem zły zasilacz i zamiast DC, arduino otrzymało 12V AC. Zwracam się z pomocą gdzie szukać problemu i czy w ogóle istnieje możliwość naprawy. Chciałbym sam naprawić uszkodzony element. Dlatego też pisze na forum o pomoc od czego zacząć sprawdzanie czy dany element jest okej czy też nie. Oczywiście o ile jest możliwość wskrzeszenia tego maleństwa. Z góry dzięki za pomoc :). Ja osobiście na pierwszy rzut oka nie widzę żadnych zmian ale wrzucam zdjęcie dla osób które może coś dostrzegą.

Jak napisałem.

Witam! Chciałbym zaprezentować Wam lodówkę, którą sam zrobiłem. Elementy z których zbudowałem lodówkę: Sklejka 6mm styropian 30mm Zestaw radiatorów Wentylatory Ogniwo Peltiera 5A Przekaźnik Arduino UNO Czujnik temperatury DS18B20 2 przełączniki Gniazdo DC 5,5x2,5mm Zasilana jest zasilaczem 12V 7A. Tak duży prąd potrzebny jest do zasilania 5A ogniwa Peltiera , 2 wentylatorów i LED'ów. Nie był potrzebny aż tak mocny, ale tylko taki miałem pod ręką. Do zasilania "zabezpieczenia" używam 2A ładowarki. niestety za późno zorientowałem się, że będzie potrzebne, przez co nie podpiąłem bezpośrednio do zasilacza. Niestety, kupując zasilacz o tak wysokim natężeniu prądu nie przewidziałem, że nie posiadam odpowiedniego kabla zasilającego. W domu znalazłem tylko taki, który da MAX 2,5A. Obudowa jest wykonana ze sklejki o grubości 6mm pomalowanej czarną matową farbą do drewna. Wyłożona jest styropianem o grubości 3cm a drzwiczki zrobione są z 4mm pleksy. Po między pleksą a styropianem jest uszczelka, która choć częściowo zapobiega uciekaniu zimna. Lodówka posiada magnesy dzięki którym drzwiczki są przyciśnięte do uszczelki. W środku zamontowałem LED'y w dwóch kolorach: białym zimnym i niebieskim. Niebieski zapala się gdy drzwiczki są zamknięte a biały, gdy są są otwarte. Z tyłu obudowy są dwa przełączniki. Jeden służy do włączania LED'ów a drugi włącza wentylatory i ogniwo Peltiera. Do chłodzenia lodówki użyłem modułu wentylatora z radiatorami przeznaczonego do ogniwa Peltiera. Niestety od zimnej strony ogniwa, mniejszy radiator nie ma wentylatora, więc musiałem go dokupić. Jego wymiary to 40mm x 40mm x10mm Obok przycisków jest otwór przez który wlatuje powietrze. Radiator z tyłu obudowy bardzo się grzał przez co musiałem wymyślić coś dzięki czemu temperatura była by stabilizowana i ograniczana. Wpadłem na pomysł aby przy temperaturze 45°C ogniwo było odłączone na 100 sekund(wentylatory wciąż pracują). W tym czasie wentylator chłodzi radiator. Do odłączenia zasilania ogniwa użyłem przekaźnika, Arduino UNO i czujnika temperatury DS18B20+. Chciałem użyć Nano, ale jak na złość wszystkie były uszkodzone. Do Arduino wgrałem odpowiedni program i podłączyłem wszystko na płytce stykowej. Dodatkowo temperaturę można sprawdzać na komputerze komunikując się z płytką przez interfejs UART. #include <OneWire.h> #include <DallasTemperature.h> OneWire oneWire(A3); //Podłączenie do A3 DallasTemperature sensors(&oneWire); //Przekazania informacji do biblioteki #define przekaznik 7 void setup(void) { pinMode(przekaznik, OUTPUT); Serial.begin(9600); sensors.begin(); //Inicjalizacja czujnikow } void loop(void) { sensors.requestTemperatures(); //Pobranie temperatury czujnika Serial.print("Temperatura radiatora to: "); Serial.println(sensors.getTempCByIndex(0)); delay(1000); if(sensors.getTempCByIndex(0) >45){//Jesli temperatura radiatira jest wyzsza niz 45 stopni digitalWrite(przekaznik, HIGH); delay(100000); digitalWrite(przekaznik,LOW); } } Niestety, na ten moment nie posiadam termometru, którym mógł bym sprawdzić różnicę temperatury. Ale po około 30 min pracy napój w puszce lekko się schłodził. Może nie jest bardzo wydajna ale mi wystarcza.

Witam. Mam problem z wgraniem programu na klon Arduino Nano. wcześniej było wszysko ok do czasu tego błędu podczas wgrywania. avrdude: stk500_recv(): programmer is not responding avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0xa6 Dziwne jest też to że czasa,i końcówka błędu jest np. resp=0x4a lub resp=0x28 Gdy korzystałem z tego Arduino czuć było, że coś zaczęło śmierdzieć. Biorę także możliwość, że to ja coś uszkodziłem. Czy miał ktoś podobny problem. Da się to naprawić czy zostaje kosz?