Przerwa egzaminacyjna

Ogłaszam przerwę w spotkaniach Fi-BOTa na czas 30 styczeń – 14 luty 2017. Proszę poświęcić się przygotowaniom do sesji. Życzę powodzenia w zaliczeniach i widzimy się 20-go lutego (wtorek, jak zawsze 16:00).

KG

Sygnały analogowe

Konwerter analogowo cyfrowy (DAC)

Sygnały analogowe to takie sygnały elektroniczne, które możemy zapisywac nie tylko jako 0 lub 1 (tak/nie, prawda/fałsz – tylko dwie wartości), ale w wielu „odcieniach” – w końcu pomiędzy zerem a jedynką jest nieskończenie wiele liczb. Oczywiście w informatyce wszystko musi byc skończone, tak więc tych „odcieni” (poziomów pomiędzy zerem a jedynką) jest skończona liczba. Układ zamianiający sygnał elektroniczny na informację cyfrową nazywa się konwerter analogowo cyffrowy (DAC) i mówiąc o nim podajemy jego zakres – liczbę bitów. Dla 8-bitowego DACa mamy wartości sygnału analogowego z przedziału od 0..255 (256 poziomów = 2^8), natomiast w przypadku 10-bitów 0..1023 (1024 poziomy = 2^10).

Potencjometr

Wygląda dość topornie – ale jeśl macie w domu zbyteczną gałkę z kryształów Swarowskiego to proszę śmiało przynieść i uatrakcyjnimy wygląd tego podzespołu elektronicznego 😉 Trzeba pamiętać o sposobie podłączania go do budowanych układów. Widzimy trzy nóżki więc:

  • jedna skrajna nóżka (nie ma różnicy która) powinna być podłączona do masy (nazwijmy ją GND i oznacza napięcie zero V)
  • druga skrajna nóżka musi być podłączona do danego napięcia, nazwijmy je VCC
  • środkowa nóżka będzie „wyprowadzać” napięcie od zera do VCC w zależności od ustawienia pokrętła na potencjometrze. 

Na zajęciach dość szczegółowo omówiłem budowę potencjometru i zasadę jego działania – dzielnik napięć – ale do tego jeszcze obiecuję wrócić. Na razie skupmy się na powyższych informacjach jak potencjometr łączymy w układ. Jako przykład możemy podłączyć „minus” bateryjki AAA do pierwszej nóżki, „plus” do trzeciej „nóżki”, wówczas z pinu numer dwa otrzymamy napięcie od 0..1.5V. Innym przykładem podłączenia jest wykorzystanie Arduino i pinów GND (podłączamy do pinu 1 na potencjometrze) oraz 5V (do pinu 3 na potencjometrze) – wówczas mamy kontrolę potencjometrem nad napięciem 0..5V (pin 2 na potencjometrze). 

Pinem #2 z potencjometru możemy zasilać jakiś układ – sprawdzaliśmy to z LED-em wpiętemym pomiędzy piny #1 (GND) i #2(0..3.3V) potencjometru, lub mozemy podłączyć pin #2 do wejścia A0 w Arduino – wówczas odczytamy wartość napięcia ustawionego potencjometrem jako liczbę z przedziału 0..1023 (Arduino UNO ma DAC 10-bitowy).

Kalibracja

Konieczne jest sprawdzenie poziomu napięcia 5V w Arduino – może się zdarzyć, że nasza płytka jest uszkodzona lub producent nie trzymał standartów i zamiast 5V mamy 5.1V. To spora różnica. W przypadku uszkodzonych płytek – których wcale nie ma co wyrzucać – napięcie zamiast 5V może być nawet 4.5V co jest już ogormną różnicą! Dlatego konieczne jest sprawdzenie multimetrem wartości napięcia produkowanego przez Arduino z pinu 5V. 

Odczytywanie sygnału – analogRead

void setup(){
  Serial.begin(9600);
}
int odczyt;
void loop(){
  odczyt = analogRead(A0);
  Serial.print("Odczytalem ");
  Serial.print(odczyt);
  Serial.print(" ---> ");
  Serial.print(odczyt*4.9/1024);
  Serial.println(" [V] ");   
}

Ten prosty program odczytuje sygnał podłączony do pinu A0 w Arduino (możesz wybrac inne wyjścia: A1,A2…A5) i wypisuje jego wartość jako liczbę z przedziału 0..1023 (gdyż Arduino UNO ma przetwornik DAC 10-cio bitowy, czyli 2^10=1024) a także podaje wartość w woltach. Sprawdziłem, że w moim Arduino napięcie z pinu 5V wcale nie wynosiło 5V a 4.9V i dlatego linia #10 zawiera właśnie takie przeliczenie na wolty. Zwróć też uwagę na sposób komunikowania się z ekranem – budowanie napisu w jednej linii i dopiero na koniec użycie funkcji Serial.println().

Posługują się powyższym programem najpierw sprawdzamy odczytywane napięcie z pinu 3.3V Arduino, potem 5V Arduino –  porównując wartości wypisywane na ekranie z multimetrem. Potem możemy użyć jakiś baterii a w końcu wykorzystać potencjometr i jego środkowy pin.

PWM (cyfrowe piny z „tyldą” ~)

PWM to szybkozmienny sygnał cyfrowy (cyfrowy, a więc tylko dwie wartości: 0V oraz 5V). Szybkozmienny oznacza naprawdę szybkie zmiany, 500x na sekundę – czyli co 2ms! Musimy podać jaki ułamek czasu (z przedziału 2ms) będzie napięciem wysokim (5V) a wówczas pozostały czas będzie napięciem 0V. Ten ułamek czasu musimy wyrazić jako liczbę całkowitą z przedziału 0..255 (gdzie 255 to 100%) gdyż w Arduino UNO piny PWM są 8-bitowe (a 2^8=256). Wartość 0..255 nazywa się to wypełnieniem sygnału.

Sterowanie wypełnieniem – analogWrite

void setup(){
  pinMode(3, INPUT);//pin cyfrowy z tyldą = PWM 
}

void loop(){ 
  analogWrite(3, 0);
  delay(5000);
  analogWrite(3, 100);
  delay(5000);
  analogWrite(3, 200);
  delay(5000);
  analogWrite(3, 255);
  delay(5000);
}

Powyższy program wybiera pin #3 Arduino UNO (zwróć uwagę, że jest on onzaczony „tyldą” na płytce – czylli jest to pin PWM, ale można wybrac inne piny PWM) i steruje jego wypełnieniem. W tym celu używamy funkcji analogWrite(int,int) podając numer pinu którego ma dotyczyć zmiana (koniecznie pin z tyldą!) oraz wartość wypełnienia (koniecznie z przedziału 0..255). Co 5 sekund zmienia jego wartość, którą możemy odczytać na multimetrze – ale uwaga, będzie to tylko wartość średnia! Aby zobaczyć zmiany napięcia w okresach 2ms należało by użyć oscyloskopu. 

Praca domowa

Wykorzystując informacje z dzisiejszych zajęć uruchomić wirtualne Arduino i zbudować program z potencjometrem, który steruje jasnością LED-a. Musimy więc odczytywać wartości z potencjometru a następnie odpowiednio sterować zasilaniem LED-a. Powodzenia!

(c) KG, 2017

 

Przycisk (modeuł) + ekran

Dziś poznalismy trzy rzeczy: wypisywanie komunikatów przez Arduino na ekran PC-ta, funkcję „zegara” millis() oraz obsługę przycisku (a właściwie modułu z przyciskiem, niedługo poznamy różnice).

Komunickacja z PC-tem

Chodzi o komunikację szeregową UART z wykorzystaniem dwóch pinów cyfrowych Rx/Tx (piny numer zero i jeden). Uruchamiamy komunikację poleceniem Serial.begin(szybkość). W tym momencie tracimy dwa wspomniane piny(zero i jeden) – no cóż, coś za coś. Parametr szybkość musi być na obu urządzeniach taki sam, w przeciwnym przypadku urządzenia się „nie dogadają”. W środowisku Arduino IDE wybieramy Monitor szeregowy (lub w angielskiej wersji: Serial Monitor) i nasłuchujemy to, co nadaje do nas Arduino – to jest właśnie drugie urządzenie, do którego Arduino nadaje (prawy, górny róg okienka z kodem programu)

Jak wspomniałem należy sprawdzić, czy w okienku Monitora (portu) szeregowego parametry tramisji (szybkość) jest taka sama, jak w programie Arduino – prawy, dolny róg tego okienka.

W przyszłości opowiem więcej o tych parametrach transmisji oraz jak wysyłać dane do Arduino – ale to później.

Trzeba zapamiętać dwie funkcje wysyłające napisy z Arduino:

  • Serial.print(„napis”) — wysyłamy tekst napis do urządzenia nasłuchującego; tekst musi być w cudzymsłowiu (aka. psie uszy)
  • Serial.println(„napis”) — wysyłamy napis i znak przejścia do nowej linii – dzięki temu kolejny napis pojawi się w nowej linii.

Te dwie funkcje w zupełności wystarczają, aby Arduino coś do nas „mówiło” 😉

millis()

Bardzo przydatna funkcja zwracająca liczbę milisekund od czasu rucuhomienia programu (włączenia/zrestartowania Arduino). Do zapisywania danych zwracanych przez tą funkcję należy użyć typu unsigned long – wystarczy na około 50 dni. Więcej info tutaj.

Dzięki tej funkcji możemy mierzyć czas wykonania jakiejś czynności. Aby to zrobić, musimy zapisać „zegar” (aktualną wartość milisekund, która sama w sobie nie jest istotna) do jednej zmiennej, powiedzmy t1, wykonać czasochłonne czynności, a po nich ponownie zapytać o „zegar” – i zapisać do drugiej zmiennej, np. t2. Różnica t2 i t1 jest właśnie czasem wykonania konkretnej czynności.

Przycisk (moduł).

Dzięki temu, że to jest przycisk z modułem, to jego obsługa jest bardzo prosta – musimy podłączyć zasilanie do modułu (Vcc do Arduino 5V, GND do Arduino GND, a pin sygnałowy S – do dowolnego, wybranego przez nas pinu cyfrowego w Arduino – np. 7).

Następnie pamiętajmy o poleceniu pinMode(7, INPUT), które spowoduje, że będziemy mogli odczytywac stan przycisku za pomocą digitalRead(7). Jeśli przycisk jest wciśnięty, to funkcja ta zwróci wartość 1, w przeciwnym przypadku – wartość 0 (zero).

Koszt takiego modułu to około 3 zł, należy szukać hasła w stylu Moduł przycisku tack switch z LED ARDUINO (np. w serwisie Allegro).

Fale… z ledów… także wirtualnych…

Fala… z LED-ów…. prawdziwych! Oprócz fal pojawiła się TABLICA i pętla FOR. To sporo – kto nadążał – gratuluję!

Prezentacja Pana Macieja – proste, ale… całkiem efektowne! Gratuluję. Bez pętli zaprogramować coś takiego to koszmar.

Następnie zachęcałem do wirtualnego Arduino ze stronki tinkercad.com (jest to znany projekt cicuits.io, który przejęła firma Autodesk):

Stronka ta umożliwia zabawę w Arduino bez posiadania płytki Arduino – wystarczy się zarejestrować (za darmo!) i można działać.

Jak zacząć? Już po rejestracji wybieramy CIRCUITS:

a następnie zielony przycisk Create new circuits:

Kolejnym krokiem jest już dodawanie elementów po naciśnięciu +Components (prawy pasek, na górze)

gdzie zaczynamy od płytki stykówki, LED-a, rezystorka i bateryjki. Uruchamiamy symulację przyciskiem Start Simulation (potem ją zatrzymujemy Stop). Gdy już wszystko rozumiemy (tyle-o-ile) to czas na dodanie płytki Arduino i… tu się zaczyna zabawa!

Kto zrobi pracę domową z „odbijającą się” falą? Ze zmienną czas? Na następnych zajęciach wgramy programiki na prawdziwe płytki i zobaczymy kolorowe efekty! Proszę śmiało działać!

 

Pierwsze spotkanie 2017 r.

No i rozpoczęliśmy nowy rok akademicki 2017/2018 a tym samym i Fi-BOTa. Na pierwszych zajęciach pojawiło się 9 śmiałków – zobaczymy, ilu będzie kontynuować…

Co robiliśmy? Dla większości była to pierwsza przygoda z Arduino więc było sporo gadania, ale finalnie udało nam się błyskać jednym LED-em podłączonym na płytce stykowej. To dużo jak na godzinkę z hakiem i moją skłonność do gadania 😉 Ale pokazałem też motywację – ta sama płytka Arduino podłączona do żarówki 230V – i działa!

Spotkania w roku 2017/18 będą odbywać się zawsze we wtorki o godz. 16:00. Zapraszam!

Xiaomi… także inteligentne domy!

ForBot donosi o wcale a wcale ciekawym osprzęcie do budowania Inteligentnych Domów – znanej frirmy Xiaomi. Wrażenia po trzech tygoniach testów można przeczytać tutaj. Zapraszam do zapoznania.

https://forbot.pl/blog/inteligentny-budynek-za-250zl-recenzja-mi-smart-home-kit-id22244?utm_source=rssToMail&utm_medium=email&utm_campaign=sprawdz_nowe_artykuly_5_kurs_fpga_3_instalacja_srodowiska_ise_xilinx&utm_term=2017-09-24

Przerwa wakacyjna

Ponownie spotykamy się w październiku 2017 r.

Podsumowując rok akademicki 2016/17: przeprowadziliśmy 31 spotkań w ramach Fi-BOTa, w tym jedno festiwalowe (XV Podlaski Festiwal nauki i Sztuki). Dziękuję za wytrwałość i zapraszam w roku akademickim 2017/18 (termin będzie ustalony w październiku). Zachęcam do samodzielnej pracy z Arduino i… pochwaleniem się własnymi projektami w nowym semestrze!

K.G.

Zajęcia nr 5 – serwo silniki, map(), bluetooth

 Serwo silnik (a właściwie mikro-serwo)

serwo1Czyli silnik, który obraca się od 0 do 180 stopni (ma blokadę na inne wychylenia). Potem utrzymuje swoją pozycję. Służy do tworzenia obrotowych ramion itd…

Trzy przewody – zasilanie (czerowny +5V, czarny/brązowy GND) oraz jeden sterujący – musi być PWM. Za dużo nie wnikałem o co chodzi w sterowaniu tym silnikiem, tylko wspomniałem o potencjometrze wewnątrz i o wypełnieniu sygnału sterującego… więcej może później? Zobaczymy.

 

Do sterowania tym silnikiem użyliśmy 2 nowych funkcji z nowej biblioteki:

  • #include <Servo.h> – na początku programu informujemy, że chcemy funkcje z tej nowej biblioteki
  • Servo silniczek; tworzymy zmienną typu silnik-serwo, czyli właśnie o to nam chodzi!
  • silniczek.attach(3); powoduje przekazanie informacji do Arduino, że sterujemy silnikiem przez pin numer 3 (przypominam: musi być to pin PWM, czyli jak nie 3, to 5,9…)
  • silniczek.write(133); ustawia nasz silnik w pozycji 133 stopni. Albo na dowolny inny z zakresu 0..180 stopni. Dziecinie proste 😉

Serwo sterowane z klawiatury

Przypomnieliśmy sobie jak odczytywać liczby z klawiatury (funkcja parseInt() dla obiektu Serial) i stworzyliśmy program ustawiający silnik w pozycji wczytanej z klawiatury. Proste a przyjemne. No i zawsze warto powtarzać wiedzę 😉

Serwo sterowane potencjometrem

Połączenie poprzednich zajęć – potencjometr liniowy (dzielnik napięć!) wykorzystany do ustawiania pozycji serwa – ruszam „gałką” w lewo, orczyk w serwie obraca się w lewo. Tak samo w prawo. Fajne!

Serwo sterowane potencjometrem – program PRO

Dbamy o szczegóły – i nie chcemy ustawiać położenia serwa wówczas, gdy potencjometr nie zminił swojej pozycji. Bez złośliwości – my staramy się programować na serio

Prąd „zjadany” przez serwo – mierzymy!

W skrajnych ustawieniach serwa (tj. w okolicy 0 stopni, oraz w okolicach 180 stopni) słyszymy buczenie/piszczenie serwo-silnika. Coś się dzieje. Amperomierz w garść i mierzymy prąd.

serwo1

Przyjrzyj się uważnie obrazkowi i zwróć uwagę, jak podłączony jest amperomierz.

Oczywiście w wirtualnym Arduino (ciągle polecam circuits.io) silniczek serwo jest idealny i nie widzimy tego, co było u nas na zajęciach….

Dodatkowo: w przypadku mierników uniwersalnych ustaw największą wartość prądu, jaką się spodziewasz dostać – nie odwrotnie! W przeciwnym przypadku zwiększając zakres przepalisz bezpiecznik w multimetrze…

Funkcja map()

Czyli skalowanie wartości z jednego zakresu na drugi zakres. Przykład, z którym my się bawiliśmy: serwo silniczek sterowany potencjometrem. Odczytujemy nastawy potencjometru z portu analogowego Arduino jako liczbę (nazwijmy ją x) z zakresu 0..1023, a następnie ustawiamy serwo w położeniu z zakresu 0..180 stopni (nazwijmy te stopnie y). Czyli musimy dokonać zamiany wczytaj liczby x na y. Na zajęciach pokazałem skalowanie funkcją liniową, rozwiązaliśmy ten układ równań, ale Arduino jest także dla tych co tego nie umieją zrobić i przygotowało funkcję map(). W naszym przypadku będzie to:

y=map(x, 0, 1023, 0, 180);

Należy pamiętać, że funkcja map() działa tylko na liczbach całkowitych (int).

Serwo sterowane przez Androida – bluetooth XM-15B

Dlaczego ten? Bo działa w zakresie 3-6V, czyli można go bezpiecznie podłączyć do Arduino. Inne modele – popularne HC-05, HC-06 komunikują się przez 3.3V i wymagają „zbijania” napięcia (np. dzielnikiem napięć). To proste, ale… po co się w to bawić, jak można kupić właśnie moduł pozbawiony tej uciążliwości? Praujemy więc z XM-15B.

 

Pamiętajmy o łączeniu „na krzyż” portów RxD,TxD modułu XM-15B z portami RxD,TxD płytki Arduino (także tymi wirtualnymi).

Komunikacja z 8LAMP

Ze sklepu Play bierzemy prostą apkę i sprawdzamy, co ona wysyła do naszego bluetootha. Kod:

#include <SoftwareSerial.h>

#define RxD 8
#define TxD 9
SoftwareSerial btSerial(RxD,TxD);

void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  Serial.println("start!");
}

void loop() {
  if (btSerial.available()){
    Serial.print("Odebrałem znak= ");
    Serial.println(btSerial.read());
  }  
}

Następnie tak modyfikujemy ten program, by wczytany znak sterował naszym serwem – guzik '1′ ustawiał serwo na 90 stopni, guzik '2′ na 10 stopni i guzik '3′ na 170 stopni. Inne modyfikacje mile widziane 😉

Ważne

Na następne zajęcia proszę o zainstalowanie ze sklepu Play aplikacji Arduino Bluetooth Controler bo będziemy sterować pojazdem.

RaspberryPi ZeroW – test Mathematicy

Wraz z czerwcowym numerem The MagPi Magazine prenumeratorzy wersji papierowej otrzymali komputer RaspberryPi Zero W, plus obudowa (z trzema pokrywkami) oraz niezbędne przejściówki (USB, HDMI). Jest to najmniejszy komputer z rodziny Malinek – cechuje go bardzo kompaktowy rozmiar. Wydział Fizyki jako prenumerator tego magazynu otrzymał swój egzemplarz, a ja przyjrzałem się wydajności tej maszynki w znanym programie Wolfram Mathematica – bezpłatnego (pod sporymi restrykcjami) na Malinki.

Parametry

Wymaga wymienić podstawową konfigurację świadczącą o szybkości, więc:

  • 1GHz, jednordzeniowy CPU,
  • 512MB RAM.

Jeśli chodzi o dodatkowe rzeczy, to:

  • Mini HDMI and USB On-The-Go ports
  • Micro USB power
  • HAT-compatible 40-pin header
  • Composite video and reset headers
  • CSI camera connector
  • 802.11 b/g/n wireless LAN
  • Bluetooth 4.1
  • Bluetooth Low Energy (BLE).

Z rozmiaru pamięci widać, że szału nie będzie. Ale skoro jest to maszynka edukacyjna, z oprogramowaniem Mathematicy (w wersji na Rasbiana) to dlaczego by nie sprawdzić? Dla podkreślenia, wersja druga Maliny wyposażona jest w czterordzeniowy procek taktowany 900MHz, no i RAMu ma dwa razy więcej – 1GB. Sprawdzałem wielokrotnie, że da się pracować na Mathematicy  w zadawalający sposób. A tutaj jak będzie?

Powyżej zdjęcie porównujące „gabaryty” nowej Malinki (po prawej stronie) do wersji Pi2B (lewa strina). Widać wyraźnie, że trzeba być przygotowany na jakiś hub z portami USB, bo inaczej nie podłączymy klawiatury+myszki – jest tylko jeden port USB (drugi, widoczny na zdjęciu – to port zasilania). Więc trzeba mieć klawiaturę zintegrowaną z myszką, albo hub-a. Przy okazji – piny GPIO nie są przylutowane, należy samodzielnie to zrobić.

Upgrade systemu na Pi 2 Model B i przełożenie karty z systemem i… ZeroW wystartował bez problemów (mówie o Rasbianie). Później w domu sprawdziłem, że taki upgrade i sieć wi-fi uruchomił bezproblemowo.

Uruchomienie – ciężki start

A nawet gorzej – nie da się pracować na Mathematicy. Samo uruchomienie to czekanie ponad 2 minuty – a system stracił responsywność.  Zaglądam na zużycie pamięci i widzę, że środowisko X-ów z uruchomoioną Mathematicą pożarło 450 MB RAMu. Jesteśmy na granicy… Co się dzieje dalej?

Praca z Mathematicą – szału nie ma

Nie ma się co oszukiwać – 512MB to zdecydowanie za mało na działanie Mathematicy. Poniżej przedstawiam wyniki kilku testów szybkościowych – generowanie fraktala Mandelbrota (prosta metoda, różne siatki jak też i dwa kryteria zbieżności, różniące się dwukrotnie progiem liczby iteracji – na końcu znajdują się dokładne procedury testujące). Porównuję czasy do Pi2 Model B – uruchomionego z tej samej karty (i do biurkowego Intela i7-4790K CPU @ 4.00GHz, 32GB RAM pod kontrolą Ubuntu 16.04).

  mandel-1 export mandel-2 mandel-3 kolor
Intel i7 0.84 s 1.2 s 0.9 s 1.4 s 0.2 s
RPi2 28.5 s 24.5 s 12 s 49 s 7.5 s
*RPi3 15.6 s 13.0 s ? 27 s 4.6 s
ZeroW 96 s 86 s 40 s 164 s 600 s

Wyniki w tabelce to wynik poleceń Timing[] Mathematicy i nie oddają dokładnie tego, co się dzieje z systemem. A dzieje się dużo – jak już wspomniałem, na RPi Zero występuje utrata responsywności, czyli możliwości pracy (system zachowuje się jakby się „zawiesił” – okna się nie odświeżają, polecenia się nie wykonują, menu się nie rozwijają). To oznacza całkowitą klęskę w obsłudze programu Mathematicy – co było do przewidzenia ze względu na wielkość pamięci RAM tego modelu. Zresztą – w domu mam RPi w pierwszej wersji, także z 512MB ramu i tam jedyne co można – to uruchomić Mathematicę, nic konkretnego nie da się zrobić (OK – poza wykresem prostej funkcji).

Z kolei wersja druga Maliny działa już jak najbardziej przyzwoicie – nawet, gdy program zajęty jest obliczeniami, ciągle możemy działać (wiadomo – więcej pamięci i cztery rdzenie CPU, podczas gdy moje testy angażują tylko jeden rdzeń).

Podsumowując

RPi Zero W – bardzo fajne urządzenie, ale nie do Mathematicy. Zdecydowanie odradzam wydatek około 50 zł na tą maszynkę w celu wykorzystania jej do rozwiązywania zadań domowych z pomocą programu Wolframa. Inne zastosowania (elektronika, IoT) – jak najbardziej TAK, zarówno mocy obliczeniowej jak i RAMu jest wystarczająco. Tym bardziej, że płytka ma już zintegrowaną kartę Wi-Fi (oraz Bluetooth, choć tego jeszcze nie sprawdziłem). 

Wyjaśnienie

Artykuł powstał z powodu rozmowy ze studentami, których uczę Mathematicy a którzy mnie dopytywali o nowy, tani model RPi Zero.

Testy

Funkcja dla Mandelbrota

mandelbrot[p_, max_] := 
 Module[{zn = p, i = 0}, 
  While[(i < max) && (Abs[zn] < 2), zn = zn^2 + p; i++]; Abs[zn] < 2]

mandelbrot[0, 100]

True

mandelbrot[I, 100]

True

mandelbrot[I + 0.1, 100]

False

Timing[mandelbrot[I + 0.1, 10000]]

{0., False}

Test 1

Timing[
 minx = -2;
 maxx = 2;
 dx = (maxx - minx)/200.;
 miny = -2;
 maxy = 2;
 dy = (maxy - miny)/200.;
 r = Show[
   Graphics[{
     Black,
     Table[
      If[mandelbrot[x + I*y, 100], 
       Rectangle[{x - dx/2, y - dy/2}, {x + dx/2, y + dy/2}]], {x, 
       minx, maxx, dx}, {y, miny, maxy, dy}]
     }
    ],
   Frame -> True,
   PlotRange -> {{minx, maxx}, {miny, maxy}}]
 ]

Test 2

Timing[
 Export["mandel.jpg", r, ImageResolution -> 300]
 ]

Test 3

Timing[
 minx = -1.45;
 maxx = -1.2;
 dx = (maxx - minx)/100.;
 miny = -0.1;
 maxy = 0.1;
 dy = (maxy - miny)/100.;
 Show[
 Graphics[{
 Black,
 Table[
 If[mandelbrot[x + I*y, 200], 
 Rectangle[{x - dx/2, y - dy/2}, {x + dx/2, y + dy/2}]], {x, 
 minx, maxx, dx}, {y, miny, maxy, dy}]
 }
 ],
 Frame -> True,
 PlotRange -> {{minx, maxx}, {miny, maxy}}]
 ]

Test 4- kolorowy

kolormandelbrot2 = Compile[{{p, _Complex}, {max, _Integer}},
  Module[{zn = p, i = 0}, 
   While[(i < max) && (Abs[zn] < 2), zn = zn^2 + p; i++]; i]
  ]


minx = -1.42;
maxx = -1.415;
dx = (maxx - minx)/200.;
miny = -0.01;
maxy = 0.01;
dy = (maxy - miny)/200.;
Timing[
 Show[
  Graphics[{
    Table[{
      Hue[-0.7*kolormandelbrot2[x + I*y, 200]/200. + 0.7],
      Rectangle[{x - dx/2, y - dy/2}, {x + dx/2, y + dy/2}]}
     , {x, minx, maxx, dx}, {y, miny, maxy, dy}]
    }
   ],
  Frame -> True,
  PlotRange -> {{minx, maxx}, {miny, maxy}}]
 ]