Przeszukaj forum

Napisz program HTML z wyglądem wiersza poleceń, który będzie mógł być przełączany pomiędzy wyglądem zielonego systemu Linux, Windows 11, Windows 3.1, Mac OS oraz Raspberry Pi. Musisz zmienić wygląd, znak zachęty, tło i obramowanie oraz kolor, aby miał on wygląd aplikacji. Pole tekstowe także musi się znaleźć. Po wpisaniu w nie tekstu powinien znikać tekst. Dodatkowo, musisz dodać pasek 'X', '_' i 'zmień rozmiar', ale pamiętaj, że wygląd, znak zachęty, kolor, obramowanie i pole tekstowe nie mogą się powtarzać!

Dzień dobry, Chciałbym się zapytać czy istnieje na urządzeniu Raspberry Pi 3B+ polski lektor(męski) ?- Python, biblioteka: pyttsx3. Szukam już po internecie od dłuższego czasu i na nic nie mogę trafić. Id polskiego głosu jaki pokazuje mi program brzmi "polish" jednak po wybraniu go brzmi on dość mało "polsko". Chciałbym się dowiedzieć czy ten głos po prostu taki jest, czy ja coś robię nie tak. Jeśli istnieje jakiś inny sposób dodania polskiego głosy do maliny to prosiłbym o podpowiedź gdzie i jak mogę go znaleźć. (Sorki za jakoś zdjęcia, ale zależy mi na czasie)

Dzień dobry nazywam się Antek dostałem w prezencie książkę ,,Arduino dla dzieci". Próbuję wykonywać przykłady z książki, ale program ,,Arduino" ciągle wyrzuca mi błędy. Prosił bym o pomoc w zweryfikowaniu problemu poniżej przesyłam przykład kodu jaki napisałem. Z góry dziękuje za pomoc. int RedPin = 9; int BluePin = 10; int GreenPin = 11; void setup() { pinMode(RedPin, OUTPUT); pinMode(GreenPin, OUTPUT); pinMode(BluePin, OUTPUT); } void loop() { digitalWrite(RedPin, HIGH); digitalWrite(GreenPin, LOW); digitalWrite(BluePin, LOW); delay(1000); } digitalWrite(RedPin, LOW); digitalWrite(GreenPin, HIGH); digitalWrite(BluePin, LOW); delay(1000); } digitalWrite(RedPin, LOW); digitalWrite(GreenPin, LOW); digitalWrite(BluePin, HIGH); delay(1000); digitalWrite(RedPin, HIGH); digitalWrite(GreenPin, HIGH); digitalWrite(BluePin, HIGH); delay(1000); digitalWrite(RedPin, HIGH); digitalWrite(GreenPin, LOW); digitalWrite(BluePin, HIGH); delay(1000); digitalWrite(RedPin, HIGH); digitalWrite(GreenPin, HIGH); digitalWrite(BluePin, LOW); delay(1000); digitalWrite(RedPin, LOW); digitalWrite(GreenPin, HIGH); digitalWrite(BluePin, HIGH); delay(1000);

Cześć! Zapraszam wszystkie osoby, którym nie straszna jest analiza danych, #BigData, #MachineLearning czy #SztucznaInteligencja do udziału w #hackathonie CuValley Hack 2023 - III edycja Kiedy? 27-29 stycznia 2023 Gdzie? Online Jak? Zupełnie za darmo! Co na Was czeka? 3 zadania i pula nagród w wysokości 120 000 PLN! 40 godzin kodowania i networking na Slacku analiza danych, #AI, #MachineLearning, #BigData webinary, Keynote Speakerzy, porządna dawka wiedzy i inspiracji! Zarejestruj się już dzisiaj, aby otrzymać atrakcyjny prezent powitalny: https://cuvalley.com/

Dzień Dobry, Chciałbym nauczyć się podstaw assemblera. Mam tutaj na myśli strukturę języka (dyrektywy, sekcje programu itp.) - inaczej mówiąc, zagadnienia niezależne od architektury docelowej. Wiedzę chciałbym najbardziej wykorzystać przy pracowaniu z układami AVR i ARM. Korzystając z zasobów internetu trafiłem na wiele "tutoriali", jednak wszystkie z nich były wg mnie niedopracowane - wiele terminów było omawianych powierzchownie albo wcale, jakby autorzy z góry zakładali, że każdy te terminy zna. Tak więc, jeśli ktoś może zasugerować przystępną, w miarę aktualną lekturę, byłbym wdzięczny za jej link/tytuł.

Cześć. Postanowiłem zamieścić tu przykład kodu w ramach podzielenia się swoja "twórczością". Jeśli zły dział, proszę przenieść. Post głównie w celach edukacyjnych dla osób, które jeszcze nie miały okazje zrezygnować z miliona zmiennych Pin_1, Pin_2 itd. Dużo przyjemniej i czytelniej jest mieć wszystko skompresowane do obiektów, nawet jeśli to bedzie przerost formy nad treścią. Po prostu sam chciałbym coś takiego przeczytać rok-dwa temu 🙂 Swego czasu, gdy trochę więcej poświęcałem czasu na embedded, natrafiłem na jednym z kursów M. Salamona fajną (według mnie) metodę implementacji obsługi przycisku. Postanowiłem sobie ją trochę przerobić, gdyż oryginał był pisany pod C i używał callbacków, które średnio mi dobrze pasowały, bo za każdym razem napotykałem rozmaite problemy, z którymi średnio sobie umiałem poradzić. Napisałem więc sobie to jako klasę, a kolejno dopisałem drugą klasę, która dziedziczy po niej, a jednocześnie implementuje to co dzieje się po wciśnięciu tego przycisku. Jest to taki chyba najprostszy przykład zastosowania programowania obiektowego dla arduino. Zamieszczam Link do GitHub z plikami .h i .cpp. gdyż wstawienie tu całego kodu byłoby trochę przesadą? Celem w ogóle użycia dziedziczenia było zrobienie swoistej "templatki" dla klasy, która implementuje obsługę przycisku, ale nie definiuje tego co dzieje się po wciśnięciu tego przycisku. Zapewne 80% przycisków w projektach po prostu wystawia jakiś stan na konkretny Pin, więc można było darować sobie to dziedziczenie, no ale.. zrobiłem sobie to głównie pod siebie na przyszłość. W temacie programowania obiektowego jestem początkujący więc wszelakie uwagi od bardziej doświadczonych kolegów mile widziane, bo niestety ale wszystko to moje własne próby sklejenia czegoś z informacji, które zdobyłem. Opisując skromnie co dzieje się w implementacji i jakie są założenia: 1. Brak możliwości stworzenia podstawowej klasy // virtual destructor virtual ~TypeButton() = 0; // virtual methods virtual void ButtonPressed() = 0; virtual void ButtonNotPressed() = 0; Chciałem stworzyć sobie klasę, która będzie miała zaimplementowaną swoista "blokade", żeby nie kusiło stworzenia obiektu, który nie posiada implementacji dla funkcji obsługującej przycisk. W tym celu zmieniłem destruktor na wirtualny i przypisałem mu 0. W ten sposób ustawiłem destruktor czysto wirtualny, czyli taki którego nie można wywołać. Co za tym idzie, nie można również stworzyć obiektu. 2. Funkcje Pressed i NotPressed są wykonywane raz Funkcje wykonywane są raz tylko przy zmianie stanów z Debbounce -> Pressed i z Pressed-> Idle. Zabezpieczało mnie to przed wchodzeniem ciągle, w funkcje, która ustawia stan na wysoki/niski. 3. Działanie głównie opiera się na sprawdzaniu w pętli metody ButtonTask() void TypeButton::ButtonTask() { switch (this->State) { case IDLE: ButtonIdle(); break; case DEBBOUNCE: ButtonDebbounce(); break; case PRESSED: ButtonIsPressed(); break; default: break; } } Metoda za każdym razem sprawdza aktualny stan obiektu, z którego została wywoływana (this->State) i wykonuje funkcje, zależnie od tego w jakim stanie znajduje się aktualnie przycisk. 4. Opierając się na Klasie-rodzic można dorabiać dalej własne implementacje klasy-dziecka, które bedą wykonywać inne zadania. Kwestia inwencji własnej. Ogólnie, jak wspomniałem wcześniej wygląda to jak przerost formy nad treścią, ale obecnie bardzo mi ułatwia pisanie prototypów bo nie musze znowu martwić czy dobrze napisałem kod do przycisku. No i było bardzo fajną lekcją w kontekście robienia klas/metod wirtualnych. Z napotkanych problemów: Mimo, że zaimplementowałem destruktor jako pure virtual to i tak musiałem dodać w pliku .cpp na początku: TypeButton::~TypeButton(){} Bez tego dostawałem ciągłe błedy o tym, że w klasie-dziecko jest nieznany typ destruktora własnie TypeButton::~TypeButton(). Trochę nie mogłem zrozumieć czemu musiałem to zrobić. Wygrzebałem to w jednym z tematów na Stack Overflow i było to tam opisane czymś w rodzaju "Czasem trzeba dodać tego typu deklaracje mimo pure virutal destruktora". Albo ja nie uważałem podczas uczenia się, ale rzadko kiedy widziałem by ktoś miał taki problem. Może ktoś dużo mądrzejszy mi to wytłumaczy? 🙂 To by było na tyle. Wszelakie uwagi mile widziane

Witam próbuje poustawiać sobie wszystko do programowania i mam problem z instalacją pakietów NuGet w visual studio bo wyskakuje następujący błąd. "Błąd Nie można zainstalować pakietu „System.Device.Gpio 2.1.0”. Próbujesz zainstalować ten pakiet w projekcie, którego celem jest „native,Version=v0.0”, ale pakiet nie zawiera żadnych odwołań zestawu ani plików zawartości zgodnych z tą strukturą. Aby uzyskać więcej informacji, skontaktuj się z autorem pakietu." Nie bardzo wiem co mam z tym zrobić a w internecie nie widze nic sensownego na ten temat.

Witam, szukam dodatku/programu pozwalającego na ustawienie okienek w visual studio tak jak to wygląda w windows forms ale działającego na linuxe. W skrócie program ma komunikować sie przez modbus z arduino a te dane chce chce wyświetlić na monitorze i mieć klikalne przyciski i tym podobne. Ewentualnie jakieś inne rozwiązanie okienkowe chociaż najlepszy był by program klikalny najlepiej darmowy

Cześć, zastanawiam się na programowanie stm32 Blackpill. Póki co mam napisany program pod Nucleo-f7 i chciałbym teraz przenieść ten projekt na Blackpill ale niestety nie mogę znaleźć żadnych informacji na ten temat. Znalazłem jedynie informację przez Arduino ale nie chciałbym też pisać programu od początku. Czy jest na to jakiś dobry sprawdzony sposób?

Zapraszamy do współpracy osoby, posiadające doświadczenie w pracy z Arduino, pasjonujące się nowoczesnymi technologiami i lubiącymi pracę z dziećmi. Robocode to młoda, progresywna firmą, oferująca szkolenia dla dzieci i młodzieży w wieku od 8 do 16 lat w zakresie robotyki, programowania i myślenia projektowego 🚀 🤖 W związku z otwarciem pierwszej w Katowicach szkoły poszukujemy nauczycieli/instruktorów zajęć, pragnących rozwijać ją razem z nami! Nauczyciel w Robocode odpowiada za: Przeprowadzanie zajęć w interesujący i zrozumiały sposób, Znalezienie wspólnego języka z dziećmi, Śledzenie trendów innowacji w IT, Bieżącą współpracę z menedżerem szkoły i zespołem. 😎 Instruktor Robocode jest ekspertem, przyjacielem i mentorem, więc jeśli czujesz, że chodzi o Ciebie, jeśli lubisz dzielić się wiedzą oraz jesteś aktywną, dobrze zorganizowaną i nastawioną na rozwój osobą, dołącz do nas! Zapewniamy niezbędne materiały oraz szkolenia dla efektywnej pracy i rozwoju Twoich kompetencji, proponujemy system podwyższenia stawki początkowej. Wymiar pracy dostosowany jest do Twojej dyspozycyjności. Brzmi interesująco? A w rzeczywistości wygląda jeszcze ciekawiej! 📩 📩 📩 Osoby zainteresowane prosimy o przesłanie CV z aktualną klauzulą RODO oraz kilku zdań o sobie na adres poland.robocode@gmail.com. Więcej o nas przeczytać można na stronie robocode.pl. Czekamy na Ciebie w naszym super zespole! 😊

Słowem wstępu Niniejszy poradnik jest przeznaczony dla osób, które nie miały dotąd styczności z programowaniem aplikacji wizualno-obiektowych przy użyciu języka C# oraz platformy .NET (czytane jako dotnet). Skupimy się tu na podstawach języka oraz na tym, jak krok po kroku napisać wybrane aplikacje. Na początek trochę teorii Język C# jest odpowiedzą firmy Microsoft na obiektowy język Java. Struktura obu języków jest podobna, a więc osoba programująca do tej pory w Javie szybko będzie mogła stosować w C# znane już sobie mechanizmy. Platforma .NET pozwala na pisanie programów nie tylko w C#, ale także w F#, C++, Visual Basic'u, Pythonie, HTML-u, Javascript’cie czy Node.js - .NET zakłada, że wszystkie języki programowania są równe, jednak to, że Microsoft stworzył język C# oraz platformę .NET sprawiło, że programowanie w tym środowisku przy użyciu języka C# jest najbardziej wydajne. C# oraz platforma .NET pozwala także na pisanie aplikacji sieciowych, jednak ten temat nie zostanie tutaj poruszony. Ten artykuł bierze udział w naszym konkursie! 🔥 Na zwycięzców czekają karty podarunkowe Allegro, m.in.: 2000 zł, 1000 zł i 500 zł. Potrafisz napisać podobny poradnik? Opublikuj go na forum i zgłoś się do konkursu! Czekamy na ciekawe teksty związane z elektroniką i programowaniem. Sprawdź szczegóły » Podstawowa wiedza Zakładam, że część osób czytająca ten poradnik miała już w swoim życiu styczność z jakimś językiem programowania wysokiego poziomu, mimo to zachęcam do zapoznania się z tą częścią poradnika, a także wracania do niej w razie potrzeb. Informacje na temat środowiska oraz zapoznania się z nim będą w oddzielnej części, przeznaczonej tworzeniu aplikacji wizualno-obiektowej. Osobom, które nie wiedzą jednak czym jest język wysokiego poziomu spróbuję wyjaśnić za pomocą skrótu myślowego i odpowiedniego rysunku: W dużym skrócie: istnieją języki wysokiego i niskiego poziomu. Język wysokiego poziomu to ten zrozumiały dla człowieka, mający postać zmiennych, ich nazw, pętli, instrukcji warunkowych itd. Natomiast język niskiego poziomu to ten najbliższy komputerowi, mający postać zer i jedynek, operacji na pamięci itd. Dawno temu ludzie programowali maszyny za pomocą kart perforowanych z wyciętymi dziurami. Było to swoistym językiem niskiego poziomu, dochodziło do błędów i było nieprzystępne dla ludzi. To właśnie było powodem powstania języków wysokiego poziomu oraz kompilatorów/interpreterów tłumaczących je na kod maszynowy. Język C# pozwala nam pracować z poniższymi typami danych byte – przyjmuje wartości od 0 do 255 char – znaki w Unicode bool – prawda / fałsz sbyte – wartości od -128 do 127 short – wartości od -32,765 do 32,767 ushort – wartości od 0 65,535 int – wartości od -2,147,483,648 do 2,147,483,647 uint – wartości od 0 do 4,294,967,295 long – wartości od 18,446,744,073,709,551,615 ulong – wartości od 0 do 18,446,744,073,709,551,615 float – wartości od -3.402823e38 do 3.402823e38 double – wartości od -1.79769313486232e308 do 1.79769313486232e308 decimal – wartości +/- od 1.0 x 10e-28 do 7.9 x 10e28 string – sekwencja znaków Unicode DateTime – format daty i czasu (0:00:00am 1/1/01 do 11:59:59pm 12/31/9999) Oprócz tych typów danych są także typy skalarne enum oraz struct, jednak ich temat nie będzie teraz rozwijany. W wymienionych powyżej typach danych, niektóre posiadają przedrostek u- i oznacza on, że typ jest unsigned czyli nieprzypisany. To z kolei oznacza, że wartości ujemne zostały przeniesione na plus w celu zwiększenia pojemności typu. Środowisko programistyczne W tej części zajmiemy się pobieraniem środowiska oraz jego wstępną konfiguracją. Pobieranie środowiska Środowisko, w którym będziemy programować to Visual Studio Community 2019 i można je pobrać na stronie https://visualstudio.microsoft.com/pl/vs/community/, to środowisko jest darmowe. Wejdź pod podany przed chwilą adres, pobierz instalator i uruchom go na swoim komputerze. Instalacja środowiska jest prosta, więc poruszymy tylko niektóre aspekty z nią związane. Ekran instalatora Visual Studio Installer W tym poradniku potrzebne będzie nam pobranie dodatku Programowanie aplikacji klasycznych dla platformy .NET, znajduje się on w części Komputery i urządzenia przenośne. Instalator powinien sam zaznaczyć wymagane pakiety opcjonalne, jednak dla pewności sprawdź, czy w prawym okienku Szczegóły instalacji są zaznaczone opcje jak na powyższym zdjęciu. W przyszłości oczywiście możesz doinstalować kolejne pakiety przy użyciu programu, który instaluje się razem z Visual Studio (jest to Visual Studio Installer), jednak teraz potrzebne nam będą tylko te domyślnie zaznaczone. Po zaznaczeniu wciskamy przycisk Instaluj znajdujący się w prawym dolnym rogu. Po instalacji może być wymagane zalogowania się do konta Microsoft. Tworzenie projektu Po uruchomieniu Środowiska wybieramy opcję Utwórz nowy projekt. Ekran użytkownika po uruchomieniu środowiska Najpierw skupimy się na aplikacji konsolowej. Znajdź szablon "Aplikacja Konsolowa", upewnij się że wybrana opcja ma tag C# Nadajmy projektowi nazwę np. Hello World. W informacjach dodatkowych na razie nic nie zmieniamy. Wybieramy Utwórz i naszym oczom powinno pokazać się środowisko, w którym będziemy pracować. Domyślnie wygenerowana aplikacja konsolowa będzie miała już napisany kod programu Hello World, skupimy się więc na jego analizie oraz dodatkowych informacjach, które mogą się przydać. using System; namespace Hello_World { class Program { static void Main(string[] args) { Console.WriteLine("Hello World!"); } } } Na początek zaczniemy od funkcji Main. Znajdująca się w niej metoda WriteLine może odstraszać początkującego programistę, jednak spokojnie. Pracujemy z aplikacją konsolową, a co za tym idzie, jeśli chcemy wypisać coś w konsoli, musimy odwołać się do metody wypisz linie (WriteLine). Metoda ta należy do klasy konsola (Console). Metody oraz klasy można zrozumieć skrótem myślowym, w tym wypadku będzie to Konsola wypisz linie „Hello World!” class Program (klasa Program) jest klasą wygenerowaną, więc możemy napisać dla niej metodę, do której później będziemy mogli się odwołać, podobnie jak przy użyciu Console.WriteLine(); namespace Hello_World może wyglądać znajomo osobom, które pisały już w C++, gdzie dla ułatwienia stosowały using namespace std; w C# namespace deklaruje zakres (proste wytłumaczenie, czym jest zakres znajdzie się na końcu poradnika) jednak ten temat rozwiniemy za chwilę przy użyciu przykładu. W celu zademonstrowania i ułatwienia zrozumienia wiedzy zdobytej do tej pory, napisałem poniższy kod: using System; namespace Hello_World { class Klasa_HelloWorld { public static void Hello() { Console.WriteLine("Hello World!"); } } } namespace wypisywanie { class Klasa_Wypisywanie { static void Main(string[] args) { Hello_World.Klasa_HelloWorld.Hello(); } } } Aby uruchomić program klikamy przycisk oznaczony zielonym trójkątem Działanie kodu wygląda następująco: Wyjaśnię więc, co dzieje się po uruchomieniu programu. Funkcja Main znajdująca się w klasie Wypisywanie z namespace wypisywanie ma w sobie odwołanie do Metody Hello() klasy o nazwie Klasa_HelloWorld zakresu Hello_World. Sama klasa metoda jest publiczna (public static void). Z kolei metoda Hello() nie należy to klasy, w której jest wywoływana, jednak modyfikator dostępu public pozwala na jej wykorzystanie. Instrukcje wejścia/wyjścia Zanim przejdziemy dalej, trzeba wspomnieć o tym jak wyglądają instrukcje wejścia/wyjścia w C#. namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { String input = Console.ReadLine(); Console.WriteLine(input); } } } Dwa podstawowe polecenia wejścia i wyjścia to Console.ReadLine() oraz znane nam już Console.WriteLine(), w tym wypadku utworzyłem zmienną input, która jest ciągiem znaków (String) i przekazałem programowi, że zawiera w sobie to, co użytkownik wpisze w konsoli. Wykonywanie działań w języku C# Jak pewnie się domyślasz, w języku C# można wykonywać działania arytmetyczne, operatory arytmetyczne. Wyniki ich działań pokazuje poniższy kod. namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { double a = 10; double b = 4; Console.WriteLine(a + b); //dodawanie wynikiem będzie 14 Console.WriteLine(a - b); //odejmowanie wynikiem będzie 6 Console.WriteLine(a * b); //mnożenie wynikiem będzie 40 Console.WriteLine(a / b); //dzielenie wynikiem będzie 2,5 Console.WriteLine(a % b); //reszta z dzielenie wynikiem będzie 2 } } } Dla ułatwienia przekazu posłużyłem się zdefiniowanymi wartościami a oraz b, by w komentarzu (czym jest komentarz, wyjaśnię na końcu poradnika) pokazać przykładowe wyniki działań. W swoim kodzie możesz oczywiście wpisywać te zmienne przy użyciu polecenia Console.ReadLine(). Instrukcje warunkowe Pierwszą instrukcją warunkową, której działaniu się przyjrzymy jest if. Instrukcja warunkowa if przyjmuje jeden argument i wykonuje odpowiedni kod, jeśli argument jest spełniony. Warto także wspomnieć o słowie kluczowym else, które wykonuje inny kod, jeśli warunek nie został spełniony. Z połączenia obu tych poleceń wychodzi else if, który pozwala na doprecyzowanie kolejnego warunku. namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { String input = Console.ReadLine(); if(input == "hello") { Console.WriteLine("Hello World!"); } else if (input == "poradnik") { Console.WriteLine("Witamy w poradniku programowania w C#"); } else { Console.WriteLine("podano błędną wartość"); } } } } Powyższy kod sprawdza, czy użytkownik wpisał w konsoli słowo hello lub poradnik, i wykonuje odpowiednie polecenia. Jeśli zaś użytkownik wpisał coś innego, kod wyświetli komunikat o podaniu błędnej wartości. Drugą instrukcją warunkową, którą poznamy jest switch. Słowa kluczowe switch oraz case działają na podobnej (lecz nie identycznej) zasadzie co if i else. Różnica polega na wygodzie pisania oraz czasie wykonywania instrukcji (nie będzie tu poruszana szczegółowa analiza różnic w działaniu obu instrukcji). namespace Hello_World { class Program { static void Main(string[] args) { String input = Console.WriteLine(); switch (input) { case "hello": Console.WriteLine("Hello World!"); break; case "poradnik": Console.WriteLine("Poradnik programowania w C#"); break; default: Console.WriteLine("podano błędną wartość"); break; } } } } Powyższy kod działa identycznie jak ten z wykorzystaniem if oraz else. Słowo kluczowe break przerywa działanie funkcji oraz pętli. Pętle w języku C# Teraz spróbujmy wypisać w konsoli napis „Hello World!” 10 razy, można oczywiście w tym celu skopiować fragment kodu odpowiedzialny za to 10 razy. Jednak co w wypadku, gdy stwierdzimy, że 10 razy to za mało? Wtedy kopiowanie kodu nie ma sensu. Do uproszczenia tego procesu posłużą nam pętle. Osobom, które są już zapoznane z pętlami, ten fragment nie wniesie nic nowego, można więc go pominąć. Osobom, które chcą sobie powtórzyć lub nie wiedzą nic o pętlach warto powiedzieć że istnieją cztery różne pętle: for foreach while do while Pętla for namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { for(int i = 0; i<10; i++) { Console.WriteLine( i + " Hello World!"); } } } } Pętla for przyjmuję trzy argumenty, na obrazku są to kolejno: int i = 0 - ten argument wykonuje się tylko raz na początku wykonywania pętli; jest to zmienna, z którą pętla rozpoczyna swoje działanie; i<10 - to warunek pętli, w tym wypadku pętla będzie się wykonywała tak długo, aż wartość zdefiniowanej przed chwilą zmiennej będzie mniejsza od 10; i++ - to inkrementacja zmiennej czyli podniesienie jej wartości o 1 z każdym wykonaniem pętli. Pętla foreach namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { int[] tablica = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; foreach(int i in tablica) { Console.WriteLine( i + " Hello World!"); } } } } Pętla foreach wykonuje się dla każdego elementu tablicy. W tym wypadku zdefiniowałem tablicę liczb całkowitych int[], jako tablicę zawierającą 10 elementów. Pętla foreach przyjmuje dwa argumenty w tym wypadku int i inny, będący dowolnym elementem tablicy oraz in tablica, będący wskazaniem tablicy. While i do while namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { int i = 0; while (i < 10) { Console.Write(i + " Hello World!"); i++; } } } } Pętla while przyjmuje jeden warunek i będzie się wykonywać do momentu, kiedy warunek zostanie spełniony. namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { int i = 0; do { Console.Write(i + " Hello World!"); i++; }while (i < 10); } } } Pętla do while jest podobna do pętlu while, z tym że wykona się przynajmniej raz, niezależnie od prawdziwości warunku. namespace wypisywanie { class Wypisywanie { static void Main(string[] args) { int i = 11; do { Console.Write(i + " Hello World!"); i++; }while (i < 10); } } Na powyższym obrazku widać, że do while wykonało się raz, mimo iż warunek nie jest spełniony. Ćwiczenie Przy użyciu zdobytej wiedzy spróbuj napisać prosty kalkulator obsługujący działania na dwóch liczbach. Wskazówka do Ćwiczenia W razie problemów z pisaniem postaraj się wyobrazić sobie albo narysować schemat działania twojego programu. Czy ma najpierw wypisać komunikat i oczekiwać na wybranie danego działania? Ma poprosić o podanie liczb na których ma operować, czy w inny sposób ma poprowadzić użytkownika do wykonania działania? Pierwsza aplikacja wizualno-obiektowa W tej części poradnika zajmiemy się pisaniem twojej pierwszej aplikacji z interfejsem użytkownika. Na początku skoncentrujemy się na potrzebnych nam elementach środowiska i podstawowych kontrolkach, które będziemy wykorzystywać, potem zajmiemy się pisaniem prostego kalkulatora. Tworzenie nowego projektu W tej części poradnika dalej będziemy pracować ze środowiskiem Visual Studio Community. W poprzedniej części zainstalowaliśmy wszystkie potrzebne nam elementy tego środowiska, które będą nam potrzebne podczas tworzenia projektu. Po uruchomieniu Visual Studio wybieramy opcję „Utwórz nowy projekt”. Następnie z listy wybieramy „Aplikacja Windows Forms”, jeśli masz problem ze znalezieniem odpowiedniej opcji, możesz wpisać ją w wyszukiwarce szablonów. Klikamy „Dalej” i nadajemy naszemu projektowi odpowiednią nazwę. Po nadaniu nazwy i kliknięciu „Dalej” pojawi się okienko proszące nas o wybranie wersji .NET, z którą chcemy pracować. W tym poradniku pracujemy z .NET Core 3.1. Po upewnieniu się, że wybraliśmy odpowiednią opcję, klikamy „Utwórz”. Po utworzeniu projektu pokaże nam się takie okno. Znajduje się na nim puste okienko aplikacji, którą teraz tworzymy. Możemy uruchomić projekt w taki sam sposób jak robiliśmy to z aplikacją konsolową. Klikamy nazwę naszego projektu, która jest obok zielonej strzałki i po chwili pojawi nam się takie same okienko jak w środowisku. Możemy to okienko zamknąć w taki sam sposób jak inne aplikacje komputerowe - krzyżykiem znajdującym się w prawym górnym rogu. Jednak lepiej zamykać projekt z poziomu środowiska, ponieważ przy bardziej rozbudowanych projektach zamknięcie okienka nie musi oznaczać końca działania aplikacji. Znajdź czerwony kwadrat w w górnej części środowiska, będzie w tym samym miejscu, co przycisk odpowiedzialny za uruchomienie aplikacji. Czerwony kwadrat zatrzyma działanie aplikacji, opcję po lewej i prawej stronie czerwonego kwadratu odpowiadają kolejno za wstrzymanie działania programu oraz za ponowne uruchomienie. Potrzebne informacje o środowisku Teraz skupimy się na elementach środowiska, których będziemy potrzebować. Po lewej stronie będzie zwinięty pasek o nazwie Przybornik. Na górze listy Przybornika znajduje się wyszukiwarka, pozwala w szybki sposób znaleźć potrzebne nam elementy interfejsu. Skupimy się teraz na kontrolce „Button” oraz „TextBox”. Na powyższych zdjęciach znajdują się potrzebne nam kontrolki znalezione przy użyciu wyszukiwarki. Po znalezieniu odpowiednich kontrolek przeciągamy je na obszar roboczy. W związku z tym, że w poradniku zajmujemy się pisaniem aplikacji „Kalkulator”, potrzebne nam będzie 16 przycisków (10 numerycznych i 6 funkcyjnych) oraz jeden TextBox do wyświetlania wyniku. Dla ułatwienia sobie pracy, po przeciągnięciu pierwszego przycisku ustaw jego wymiary na takie, które chcesz mieć w projekcie końcowym. Późniejsza zmiana rozmiarów wielu elementów może być czasochłonna i nieprzyjemna. Aby zmienić rozmiar przycisku kliknij go i rozciągnij używając charakterystycznych punktów, które się pojawią. Gdy już nadasz kontrolce odpowiednie wymiary, możesz ją skopiować skrótem klawiszowym ctrl + c i wkleić kolejne przyciski o tych samych wymiarach. Wymiary kontrolki TextBox zmienia się w identyczny sposób, jednak jeśli chcesz ustawić jej wysokość, musisz wybrać opcję MultiLine klikając kolejno trójkącik nad wybranym TextBox’em, a następnie opcję MultiLine. Po dodaniu wszystkich potrzebnych kontrolek, moja propozycja wyglądu aplikacji prezentuje się następująco: Po napisaniu kodu aplikacja byłaby funkcjonalna, jednak jej wygląd oraz podpisy nie są przyjazne użytkownikowi, dlatego aby to zmienić, możemy dostosować wszystkie elementy interfejsu. Po wybraniu dowolnego elementu w prawym dolnym rogu środowiska pojawią nam się właściwości, które dla tego elementu możemy zmienić. Zachęcam do samodzielnego zapoznania się ze wszystkimi elementami, dlatego teraz skupmy się tylko na podstawowych, które będą nam potrzebne. Na początek zmienimy nazwę przycisku oraz tekst, jaki jest w nim wyświetlany. By zmienić nazwę w segmencie Design zmienimy właściwość (Name) na liczba_7 oraz w segmencie Wygląd właściwość text na 7. Możemy tez dostosować wygląd, zmieniając właściwości z segmentu Widok, takie jak BackColor (kolor tła), BorderSize z listy FlatApperance (grubość ramki wokół przycisku) oraz FlatStyle (ogólny wygląd przycisku. Zachęcam do samodzielnej zabawy tymi ustawieniami i zobaczenia jak wpływają na wygląd kontrolki. W ten sam sposób możesz również zmienić ustawienia okienka klikając na nie i zmieniając np. kolor tła albo rodzaj ramki. Teraz zmienimy ustawienia TextBox’a. Zmień właściwość Text na przykładowy ciąg liczb, TextAlign na Right oraz rozmiar czcionki właściwością Font, dostosuj czcionkę do rozmiaru kontrolki (pamiętaj, żeby usunąć wybrany przez siebie ciąg liczb po dobraniu satysfakcjonujących ustawień czcionki) . Zaproponowany przeze mnie wygląd aplikacji jest teraz taki: Teraz dodajmy naszemu kalkulatorowi kod, by zapewnić mu pewną funkcjonalność. Po podwójnym kliknięciu na kontrolkę, środowisko wygeneruje nam fragment kodu odpowiedzialny za wykonanie poleceń mających miejsce po kliknięciu przycisku w programie. Kliknij dwukrotnie na wszystkie przyciski. using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; namespace WinFormsApp1 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void liczba_1_Click(object sender, EventArgs e) { } } } Na powyższym obrazku widać wygenerowany kod. Zauważ, że funkcja void przyjmuje nazwy takie jak nazwy kontrolek, które przed chwilą stworzyłeś. W programie potrzebne będą nam trzy zmienne globalne: jedna przechowująca znak działania, jedna przechowująca wynik i jedna zmienna kontrolna. Double wynik = 0; //wynik działania String operacja = ""; //zmienna przechowująca znak działania bool czyPrzeprowadzaOperacje = false; //zmienna kontrolna do sprawdzania czy można przeprowadzić operacje Żeby móc wykonywać działania, potrzebne będą nam liczby. W tym celu dla każdej kontrolki w kodzie musimy przypisać wartość liczbową. private void liczba_7_Click(object sender, EventArgs e) { czyPrzeprowadzaOperacje = false; Button przycisk = (Button)sender; textBox1.Text = textBox1.Text + przycisk.Text; } Powyższy kod zadziała dla każdej kontrolki, można by go użyć nawet bez wklejania do każdej funkcji _Click, jednak dla ułatwienia skupimy się na prostszej wersji. Zanim wkleisz kod do wszystkich funkcji, wyjaśnię ci, w jaki sposób on działa. Na samym początku zmienna czyPrzeprowadzaOperacje jest ustawiona na fałsz. Użyjemy tej zmiennej, żeby upewnić się, że kod będzie działał dokładnie tak jak tego chcemy. Kolejna linijka “Button button = (Button)sender” na niewtajemniczonych robi wrażenie, jednak jest to bardzo proste. Ta linijka tworzy nowy obiekt typu Button o nazwie przycisk, zaś (Button)sender w uproszczeniu tworzy nadawcę. Cała funkcja należy do przycisku 7, który jest nadawcą, więc ta linijka sprawia, że nasz przycisk może „odebrać” informacje sam od siebie. Ostatnia linijka jest łatwa do zrozumienia. Chcemy przypisać tekst dla pola tekstowego i, aby to zrobić, wywołujemy Text z textBox1, a następnie przypisujemy mu tekst zawarty w przycisku (w tym wypadku jest to 7). Teraz możesz skopiować ten kod dla innych liczb. Nie martw się, nic złego się nie stanie 😊. Jak już skopiujesz ten kod w odpowiednie miejsca, uruchom program i upewnij się, że wszystkie liczby wyświetlają się poprawnie. Następnie potrzebny nam będzie kod sprawdzający, jaka operacja została wybrana. private void dzielenie_Click(object sender, EventArgs e) { Button button = (Button)sender; if (wynik != 0) { rownosc.PerformClick(); operacja = button.Text; czyPrzeprowadzaOperacje = true; } else { operacja = button.Text; wynik = Double.Parse(textBox1.Text); textBox1.Text = " "; czyPrzeprowadzaOperacje = true; } } Pozwoli na to powyższy kod. Podobnie jak poprzednio, ten sam kod możesz zastosować dla każdego przycisku osobno. Zanim jednak go powklejasz tam gdzie trzeba - trochę wyjaśnień. Zajmę się rzeczami, które wykorzystujemy po raz pierwszy. Linijka rownosc.PerformClick() ta linijka odwołuje się do kontrolni o nazwie rownosc, a PerformClick() to metoda, która wykona kod w przycisku równości bez jego kliknięcia. Stanie się tak, tylko jeśli wynik będzie różny od zera. Linijka wynik = Double.Parse(textBox1.Text) przypisze zmiennej wynik wartość z textbox1 nie możemy tego jednak zrobić bezpośrednio, w tym celu użyjemy metody Parse by zmienić string zawierający ciąg liczbowy na typ Double. Niezależnie od spełnienia instrukcji warunkowej if, zmieniamy zmienną czyPrzeprowadzaOperację naprawdę. Teraz potrzebna nam funkcja, która wykonuje obliczenia. private void rownosc_Click(object sender, EventArgs e) { switch (operacja) { case "+": textBox1.Text = (wynik + Double.Parse(textBox1.Text)).ToString(); break; case "-": textBox1.Text = (wynik - Double.Parse(textBox1.Text)).ToString(); break; case "*": textBox1.Text = (wynik * Double.Parse(textBox1.Text)).ToString(); break; case "/": textBox1.Text = (wynik / Double.Parse(textBox1.Text)).ToString(); break; default: break; } wynik = Double.Parse(textBox1.Text); } Powyższy kod wykorzystuje instrukcję switch case w celu sprawdzenia jaką operację chcemy wykonać. Jeśli spełnimy jeden z warunków, wtedy wykona się odpowiednie działanie. Skupimy się teraz na tym, co nowe. W każdej instrukcji case możesz zauważyć metodę ToString(), w tym wypadku używamy jej, żeby wyświetlić wynik obliczeń w textBox’ie. Zauważ, że wykonujemy obliczenia na typach liczbowych, których nie możemy bezpośrednio wyświetlić, właśnie dlatego używamy metody ToString(). Na koniec zostało nam tylko zajęcie się przyciskiem CE. Dla zapewnienia jego funkcjonalności wykorzystamy poniższy kod. private void CE_Click(object sender, EventArgs e) { textBox1.Text = " "; wynik = 0; } Dodatkowe objaśnienia pojęć, które wystąpiły w poradniku Zakres – dla ułatwienia przekazu posłużymy się przykładem static void Main(string[] args) { //to jest zmienna x z tego zakresu int x = 3; } void InnaFunkcja() { //to jest zmienna x z tego zakresu String x = "Hello"; } W powyższym fragmencie kodu znajdują się dwie funkcje, każda z tych funkcji jest ograniczona przez „agrafki” (otwarcia „{„ oraz zamknięcia „}”) te agrafki są zakresem tej funkcji, co sprawia, że wszystko co się w nim znajduje, jest widziane tylko w tym zakresie i nie jest dostępne poza nim. Komentarz – w języki C# możemy „zakomentować” fragmenty kodu, oznacza to, że kompilator nie będzie brał tego fragmentu pod uwagę przy kompilowaniu naszego kodu. Istnieją dwa rodzaje komentarza: jednoliniowy oraz wieloliniowy, pokazane na poniższym obrazku: static void Main(string[] args) { //to jest komentarz jednoliniowy /** to jest komentarz wieloliniowy */ } Praca domowa Chciałbym, abyś po ukończeniu tego poradnika samodzielnie zapoznał się z właściwościami kontrolek i zmieniał ich wygląd. Postaraj się także dodać dodatkową funkcjonalność w postaci obsługi liczb dziesiętnych, potęg oraz pierwiastków. Powodzenia 😊.

CUDA na kiju (a nawet GPU) cz. 1 Wstęp Tym artykułem chciałbym zapoczątkować cykl artykułów na temat programowania równoległego z wykorzystaniem kart graficznych (GPU) w języku CUDA C. W części pierwszej przedstawię krótki wstęp teoretyczny tzn. omówię dlaczego równoległe wykonywanie obliczeń może istotnie przyspieszyć działanie programu, opiszę budowę procesorów graficznych, a w dalszych częściach będą przedstawione praktyczne wskazówki z fragmentami kodu programu do mnożenia macierzy. Zapraszam do lektury! Treść artykułu została usunięta, ponieważ użytkownik publikujący ten poradnik wykorzystał w nim materiały, do których nie posiadał odpowiednich praw. Usunięcie nastąpiło na prośbę autora zapożyczonych materiałów.

CUDA na kiju (a nawet GPU) cz 2. Wstęp W poprzedniej części omówiliśmy sobie dlaczego warto wykorzystać procesory graficzne do obliczeń oraz po krótce zapoznaliśmy się z ich budową. W tej części omówimy sobie wszystko to co należy zrobić przed napisaniem programu: podam kilka informacji przydatnych podczas rozważania programu równoległego, przygotujemy środowisko do pisania programu w CUDA C, a następnie przygotujemy podwaliny pod pierwszy program tzn. opracujemy sobie teorię mnożenia macierzy oraz napiszemy prototyp programu na CPU. Gotowi? No to jazda!!! Treść artykułu została usunięta, ponieważ użytkownik publikujący ten poradnik wykorzystał w nim materiały, do których nie posiadał odpowiednich praw. Usunięcie nastąpiło na prośbę autora zapożyczonych materiałów.

CUDA na kiju (a nawet GPU) cz. 4 Wstęp W trzeciej części serii artykułów CUDA na kiju (a nawet GPU) udało nam się stworzyć nasz pierwszy CUDOwny program mnożący macierze. Program działa poprawnie ale (jeszcze) nie grzeszy szybkością o ile rozmiary problemu nie są olbrzymie. W tym artykule spróbujemy go zatem trochę przyśpieszyć. Do celów testowych powrócimy do rozmiaru macierzy 1021x1021. Treść artykułu została usunięta, ponieważ użytkownik publikujący ten poradnik wykorzystał w nim materiały, do których nie posiadał odpowiednich praw. Usunięcie nastąpiło na prośbę autora zapożyczonych materiałów.

CUDA na kiju (a nawet GPU) cz. 3 Wstęp W części drugiej artykułu stworzyliśmy szkielet programu do mnożenia macierzy oraz prototyp funkcji jądra wykonującej iloczyn skalarny wiersza macierzy A i kolumny macierzy B czyli pojedynczy element macierzy wynikowej C. W tym artykule pójdziemy krok dalej to znaczy wreszcie napiszemy program na GPU. Będzie to od nas wymagało zmian w funkcji matmul, wywołującej jądro oraz wewnątrz samego jądra. Rozpoczniemy od najprostszej wersji programu implementując po prostu to co robił program CPU na procesorze graficznym i z czasem będziemy ją sobie komplikować za każdym razem sprawdzając jakie przyspieszenie względem wersji CPU uzyskaliśmy. Nie ma co już dłużej zwlekać. Lecimy z tematem 😊. Treść artykułu została usunięta, ponieważ użytkownik publikujący ten poradnik wykorzystał w nim materiały, do których nie posiadał odpowiednich praw. Usunięcie nastąpiło na prośbę autora zapożyczonych materiałów.

Cześć forumowicze! Mam do was ogromną prośbę, robie projekt, "motogp simulator" który ma działać tak jak zwykła kierownica do gier, tylko ze ma byc motocyklem. Problem jest w tym ze chciałbym zrobić to na własnym kontrolerze (nie na arduino na którym aktualnie jest) problem jest w tym z e jestem totalnie zielony w avr jakbyscie mogli dać jakie kolwiek porady odnośnie tego jak zacząć byłbym niezwykle wdzięczny

Zamysł: „ATMEGA” jako PLC. Wszystko zaczęło się od chęci programowania/użycia sterownika PLC w domowych warunkach do prostych automatyzacji. Jednakże oryginalne sterowniki PLC są drogie. Nawet jeżeli ktoś by się zdecydował na jego zakup to nie wykorzystał by jego możliwości. Postanowiłem więc zbudować coś co może przypominać sterownik PLC i nie tylko przypominać, ale także działać na tej samej zasadzie. Jak wiemy sterowniki PLC najczęściej programuje się w języku „LD” co może być problemem przy programowaniu mikrokontrolerów AVR. Jednak je programujemy w języku „C”, czyli języku, który jest najbardziej popularny oraz oczekiwany w dziedzinie programowania. Istnieją programy które przetworzą nam program napisany w języku „LD” na „C” lecz do samego programowania mojego projektu nie jest to konieczne jedynie, gdzie widzę sens użycia takiego programu to programowanie sterownika przez inną osobę, która nie zna języka „C”. Jest to urządzenie z dużym potencjałem mam tutaj na myśli „nieograniczoną” możliwość rozbudowy i przystosowania do samego użytkownika. Cenowo tutaj nie będę porównywał, bo nie ma żadnego porównania, tak samo jak do prawdziwego sterownika PLC który to już długi czas króluje na rynku i ciągle się rozwija. Reasumując „ATMEGA” jako PLC jest bardzo ciekawym, tanim projektem, który możemy wykorzystać w naszych domach do sterowania prostych oraz średniozaawansowanych czynności. Budowa: Wszystkie połączenia oraz schemat płytki drukowanej wykonałem w programie EasyEDA. Następnie ścieżki wydrukowałem na papierze kredowym i odbiłem je na laminacie poprzez termo-transfer. Następnie wytrawiłem płytkę oraz wywierciłem otwory pod elementy przewlekane. Zacząłem lutować elementy, na samym początku przylutowałem wszystkie elementy potrzebne do zaprogramowania oraz uruchomienia mikrokontrolera oraz tylko jedno wyjście(przekaźnik). Po wypróbowaniu czy wszystko działa zgodnie z założeniem przylutowałem resztę elementów. Tak wiem nie wyczyściłem pytki. Następną czynnością było zaprojektowanie i wydrukowanie obudowy na płytkę i złożenie w całość. Dodałem opisy na obudowie jak wszystko powinno być podłączone. Przyszedł czas na testy. Wgrałem prosty program działający na zasadzie: jeśli podamy stan wysoki na wejście I1 załączy się wyjście Q1 po odłączeniu stanu wysokiego i po ponownym jego podaniu na wejście I1 spowoduje wyłączenie wyjścia Q1. Jeśli podamy stan wysoki na wejście I2 wyjście Q1 załączy się i wyłączy po 5 sekundach. Nie chodzi tu o zagłębianie się w sens tego programu tylko chodzi o pokazanie działania urządzenia. Filmik pokazujący działanie układu: ⚠️UWAGA! W filmiku zostało użyte wysokie napięcie które jest niebezpieczne dla zdrowia i życia.⚠️ Działania na rozwój projektu: W dalszym rozwoju projektu chciałbym dodać dodatkowe funkcje. Jedną z nich jest umożliwienie odczytu analogowych wartości z wejść urządzeń działających na logikę 5V takich jak: Potencjometr Fotorezystory Czujniki temperatury Dodanie wyjść PWM do sterowania prędkościami silników oraz natężeniem światła. Dodanie magistrali I2C do komunikacji np. pomiędzy kontrolerem a wyświetlaczem oraz innymi urządzeniami, które obsługują tą magistrale. Zmniejszeniem rozmiaru płytki drukowanej. Dodanie innych wersji sterowników np. 2 wejścia i 2 wyjścia do sterowania prostymi urządzeniami. Dodanie modułu Wi-Fi poprzez który będzie można odczytywać informacje dotyczące np. temperatury i zmieniać ustawienia z każdego miejsca, gdzie będziemy mieli dostęp do Internetu poprzez aplikację. Spis elementów elektronicznych:

Dzień dobry, Potrzebuję wyciągnąć informacje z pliku Midi ( numer, początek i długość dźwięku) formatu 0 których będę potem używał do sterowania arduino. Dane będą następnie przesyłane do tablicy z której arduino będzie pobierać informacje o pozycji. Jestem początkujący , a to mój pierwszy wpis proszę o wyrozumiałość 😉

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); } } }

Source Enterprise sp. z o.o. sp. k. jest ambitnym, stabilnie finansowanym krakowskim start-up’em. Rekrutujemy do nowych zespołów badawczo-rozwojowych. Zespoły te zajmowały będą się konstruowaniem mobilnych robotów oraz budową ekosystemu do zarządzania nimi. PROGRAMISTA MIKROKONTROLERÓW Miejsce pracy: Kraków, Wola Justowska Marzy Ci się kreatywna praca w startup’ie? Chciałbyś brać realny udział w tworzeniu nowych konstrukcji mechatronicznych? Pracujemy w interdyscyplinarnych zespołach. Tworząc zespół, wybieramy osoby, których umiejętności będą nawzajem się uzupełniały. Do Twoich zadań należeć będzie: tworzenie i rozwój oprogramowania w języku “C”, programowanie mikrokontrolerów Espressif ESP32, Nordic nRF, STM32, tworzenie oraz aktualizacja dokumentacji, budowa oraz testowanie prototypów. Oczekujemy od Ciebie: minimum 3 lata doświadczenia w programowaniu z wykorzystaniem języka z rodziny “C”, bardzo dobrej znajomości programowania w języku “C” i/lub “C++”, doświadczenia w programowaniu mikrokontrolerów (8-,32-bitowych) w “C” i/lub “C++”, znajomości specyfiki programowania systemów wbudowanych z uwzględnieniem ograniczonych zasobów sprzętowych, umiejętności obsługi podstawowych peryferiów, umiejętność obsługi komunikacji BLE oraz WiFi, wiedzy w zakresie elektroniki cyfrowej i analogowej umożliwiającej czytanie schematów zawierających cyfrowe i analogowe obwody elektroniczne, znajomości elektroniki w stopniu pozwalającym na świadomą implementację obsługi poszczególnych bloków elektronicznych, umiejętności posługiwania się urządzeniami kontrolno-pomiarowymi, znajomości języka angielskiego min. na poziomie B2, umiejętności samodzielnego rozwiązywania problemów, samodzielności w dziedzinie, którą reprezentujesz. Dodatkowo możesz pochwalić się: wykształceniem wyższym, osiągnięciami w realizacji projektów związanych z robotyką, znajomością oprogramowania Atlassian: Confluence, Jira, Bitbucket, doświadczeniem w zwinnym podejściu do zarządzania projektami, znajomością zagadnień szyfrowania oraz transmisji danych. Oferujemy: pracę w zespole Scrum, wynagrodzenie adekwatne do posiadanych umiejętności i zaangażowania, umowę o pracę lub B2B, pokój kreatywny, pyszną kawę. Prosimy o przesyłanie CV w języku polskim wraz z klauzulą RODO na adres mailowy careers@see.inc. Klauzula: “Wyrażam zgodę na przetwarzanie moich danych osobowych przez firmę Source Enterprise Spółka z ograniczoną odpowiedzialnością Spółka Komandytowa dla potrzeb niezbędnych do realizacji procesu rekrutacji zgodnie z Rozporządzeniem Parlamentu Europejskiego i Rady (UE) 2016/679 z dnia 27 kwietnia 2016 r. w sprawie ochrony osób fizycznych w związku z przetwarzaniem danych osobowych i w sprawie swobodnego przepływu takich danych oraz uchylenia dyrektywy 95/46/WE (RODO).” Oraz jeśli chcesz wziąć udział w przyszłych rekrutacjach: “Wyrażam również zgodę na przetwarzanie moich danych osobowych w celu prowadzenia przyszłych rekrutacji przez wyżej wskazaną firmę.” Wysyłając swoje CV i inne dokumenty aplikacyjne wyrażasz zgodę na przetwarzanie swoich danych osobowych przez Source Enterprise Spółka z ograniczoną odpowiedzialnością Spółka Komandytowa z siedzibą w Krakowie, ul. Starowolska 9, 30-231 Kraków, jako administratora danych osobowych, na potrzeby realizacji toczącego się procesu rekrutacyjnego. Udzielenie zgody jest dobrowolne, jednak niezbędne w celu wzięcia udziału w rekrutacji na stanowisko wskazane w ogłoszeniu. Zgoda może zostać w każdym czasie wycofana poprzez wysłanie oświadczenia na adres e-mail: gdpr@see.inc lub na wskazany powyżej adres siedziby, jednak uniemożliwi to dalszy udział w rekrutacji. Twoje dane osobowe wskazane w Kodeksie pracy lub w innych ustawach szczegółowych (według wymogów ogłoszenia), są przetwarzane w oparciu o przepisy prawa i ich podanie jest konieczne do wzięcia udziału w rekrutacji. Pozostałe dane osobowe (np. Twój wizerunek) przetwarzamy na podstawie Twojej dobrowolnej zgody, którą wyraziłaś/eś wysyłając nam swoje zgłoszenie rekrutacyjne i ich podanie nie ma wpływu na możliwość udziału w rekrutacji. Możemy przetwarzać Twoje dane osobowe zawarte w zgłoszeniu rekrutacyjnym także w celu ustalenia, dochodzenia lub obrony przed roszczeniami, jeżeli roszczenia dotyczą prowadzonej przez nas rekrutacji. W tym celu będziemy przetwarzać Twoje dane osobowe w oparciu o nasz prawnie uzasadniony interes, polegający na ustaleniu, dochodzeniu lub obrony przed roszczeniami w postępowaniu przed sądami lub organami państwowymi. Masz prawo dostępu do swoich danych, w tym uzyskania ich kopii, sprostowania danych, żądania ich usunięcia, ograniczenia przetwarzania, wniesienia sprzeciwu wobec przetwarzania oraz przeniesienia podanych danych (na których przetwarzanie wyraziłeś zgodę) do innego administratora danych. Masz także prawo do wniesienia skargi do Generalnego Inspektora Ochrony Danych Osobowych (w przyszłości: Prezesa Urzędu Ochrony Danych Osobowych). Cofnięcie zgody pozostaje bez wpływu na zgodność z prawem przetwarzania, którego dokonano na podstawie zgody przed jej cofnięciem. Twoje dane osobowe przetwarzamy w celu prowadzenia rekrutacji na stanowisko wskazane w ogłoszeniu przez okres nie dłuższy niż 180 dni od momentu zakończenia procesu rekrutacji, a gdy wyraziłaś/eś zgodę na udział w przyszłych rekrutacjach przez okres nie dłuższy niż 3 lata od momentu zakończenia rekrutacji. Ponadto Twoje dane osobowe możemy przechowywać dla celów ustalenia, dochodzenia lub obrony przed roszczeniami związanymi z procesem rekrutacji przez okres nie dłuższy niż 3 lata od momentu zakończenia rekrutacji. W określonych przypadkach możemy przetwarzać Twoje dane dłużej niż 3 lata, jeżeli taka konieczność wynika z przepisów prawa. Nie przekazujemy Twoich danych osobowych poza Europejski Obszar Gospodarczy. W razie pytań możesz się z nami skontaktować pod adresem e-mail gdpr@see.inc. Zastrzegamy możliwość kontaktu tylko z wybranymi kandydatami.

Witam serdecznie Jak nie ten dział to proszę przenieść:) Zbudowałem pixel poi na podstawie projektu z dwóch stron: https://learn.adafruit.com/supernova-poi oraz: https://forum.pjrc.com/threads/30020-Teensy-APA102-POV-Poi-Pixel-Poi-Build-Tutorial. Działa to wszystko całkiem przyzwoicie ale projekt jest rozwojowy. Przede wszystkim chciałbym napisać program pod windows do wgrywania grafik(otwarte oprogramowanie w którym jak będę chciał zbudować większy czy mniejszy wyświetlacz będzie opcja podania ilości diod czy np sterowania przez bluetooth bądź bez) Chce dodać karty sd i zmienić miejsce włącznika(miałby go zastąpić micro-styk na górze przy zaczepie łańcucha o ile można załatwić to programowo). Na rękojeści miałby znaleźć się włącznik programu. Chciałbym zacząć od dopisania kodu żeby po uruchomieniu przez kilka sekund na pasku led wyświetlał się stan naładowania baterii(w środku znajduje się ogniwo 18650). Ktoś wie jak to zrobić?? Jaki kod i gdzie wpisać?? Mój kod to: #include "FastLED.h" #define NUM_LEDS 60 #define DATA_PIN 13 #define CLOCK_PIN 11 CRGB leds[NUM_LEDS]; //int numberOfSlices = 150; void setup() { delay(200); FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN,BGR>(leds, NUM_LEDS); } //for post use this> const unsigned int array1[] = { 0xfaa60f, 0xffaf10, 0xffb914, 0xf7b312, 0xd99a01, ...... const unsigned int array2[] = { 0x080300, 0x050102, 0x000005, 0x000106, 0x020307,... void PoiSonic(unsigned long time, const unsigned int array[], int sliceNumber); void loop() { PoiSonic(10000,array1,120);//15 PoiSonic(10000,array2,256);//16 } void PoiSonic(unsigned long time, const unsigned int array[], int sliceNumber){ unsigned long currentTime = millis(); while (millis()< currentTime + (time)) { int f= sliceNumber;// previously used numberOfSlices; int z; //a counter int j=NUM_LEDS; for (int x=0;x<f;x++){ for(z=NUM_LEDS;z>0;z--){ leds[z-1]=array[x+((j-z)*f)];} FastLED.show(); delayMicroseconds(40); //may need to increase / decrease depending on spin rate } delayMicroseconds(1000); //may need to increase / decrease depending on spin rate } }

Cześć! Jako nowy użytkownik, przede wszystkim chciałbym się przywitać. Szukam pomocy w zrealizowaniu projektu (oczywiście zapłacę)- zdalnie sterowanego wózka inwalidzkiego. Historia i pomysł są następujące: Poruszam się na wózku, ręcznym. Proces poruszania się, wolałbym zautomatyzować dla własnej wygody, a niejednokrotnie potrzeby. Mam na stanie hulajnogę Xiaomi m365, którą chciałbym wykorzystać podczas prac (silnik, sterownik, bateria). Wózek, czyli ramę, koła i tapicerkę mogę zrobić sam. Cóż mi zatem potrzebne? Osoba, która zajmie się oprogramowaniem sterowania silnikiem skręcania, silnikiem napędowym i zintegrowania tego w jeden, najlepiej bezprzewodowy, obsługiwany jedną ręką kontroler, jak np ten: Chciałbym, aby wózek wyglądał mniej więcej tak: Co chciałbym otrzymać: Jak wspomniałem powyżej, zintegrowane sterowanie wózkiem inwalidzkim z poziomu bezprzewodowego, obsługiwanego jedną ręką kontrolera. Pomoc w zakresie doboru i zakupu niezbędnych materiałów (silnik do sterowania, wszelkiego rodzaju sterowniki, arduino (bądź inna platforma), etc). Optymalnie byłoby, gdyby wykonawca był z okolic Poznania, lub Wrocławia. Sam pochodzę z Leszna, byłoby fantastycznie, gdybym mógł w tym procesie uczestniczyć i czegoś się nauczyć. Chciałbym oczywiście dzielić się z Wami postępami prac, także będę je tu publikował. Będzie to dla mnie bardzo ważny projekt, gdyż po osiągnięciu celu, miałbym kilka nowych pomysłów do realizacji i byćmoże komercjalizacji.

Witam serdecznie! Chciałbym się podzielić stworzoną przez siebie graficzną aplikacją na Raspberry Pi 4 do podkręcania i wyświetlania informacji o systemie (wersja jądra, akutalna temperatura procesora, aktualne jego zużycie). DZIAŁA TYLKO NA RASPBERRY PI 4 Aplikacja nadal jest w rozwoju więc jeszcze nie jest idealna lecz wyżej wymienione funkcje spełnia 🙂 https://github.com/Jack477/CommanderPi

Płytka prototypowa AVR Witam mam dla was do zaprezentowana płytkę prototypową z mikrokontrolerem AVR w obudowie DIP40. Zaprezentowany układ został wykonany dla osób zaczynających zabawę z mikrokontrolerami AVR. Płytka PCB ma wymiary 132mm x 69mm. Został wykonany w programie KiCad. Schemat umieszczony poniżej składa się z Płytki dwuwarstwowej Mikrokontrolera AVR DIP40 Wyświetlacza 7-segmentowego Wyświetlacza LCD HD44780 Dwóch mostków H w jednej obudowie 5 przycisków przycisków 1. Obok mikrokontrolera są umieszczone jego wyprowadzenia. Do obu wyświetlaczy wyprowadzenia umieściłem obok goldpinów Portu A dla LCD oraz Portu C dla 7-segmentowego (odpowiedzialnego za załączenie segmentów) Umożliwia to łatwe połączenie używając zworek. Każdy podłączony układ ma doprowadzone zasilanie. 2. Mikrokontroler AVR – Płytka przystosowana jest do mikrokontrolerów AVR w obudowie DIP40. Nie wyposażyłem układ w programator. Lecz zastosowałem złącze ISP 10-pinowe. Programator to koszt ok 20 pln. Podłączyłem do układu zewnętrzny rezonator kwarcowy w obudowie HC-49 przy montażu należy pamiętać o przylutowaniu adaptera. Daje to możliwość zamiany taktowania procka. 3. Wyświetlacz 7-segmentowy jest to element ze wspólną anodą Jest to układ który ma już wyprowadzone i połączone segmenty i anody poszczególnych cyfr. Do obsługi wyświetlacza wykorzystywane są piny wyprowadzone przy Porcie C (segmenty) oraz obok wyświetlacza (Anody). Segmenty posiadają również rezystory 220 Ω. Można również zastosować wyświetlacz ze wspólną katodą ale należy pamiętać o tym pisząc program. 4. Wyświetlacz LCD HD44780 nie występuje on w prezentowanym układzie ma on wyprowadzenia na PCB. Jest możliwa jedynie komunikacja 4-bitowa, która oszczędza na ilości potrzebnych połączeń między mikrokontrolerem a ekranem. Wykorzystać można wiele rozmiarów wyświetlaczy. Najczęstszym jest 1602 który posiada dwa wiersze oraz 16 kolumn. Czyli 32znaki. Jest też możliwość podłączenia ekranu 2004 i zależność kolumn i wierszy jest identyczna jak w opisywanym wcześniej ekranie. Pod ekranem jest miejsce na zworkę RW która odpowiada za komunikacje zwrotną z LCD do mikrokontrolera. Nie korzystając z tej opcji należy przełączyć pomiędzy RW a GND. Obok zworki RW jest miejsce na przylutowanie potencjometru do ustawienia kontrastu. 5. Mostek H jest to element do pełnej obsługi silników. Układ L293D jest w obudowie DIP 16. Układ ten pozwala sterować w pełni (prędkość, kierunek obrotów) dwoma silnikami DC. Można również podłączyć opisywany układ do silnika krokowego bipolarnego. Dzięki wyprowadzeniom można wykorzystać zewnętrzne napięcie przystosowane do danego silnika. W każdym z silników możemy decydować o prędkości obrotowej wykorzystując złącze PWM oraz kierunkiem przy użyciu wejść 1A, 2A lub 3A, 4A (np. 1A Vcc , 2A GND -> obroty w prawo) 6. Ostatnim opisywanymi elementami są przyciski. Są one podjęte a stałe do GND a drugie końce wyprowadzeń są podłączone do złączy goldpinowych. Projekty które można zrealizować na omawianym PCB Migotanie diodami LED (należy pamiętać o podłączeniu co najmniej jednego wyprowadzenia Anod do GND) Sterowaniem Wyświetlaczem LED 7 segmentowym (multipleksacja) Obsługa wyświetlacza LCD Sterowanie silnikami DC w wykorzystaniem PWM Sterowanie silnikiem krokowym bipolarnym obsługa klawiszy (sprawdzenie stanu na pinie) Obecny układ jest pierwszą wersją po której nastąpią poprawki. W kolejnych etapach rozwoju chciałbym dodać osobne diody LED podpięte na stałe do 5V lub GND wraz z rezystorami. Dołączyć dwa moduły jednym jest ekspander pinów pracujący na magistrali TWI (I2C) oraz moduł termometru cyfrowego DS18B20 połączonego za pomocą komunikacji 1-wire. Poprawić układ PCB (układ ścieżek, wymianę obudów na inne). Zachęcam do zadawania pytań, pisania sugestii oraz krytyki w celu dalszego rozwoju. W załączniku dołączam plik rar z wszystkimi plikami KiCad'a.Board 1.rar Pozdrawiam

Dzisiaj próbowałem nauczyć się sterować kilkoma funkcjami jednym przyciskiem za pomocą "switch case" i coś mi nie wyszło. Z założenia program po wciśnięciu przycisku miał zapalać diodę, gasić ją po 2 sekundach .Po kolejnym przyciśnięciu przycisku zapalać następną diodę , gasić po 2 sekundach i tak dalej... Zamiast tego diody same zapalają się i gasną po kolei . Z góry dziękuje za odpowiedzi. szkic programu: #define przycisk 6 #define led1 7 #define led2 8 #define led3 9 #define led4 10 byte x = 0; void setup (){ digitalWrite(led1,LOW); digitalWrite(led2,LOW); digitalWrite(led3,LOW); digitalWrite(led4,LOW); pinMode(led1,OUTPUT); pinMode(led2,OUTPUT); pinMode(led3,OUTPUT); pinMode(led4,OUTPUT); pinMode(przycisk,INPUT_PULLUP); } void loop(){ if(digitalRead(przycisk == LOW)){ switch(x){ case 0: digitalWrite(led1,HIGH); delay(2000); digitalWrite(led1,LOW); x=1; break; case 1: digitalWrite(led2,HIGH); delay(2000); digitalWrite(led2,LOW); x=2; break; case 2: digitalWrite(led3,HIGH); delay(2000); digitalWrite(led3,LOW); x=3; break; case 3: digitalWrite(led4,HIGH); delay(2000); digitalWrite(led4,LOW); x=0; break; } }else{ digitalWrite(led1,LOW); digitalWrite(led2,LOW); digitalWrite(led3,LOW); digitalWrite(led4,LOW); } }