Logging to Raspberry without password

Once upon a time I was spending a lot of time working with Linux servers. It's a distant past, but I still can recall some tips. One of them, quite useful when it comes to playing with RPi, is logging without password. I don't mean to give up passwords and allow anyone to enter my realms, but rather to automate the whole process from trusted machine.

How to achieve that?

On your workstations you need to generate authentication keys:

myuser@myhost:~$ ssh-keygen 
Generating public/private rsa key pair.
Enter file in which to save the key (/home/myuser/.ssh/id_rsa): 
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/myuser/.ssh/id_rsa.
Your public key has been saved in /home/myuser/.ssh/id_rsa.pub.
The key fingerprint is:
2d:2c:d5:d1:cc:cc:1a:aa:a3:11:28:da:1b:1a:2a:3a

When you have them, the next step is copying your public key to RPi:

myuser@myhost:~$ ssh-copy-id -i ~/.ssh/id_rsa.pub myuser@raspberrypi
myuser@raspberrypi's password: 
Now try logging into the machine, with "ssh 'myuser@raspberrypi'", and check in:

  ~/.ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

And that's all.
From now on you will be automatically logged to your precious board.

Malinowo :)

W tym roku Mikołaj był przesłodki. Jak malina. Więc zaczyna się zabawa z nową płytką, czyli Raspberry Pi. Oby tylko czasu starczyło...

Pracę z Raspberry Pi wypada rozpocząć od przygotowania karty SD. Minimalny rozmiar karty do 2GB, ja użyję 8GB klasy 10.

Po włożeniu karty do czytnika, sprawdzamy urządzenie skojarzone z kartą:

df -h

Zakładajac, że jest to sdb, należy odmontować kartę:

sudo umount /dev/sdb1

a następnie za pomocą dd skopiować obraz na kartę

sudo dd bs=1M if=./2012-12-16-wheezy-raspbian.img of=/dev/sdb

Pomimo wielu zalet, dd ma zasadniczą wadę - nie informuje o postępie kopiowania. Jednakże można zmusić dd do współpracy. Najpierw trzeba poznać PID procesu. W tym celu otwieramy drugą konsolę:

ps aux | grep dd.*wheez

a następnie wysłać sygnał do procesu:

sudo kill -USR1 <PID>

W pierwszej konsoli dd łaskawie ujawni swoje tajemnice:

Kiedy karta jest gotowa, można za pomocą Gparted rozszerzyć partycję, tak by zajmowała całą kartę, jednakże nie jest to konieczne. Przy pierwszym starcie uruchomi się raspi-config, który umożliwia wstępną konfigurację malinki:

Z przydatnych ustawień:

• expand_rootfs
• change_pass
• change_locale
• change_timezone
• ssh
• boot_behaviour

Jeśli czegoś nie ustawimy, można konfigurator uruchomić ponownie:

sudo raspi-config

Po zakończeniu konfiguracji można się zalogować do systemu.

Pierwszym krokiem po uruchomieniu, jest nadanie stałego IP.
W pliku /etc/network/interfaces należy wpisać (wybierając odpowiednie IP :) )

auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 192.168.1.10
gateway 192.168.1.1
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255

# w moim przypadku nie używam sieci bezprzewodowej
#allow-hotplug wlan0
#iface wlan0 inet manual
#wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
#iface default inet dhcp

Jeśli nie chcemy używać domyślnego użytkownika (pi), można dodać własnego:

sudo adduser myuser

A następnie nadać mu nieco większe uprawnienia:

sudo visudo

wpisując

myuser ALL=(ALL) NOPASSWD: ALL

Możemy jeszcze dodać naszego użytkownika do tych samych grup, do których należy pi. W tym celu (bedąc zalogowanym jako pi) wykonujemy polecenie:

sudo usermod -a -G adm,dialout,cdrom,sudo,audio,video,plugdev,games,users,netdev,input myuser

albo mniej zrozumiałe polecenie:

sudo usermod -a -G `groups | sed -e 's/pi //g;s/ /,/g'` myuser

Po przelogowaniu się na naszego nowego użytkownika możemy sprawdzić czy się udało:

groups

Szeregowo i kolorowo...

Dużo czasu minęło od ostatniego posta... Spręża brak, więc na dobry początek coś łatwego, szybkiego i... mało potrzebnego.

Potrzebowałem zobaczyć, jak skomplikowane jest komunikowanie się aplikacji uruchomionej na komputerze z Arduino. Oczywiście wybór padł na  złącze szeregowe :/

Pytanie, czym sterować, żeby się nie narobić... Albo serwo, a może jakaś dioda? A może dioda RGB? Akurat miałem pod ręką małe trójkolowe coś w wersji smd, więc...

Najpierw mała aplikacja w Processingu, ot trzy suwaki...

Każdy z "suwaków" aktualizuje poszczególne składowe, które następnie są łączone w jeden łańcuch i wysyłane przez port szeregowy do Arduino:

float mr = map(r, 0, 255, 0, 255);
float mg = map(g, 0, 255, 0, 255);
float mb = map(b, 0, 255, 0, 255);

String rgbString = str((int)mr) + " " + str((int)mg) + " " + str((int)mb) + "\n";
print("rgbString:"); println(rgbString);
port.write(rgbString);

Arduino zaś odbiera łańcuch i parsuje poszczególne składowe:

if (Serial.available() > 0) {
    redValue   = Serial.parseInt();
    greenValue = Serial.parseInt();
    blueValue  = Serial.parseInt();
        
    if (Serial.read() == '\n') {
        redValue   = constrain(redValue, 0, 255);
        greenValue = constrain(greenValue, 0, 255);
        blueValue  = constrain(blueValue, 0, 255);

        analogWrite(redPin,  redValue);
        analogWrite(greenPin,greenValue);
        analogWrite(bluePin, blueValue);
    }
}

Próby wysyłania poszczególnych składowych osobno, jako sekwencja bajtów, się nie sprawdziła, więc póki co pozostaje tworzenie łańcucha znaków...

A działa to mniej więcej tak:

Kody źródłowe:

• processing
• arduino

Tribute to Johny Five

Wszyscy znają robota o imieniu Wall-e, ale czy ktoś jeszcze pamięta Jasia Piątkę, czyli Johny'ego Five?
Od razu uprzedzę - nie będę budować repliki w/w robotów, przynajmniej nie w najbliższym czasie ;)
Przywołuję jednak bohatera filmu "Krótkie spięcie" z 1986 r. ze względu na prosty "bajer" - linijkę diodową, która miała wizualizować aparat mowy, takie sztuczne usta. Na tyle charakterystyczny efekt, a do tego prosty, że mój pierwszy robot, jak już powstanie, będzie go mieć :)

Do budowy tego efektu wydaje mi się, że najprościej jest zastosować miernik wysterowania. W sprzedaży jest wiele układów realizujących tę funkcjonalność, ja wybrałem AN6884 ze względu na minimalną ilość elementów dodatkowych, jak i małą liczbę diód - tylko 5.

Schemat pochodzi ze specyfikacji technicznej układu:

Diody na schemacie w rzeczywistości to 10-cio segmentowy słupkowy wyświetlacz LED. Diody są połączone równolegle, tak by wyświetlana linijka była symetryczna. Napięcie zasilania może się wahać od 3.5V do 16V, więc 5V dostarczane przez Arduino w zupełności wystarczy.

A efekt?

Pokrótce wyjaśnię działanie tej plątaniny: Arduino za pomocą czujnika ultradźwiękowego HC-SR04 odczytuje odległość przedmiotu przed czujnikiem, a następnie werbalizuje tę odległość odtwarzając odpowiednie pliki WAV za pomocą WaveShielda, z którego wyjścia jest również brany sygnał do AN6884. Pliki wygenerowałem programem GeSpeaker. 

WaveShield na płytce prototypowej

"Shielda" do odtwarzania plików wav na Arduino można kupić. W tym celu musimy przeznaczyć ok 75 złotych, zakładając że układ dostaniemy. Możemy też zbudować sami, niespecjalnie się wysilając, a co ważniejsze płacąc nieco mniej, że o zabawie nie wspomnę :)

Wszystkie potrzebne elementy, instrukcję itd znajdziemy na stronie układu., więc nie będę szczegółowo wymieniał, co jest konieczne , może tylko najważniejsze elementy:

• złącze do kart SD (~5 PLN)
• układ 74HC125 (~1 PLN)
• 12 bitowy przetwornik DAC - MCP4921 (~10 PLN)
• wzmaczniacz  TS922IN (~5 PLN)

Jak widać całość wyniesie nieco ponad 20 złotych. Chyba zatem warto się pokusić o chociażby wypróbowanie shielda, montując go na płytce prototypowej. 

Prawdę mówiąc część modułu można wykonać sobie wcześniej, wystarczy spojrzeć na poprzedni post, a czytnik kart SD może sobie leżeć na podorędziu i być pomocnym w różnych przypadkach, także wtedy, gdy chcemy zachęcić Arduino do muzykowania, mówienia itp.

Schemat układu bez czytnika kart SD (w oparciu o oryginalny projekt):

Przetwornik MCP łączymy z Arduino następująco:

• CS do pinu D2 (Digital 2)
• SCK do pinu D3
• SDI do pinu D4
• LDAC do pinu D5

Karta SD jest podłączana do Arduino prawie tak samo, jak w poprzednim poście. Wyjątek stanowi pin CS karty, który uprzednio był podłączony do pinu D4, teraz zaś musi być podłączony do pinu D10.

Po zmontowaniu cały układ wygląda następująco:

A to takie "Hello World" - kod programu wziąłem z przykładu dołączonego do biblioteki WaveHC (PiSpeakHC), zmieniając jedynie nazwę pliku do odtworzenia (pozbywszy się uprzednio logiki związanej z deklamacją liczby PI):

Karta SD (a miał być Robot)

Roboty lubią zarówno mali chłopcy, ci więksi jak i ci naprawdę duzi. Przynajmniej większość "chłopców", których znam. Z reguły lubią się bawić robotami, ale są też tacy, których bawi/bawiłoby stworzenie takiego "cudeńka". Mógłbym napisać, że jestem w tej drugiej grupie, ale... Poza "Wallym" nie zrobiłem jeszcze całego robota. Przy okazji, to jest Wally:

Nie dość, że miał dość ograniczone funkcje, to do tego byłem jedynie pomocnikiem.
Byłoby sympatycznie samemu coś "wydziergać". Póki co niestety kończy się na "byłoby sympatycznie". Ale... Pojawiło się światełko w tunelu, choć wcale roboty nie były mi wtedy w głowie. Szukałem sposobów odtwarzania dźwięku przez Arduino. Spośród znalezionych rozwiązań spodobały mi się dwa:

• SpeakJet
• WaveShield dla Arduino

Niestety, póki co nie udało mi się dostać układu SpeakJet, więc pozostaje WaveShield. Nie żeby był gorszy, po prostu części są dostępne, co więcej - nie ma potrzeby sięgania po SMD!

W zasadzie nie ma problemów ze zmontowaniem układu do momentu zabrania się za czytnik kart SD. Można kupić, można spróbować samemu zrobić. Co wybrać...

Cóż, wybrałem ciemną stronę mocy i powstało to:

Płytka była projektowana późnym wieczorem i drapana, do tego jeszcze miała błędy, a że do tego specjalnie estetyczna nie jest, więc daruję sobie wrzucanie projektu. Powiedzmy że gotowy układ realizuje poniższy schemat,

który wziąłem ze strony shielda, a układ wyjść wygląda tak:

Ironicznie, ciesząc się że nie ma konieczności sięgania po SMD, znalazłem w swoich zasobach tylko jeden układ 74HC125, właśnie w takiej postaci :/.

Moduł czytnika kart SD podłączamy następująco:

• MOSI do pinu 11
• MISO do pinu 12
• CLK do pinu 13
• MMC_CS do pinu 4

Powyższy układ działa na Arduino 2009, Nano itp.

Po podłączeniu układ wygląda następująco:

Z biblioteki SD wybieramy przykład "CardInfo", wgrywamy i po uruchomieniu możemy dostać coś podobnego:

I zasadniczo tyle. Post zaczynał się szumnie aluzją do robienia robotów, miał pierwotny tytuł "Robot cz. 1" i... ani się obejrzałem już północ. O robotach coś na pewno będzie :)
Niestety, gdybym chciał wrzucić wszystko co planowałem w jeden post, sam bym się potem pogubił, więc nieco lepiej będzie podzielić całość na małe części.  A oto co nas jeszcze czeka:

• "aparat głosowy", czyli WaveShield
• usta robota, czyli co można zrobić z AN6884
• oczy robota, czyli moduł HC-SR04.

Zatem... CDN

BMA180 i Arduino cz. 1

Jakiś czas temu zakupiłem moduł z akcelerometrem BMA180. Jednakże od początku były jakieś "ale". Pierwsza sprawa to cyfrowy interfejs - nie wystarczy mierzyć napięć, trzeba być dość rozmownym, by wydostać dane z układu. Drugim problemem był brak biblioteki dedykowanej na Arduino. Co prawda w sieci znalazłem nieoficjalne wsparcie, ale... Dlaczegóż by nie napisać czegoś samemu? No i trzeci problem - niezgodniość poziomów logicznych. Układ BMA180 pracuje w logice 3.3V,  natomiast Arduino w 5V.

Jak mawiają ludy anglojęzyczne "first things first" - jeśli chcemy używać układu trzeba mieć konwerter. Można go zakupić, zresztą wiele nie kosztuje, ale dostawa chwilę trwa. Można zbudować, schemat jest dostępny na stronie producenta, ale... Trzeba mieć odpowiednie tranzystory. Jak się okazało tranzystorów BSS138 nie mogłem dostać w znanych mi wrocławskich sklepach, więc trzeba było improwizować. Z tego typu tranzystorów łatwo dostać BS170, więc...

Schemat ideowy części konwertera:

A moduł wygląda tak:

Przed rozpoczęciem pracy z modułem trzeba się zdecydować, przez jaki interfejs będziemy się komunikować z układem. Mamy do dyspozycji SPI (4 przewody) i I²C (2 przewody). Osobiście wolę I²C, więc dalsze rozważania będą brać po uwagę tylko ten interfejs.

Jeśli chcemy włączyć komunikację po I²C, wystarczy na pinie CS ustawić stan wysoki (jak się można domyślić, stan niski przełącza komunikację na SPI).

Kompletny schemat układu poniżej:

Po podłączeniu otrzymujemy coś takiego:

Najmniej skomplikowanym sposobem weryfikacji połączenia jest odpytanie układu o jego ID:

#include 
#include 


#define BMA180_ADDR 0x40
#define CHIP_ID     0x00

byte val;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  val = readI2C((uint8_t)CHIP_ID);
  Serial.print("CHIP_ID=");
  Serial.println(val);
}

void loop() {
}

byte readI2C(uint8_t offset) {
  byte val;
  Wire.beginTransmission(BMA180_ADDR);
  Wire.write((uint8_t)offset);
  Wire.endTransmission();

  Wire.requestFrom(BMA180_ADDR, 1);
  while (Wire.available()) {
    val = Wire.read();  
  }
  return val;
}

Jeśli w terminalu otrzymam wartość CHIP_ID=3,

 możemy zaczynać bardziej skomplikowane zabawy z akcelerometrem. 

Arduino Nano po polsku

W ostatnim poście pisałem o tanim Arduino na mikrokontrolerze Atmega8. Moduł jest tani, bo koszt całości zamyka się w 20 zł, ale nieco bardziej uciążliwy w użyciu, jeśli chcemy szybko prototypować. Na szczęście AVT wypuściło inny kit - AVT 1622 - Minimoduł z Atmega8
Układ ten, w odróżnieniu od poprzedniego, posiada wbudowany konwerter UART<->USB, zatem może być używany prawie jak oryginalne Arduino Nano.

Decydując się na zakup kitu, wybieram samą płytkę. Choćby dlatego, że finalnie będzie to minimoduł z Atmegą 328.

Lista potrzebnych elementów:

• płytka drukowana modułu
• Atmega328
• FT232RL
• 78M05 (TO252)
• 3x 470om 0805
• 10k 0805
• 2x 1k 0806
• 2x 10mikroF . 16V
• 4x 100nF 0805
• 2x 22pF 0805
• niski kwarc 16 MHz
• diody led smd 0805 - zielona, czerwona, żółta
• gniazdo mini usb
• goldpiny

Instrukcja kitu zaleca rozpoczęcie montażu od mikrokontrolera, kondensatorów i diod LED na jednej stronie. W kolejnym kroku FT232, stabilizator, rezystory i kontensatory po drugiej stronie, a na końcu gniazdo USB i goldpiny.
Lutowanie elementów smd jest relatywnie proste, nawet dla takiego początkującego jak ja, jeśli się ma pod ręką plecionkę lutowniczą:

Po zlutowaniu moduł wygląda tak:

Jeszcze można zauważyć mnóstwo kalafonii po "odsączaniu" nadmiaru cyny. Ważne, że sposób działa...

Po zakończeniu lutowania można moduł podłączyć do komputera - powinna świecić się zielona dioda (PWR), a diody RX i TX pobłyskiwać od czasu do czasu. Dodatkowo, w IDE powinien pojawić się nowy port. Jeśli nic takiego się nie dzieje, trzeba sprawdzić, czy np drobinki lutu nie zwierają pinów złącza USB czy też układów sclaonych. Nim wgramy bootloader sprawdźmy FUSE bity:

avrdude -p m328p -c stk500v2 -P /dev/ttyACM0 -U lfuse:r:-:h -U lfuse:r:-:b -U hfuse:r:-:h -U hfuse:r:-:b 

i otrzymujemy:

avrdude: Device signature = 0x1e950f 
reading lfuse memory: 0x62 
reading hfuse memory: 0xd9 

Teraz możemy wgrać bootloader. Podłączamy moduł do programatora i za pomącą IDE ładujemy oprogramowanie. Możemy sprawdzić FUSE bity ponownie. To co powinniśmy otrzymać to 0xff (lfuse) i 0xda (hfuse).

Mogłoby się wydawać, że to już koniec. Niestety nie. Próba załadowania programu z IDE z reguły skończy się komunikatem:

Binary sketch size: 1,084 bytes (of a 30,720 byte maximum) avrdude: stk500_recv(): programmer is not responding 

  Nasze nowe Arduino będzie trudno programować przez USB, gdyż moduł dostarczany przez AVT nie posiada możliwości autoresetu, co więcej przycisku RESET też na płytce nie ma. O ile drugi problem można usunąć przez podłączenie zewnętrznego przycisku do resetowania układu, o tyle ja osobiście wolę nic nie naciskać. Prostym rozwiązaniem jest dodanie połączenia pinu DTR# układu FT232RL poprzez kondensator 100nF z pinem RESET mikrokontrolera. Do tego celu najlepiej użyć bardzo cienkiego przewodu, choć jak nie ma nic pod ręką, można użyć przewodu ze skrętki:

Moje lutowanie wygląda tak:

Może nie najwyższych lotów, ale nie ma zwarć, a wgrywanie programów nie stanowi już żadnego problemu.

Mapa pinów modułu:

Niedrogie Arduino na Atmega8

Od pewnego czasu "bawię" się Arduino. Prosty sposób, by osoba nie mająca doświadczenie z mikrokontrolerami mogła się nimi zająć, bez żmudnego wgryzania się w detale.
Jednakże kiedy przychodzi moment, że trzeba przejść od prototypu to finalnego produktu, robi się problem. Najlepiej by było zaprojektować płytkę dedykowaną pod konkretne rozwiązanie. Ale kto ma czas? A co jeśli za jakiś czas zrezygnuję z budowanego urządzenia? Itd, itp...
Można użyć Arduino... Ale raz że duże, dwa - ciut drogie. Na szczęście niedrogie rozwiązanie istnieje; jest to wypuszczony przez AVT kit AVT2892/2 - minimoduł z mikrokontrolerem Atmega8.
Można zamówić cały kit, ale ja zamawiam tylko płytkę - z reguły atmegę mam, a poza kwarcem nic innego nie potrzebuję (ale o tym za chwilę).

Składanie modułu nie jest specjalnie trudne, nawet osoba nie mająca doświadczenia w lutowaniu SMD powinna sobie poradzić.

Moja lista elementów:

• płytka
• Atmega8A
• kwarc 16MHz
• 2x 22pF 0806
• goldpiny

Nie lutuje z reguły układu stabilizatora, bo zasilanie to najczęściej osobna sprawa.

Po zlutowanie otrzymujemy zgrabny moduł, którego konfiguracja pinów wygląda następująco:

Kolejnym krokiem jest przygotowanie programatora - jakby nie patrzeć będzie potrzebny, gdyż albo będę używać modułu USB<->RS232, a to wymaga bootloader, albo wgrywać programy bezpośrednio, co wymaga programatora.
Osobiście używam AVRPROG v2 (firmy AndTech). Z początku nie chciało działać, ale po chwili odgadłem powód - niepoprawna konfiguracja w pliku programmers.txt :


avrisp.name=AVR ISP
avrisp.communication=serial
#oryginalna wartość: stk500v1
avrisp.protocol=stk500v2


Teraz tylko upload bootloadera, co warto wykonać, bez względu na to, jak będziemy w przyszłości wgrywać programy. Po prostu zostaną ustawione FUSE bity :)

A zweryfikowć FB można następująco:


avrdude -p atmega8 -c stk500v2 -P /dev/ttyACM0 -U lfuse:r:-:h -U lfuse:r:-:b -U hfuse:r:-:h -U hfuse:r:-:b


Powinniśmy otrzymać: 

Zmiana hasła w AD w konsoli linuksowej

Hasło użytkownika w AD z konsoli linuksowej można zmienić następująco:

smbpasswd -r kontroler_domeny -U username 

Arduino na Linuxie

Instalacja Arduino IDE na linuxie do skomplikowanych nie należy...

• Pobrać paczkę z arduino.cc
• Rozpakować w wybranej lokalizacji (ja preferuje /opt/apps/)
• Pobrać i zainstalować gcc-avr i avr-libc
  sudo apt-get install gcc-avr avr-libc
• I niby wszystko powinno działać. Jednakże może się okazać, że nie można wybrać z IDE portu USB.
  Wtedy należy dodać swojego użytkownika do grupy dialout:
  

  sudo usermod -aG dialout username 

Voila!

A przynajmniej tak było do wersji 1.0. Kolejna wersja ma coś sknoconego, podczas próby uruchomienia rzucany jest wyjątek:

java.lang.IllegalArgumentException: Illegal pattern character 'r'
at java.text.SimpleDateFormat.compile(SimpleDateFormat.java:845)
at java.text.SimpleDateFormat.initialize(SimpleDateFormat.java:659)
at java.text.SimpleDateFormat.
(SimpleDateFormat.java:585)

Taaak....
Rozwiązanie 1: przed uruchomieniem arduino wykonać w konsoli:

export LANG=en_US.UTF-8

Environment Variables

Zmienne środowiskowe na windows można na szczęście zapisać:

zmienne sytemowe:

reg save "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" env_var_system.bkp

zmienne użytkownika:

reg save "HKCU\Environment" env_var_user.bkp

Odtwarzanie zmiennych można uzyskać wykonując odpowiednio:

reg restore env_var_system.bkp

reg restore env_var_user.bkp

Transcoding

"Za moich czasów" ASCII było wystarczającym kodowaniem, ba, wiele znaków znałem na pamęć (wiem, geekowate :) )

Obecnie kodowań "jak mrówków". Na szczęście na linuxie można zmienić kodowanie bardzo prosto, za pomocą prostego narzędzia iconv:

iconv --from-code=CP1250 --to-code=UTF-8 file_in > file_out

Initial commit

Zdarza mi się czytać blogi, tak od czasu do czasu. A to wspominki kono... lekarzy znaczy się, a to jakieś techniczne dywagacje na tema tej czy innej technologii. Generalnie są to blogi kierowane do licznej rzeszy potencjalnych odbiorców. Ten blog zaś ma jednego podstawowego odbiorcę... Mnie :)

Nie, nie popadłem w samouwielbienie itp. Bardzo często znajduję się w sytuacji "hmmm. robiłem to, ale jak to było..." albo "dlaczego sobie nie zapisałem jak te [CENZURA] kabelki połączyć". Dlatego też postanowiłem przenosić zapiski jak-ja-coś-zrobiłem, by potem móc do tego wrócić. A jeśli przy okazji komuś któryś z wpisów okaże się pomocny - jakoś to przeżyję ;)