Intel Galileo, Yocto, Python, IC, SSH, Crosscompile

Laboratorium 1
(Intel Galileo, Yocto, Python, I2C, SSH, Crosscompile)
Zadania do wykonania
1.
2.
3.
4.
5.
Aktualizacja firmware’u układu Galileo. (5%)
Przygotowanie obrazu systemu Yocto na karcie SD. (10%)
Połączenie i konfiguracja systemu operacyjnego Yocto. (5%)
Instalacja i konfiguracja przykładowego rozszerzeniowego modułu Pythona. (5%)
Przygotowanie infrastruktury do testowania portów układu Galileo, opracowanie testów i ich implementacja w języku Python. Należy przetestować działanie następujących elementów układu Galileo:
•
•
•
•
cyfrowe wyjścia, (10%)
cyfrowe wejścia, (10%)
analogowego wyjścia korzystając z oscyloskopu, (10%)
analogowego wejścia. (10%)
6. Obsługa wyświetlacza LCD przy pomocy Pythona. (10%)
7. Zbudowanie woltomierza, (25%)
Bonus. Kompilacja skrośna. (+0.5)
Laboratorium 2
(Intel Galileo, Debian, CRON, Gstreamer)
Zadania do wykonania
1. Przygotowanie obrazu systemu Debian na karcie SD. (10%)
2. Zwiększenie rozmiaru partycji zawierającej system plików. (15%)
3. Połączenie i konfiguracja systemu operacyjnego: (20%)
• konfiguracja systemu
• aktualizacja systemu przy pomocy menadżera pakietów
• instalacja Gstreamera
4. Cykliczne wykonywanie zadań za pomocą systemu CRON (10%)
5. Przesyłanie plików używając Gstreamera i protokołu UDP – konfiguracja w powłoce BASH (10%)
6. Strumieniowanie audio używając Gstreamera i protokołu UDP
– konfiguracja w powłoce BASH (15%)
7. Opracowanie autorskiej aplikacji cyklicznego strumieniowania audio (20%)
1
Laboratorium 1
(Intel Galileo, Yocto, Python, I2C, SSH, Crosscompile)
Zadania do wykonania
1.
2.
3.
4.
5.
Aktualizacja firmware’u układu Galileo. (5%)
Przygotowanie obrazu systemu Yocto na karcie SD. (10%)
Połączenie i konfiguracja systemu operacyjnego Yocto. (5%)
Instalacja i konfiguracja przykładowego rozszerzeniowego modułu Pythona. (5%)
Przygotowanie infrastruktury do testowania portów układu Galileo, opracowanie testów i ich implementacja w języku Python. Należy przetestować działanie następujących elementów układu Galileo:
•
•
•
•
cyfrowe wyjścia, (10%)
cyfrowe wejścia, (10%)
analogowego wyjścia korzystając z oscyloskopu, (10%)
analogowego wejścia. (10%)
6. Obsługa wyświetlacza LCD przy pomocy Pythona. (10%)
7. Zbudowanie woltomierza, (25%)
Bonus. Kompilacja skrośna. (+0.5)
1
Aktualizacja firmware’u układu Galileo
Aktualizacji układu Galileo należy dokonać przy pomocy dostarczonej aplikacji Arduino. Aplikację należy
uruchomić z uprawnieniami administratora (jako root) na komputerze laboratoryjnym. Należy się upewnić
czy został wybrany prawidłowy plik pośredniczący /dev/ttyACM0 oraz czy przewód USB jest podłączony, a
przewód zasilania odłączony. Ręczne przerwanie procesu aktualizacji lub odłączenie zasilania podczas tego
procesu grozi awarią urządzenia! Dlatego zalecane jest zachowanie szczególnej ostrożności.
Rys. 1.1. GUI – Arduino.
2
2
2.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
Pobranie obrazu systemu operacyjnego
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako student)
# przejdź do katalogu roboczego/domowego:
cd ~
# ściagnij
˛
obraz Linuksa: SDCard.1.0.4.tar.bz2 do katalogu roboczego/domowego
wget http://downloadmirror.intel.com/24355/eng/SDCard.1.0.4.tar.bz2
# lub za pomoca˛ przegladarki
˛
internetowej z https://communities.intel.com/docs/DOC-22226
# rozpakuj archiwum do katalogu roboczego/domowego:
tar xjvf SDCard.1.0.4.tar.bz2
# zawartość znajdzie si˛
e w katalogu: image-full-galileo
# zawartość czyli:
# - jadro
˛
systemu - bzImage
# - katalog rozruchowy - boot
# - program rozruchowy - grub.efi
# - rozruchowy system plików - core-image-minimal-initramfs-clanton.cpio.gz
# - właściwy system plików - image-full-galileo-clanton.ext3
2.2
1
Przygotowanie obrazu systemu Yocto na karcie SD
Formatowanie karty SD i skopiowanie wymaganych plików
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# wszystkie polecenia wydawane przez administratora (root)
# należy wykonywać ze szczególna˛ ostrożnościa˛ - zwłaszcza polecenie dd i fdisk
# podłacz
˛
kart˛
e mikro SD do komputera, sprawdź jaki plik reprezentuje kart˛
e w systemie plików (tu np. /dev/sdc)
# można to zrobić odczytujac
˛ ostatnie komunikaty jadra
˛
systemu:
dmesg
[956173.698945] sdc: sdc1
[956173.700074] sd 14:0:0:0: [sdc] Attached SCSI removable disk
8
9
10
11
12
13
14
15
16
# usuń wszystkie dane z karty:
dd if=/dev/zero of=/dev/sdc
# procedura ta w zależności od pojemności karty może trwać dość długo,
# dlatego można ewentualnie nadpisać tylko poczatek
˛
karty:
dd if=/dev/zero of=/dev/sdc bs=512 count=1
1+0 przeczytanych rekordów
1+0 zapisanych rekordów
skopiowane 512 bajtów (512 B), 0,00264133 s, 194 kB/s
17
18
19
20
21
22
23
24
25
1
2
3
# konfiguracj˛
e tablicy partycji należy przeprowadzić programem fdisk
# prosz˛
e wcześniej przejrzeć manual programu fdisk
man fdisk
# jeżeli w systemie jest zainstalowany podr˛
ecznik, to powinna si˛
e wyświetlić dokumentacja
# należy założyć nowa˛ tablic˛
e partycji oraz utworzyć w niej jedna˛ nowa˛ partycj˛
e
fdisk /dev/sdc # przejście do edycji tablicy partycji
# Prosz˛
e si˛
e upewnić czy wybrano właściwy plik reprezentujacy
˛
kart˛
e SD
# w zależności od konfiguracji systemu może to być /dev/sdb, /dev/sdd itd.
w programie fdisk systemu Debian w komputerze laboratoryjnym
Witamy w programie fdisk (util-linux 2.25.2). # program fdisk służy do manipulowania tablica˛ partycji
Zmiany pozostana˛ tylko w pami˛
eci do chwili ich zapisania.
Przed użyciem polecenia zapisu prosimy o ostrożność.
4
5
6
7
8
9
10
11
12
13
14
15
Urzadzenie
˛
nie zawiera żadnej znanej tablicy partycji.
Created a new DOS disklabel with disk identifier 0xb4d026f0. # automatyczne utworzenie nowej tablicy partycji
# ekwiwalentnie można wykonać polecenie o
Polecenie (m wyświetla pomoc): n # tworzymy nowa˛ partycj˛
e primary obejmujac
˛ a˛ cała˛ kart˛
e SD
Typ partycji
p
główna (głównych 0, rozszerzonych 0, wolnych 4)
e
rozszerzona (kontener na partycje logiczne)
Wybór (domyślnie p): p
Numer partycji (1-4, domyślnie 1): 1
Pierwszy sektor (2048-15523839, domyślnie 2048): 2048
Ostatni sektor, +sektorów lub +rozmiarK,M,G,T,P (2048-15523839, domyślnie 15523839): 15523839
16
17
Utworzono nowa˛ partycj˛
e 1 typu ’Linux’ o rozmiarze 7,4 GiB.
18
19
20
21
22
Polecenie (m wyświetla pomoc): t # zmiana typu partycji na FAT32
Wybrano partycj˛
e 1
Kod szesnastkowy (L wyświetla list˛
e wszystkich kodów): b
Zmieniono typ partycji ’Linux’ na ’W95 FAT32’.
23
24
25
26
27
28
29
30
Polecenie (m wyświetla pomoc): p # wyświetla konfiguracj˛
e tablicy partycji
Dysk /dev/sdc: 7,4 GiB, bajtów: 7948206080, sektorów: 15523840
Jednostki: sektorów, czyli 1 * 512 = 512 bajtów
Rozmiar sektora (logiczny/fizyczny) w bajtach: 512 / 512
Rozmiar we/wy (minimalny/optymalny) w bajtach: 512 / 512
Typ etykiety dysku: dos
Identyfikator dysku: 0x9e9d9bed
31
32
33
Device
/dev/sdc1
Boot Start
End Sectors
2048 15523839 15521792
Size Id Type
7,4G b W95 FAT32
34
35
36
37
38
Polecenie (m wyświetla pomoc): w # fizyczny zapis zmian na urzadzeniu
˛
Tablica partycji została zmodyfikowana.
Wywoływanie ioctl() w celu ponownego odczytu tablicy partycji.
Synchronizacja dysków.
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# po zakończeniu programu fdisk powinien pojawić si˛
e plik /dev/sdc1 reprezentujacy
˛
nowa˛ partycj˛
e
# należy utworzyć na niej system plików FAT32:
mkfs.vfat -F 32 /dev/sdc1
mkfs.fat 3.0.27 (2014-11-12)
# nast˛
epnie utworzyć punkt montowania i zamontować t˛
e partycj˛
e
mkdir sdcard
mount /dev/sdc1 sdcard/
# w końcu kopiujemy zawartość katalogu image-full-galileo:
cp image-full-galileo/* sdcard/ -r
# synchronizujemy dyski:
sync
# i odmontowujemy kart˛
e SD:
umount sdcard
# obraz systemu jest już gotowy, wkładamy kart˛
e SD do układu Galileo
# podłaczamy
˛
zasilanie i czekamy, aż system zostanie załadowany
# proces uruchamiania systemu operacyjnego można obserwować za pośrednictwem interfejsu szeregowego
# należy podłaczyć
˛
odpowiednio przewód i uruchomić aplikacj˛
e putty:
putty
# należy ustawić pr˛
edkość równa˛ 115200 bodów na sekund˛
e
# i komunikować si˛
e za pośrednictwem pliku /dev/ttyUSB0 - choć to może być zależne od systemu operacyjnego
2.3
Nagranie przygotowanego obrazu karty SD z systemem Yocto (alternatywnie)
Niniejszy podpunkt przedstawia alternatywny sposób przygotowania karty SD korzystając z gotowego obrazu. Zaproponowano tu użycie obrazu systemu Yocto w wersji iot-devkit, który jest już skonfigurowany do
pracy z interfejsami I2 C. Wspomniany obraz należy zastosować przy obsłudze wyświetlacza LCD w dalszych
punktach niniejszego ćwiczenia lub skonfigurować system operacyjny instalując wymagane komponenty do obsługi interfejsu I2 C.
1
2
3
4
5
6
7
8
9
10
11
12
13
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# przejdź do katalogu roboczego/domowego:
cd ~
# ściagnij
˛
obraz Linuksa: Yocto (iot-devkit-latest) do katalogu roboczego/domowego
wget http://iotdk.intel.com/images/iot-devkit-latest-mmcblkp0.direct.bz2
# lub za pomoca˛ przegladarki
˛
internetowej z http://iotdk.intel.com/images/
# rozpakuj archiwum do katalogu roboczego/domowego:
bunzip2 -c iot-devkit-latest-mmcblkp0.direct.bz2 > iot-devkit-latest-mmcblkp0.direct
# plik iot-devkit-latest-mmcblkp0.direct jest obrazem kardy SD, który należy nagrać poleceniem dd
dd if=iot-devkit-latest-mmcblkp0.direct of=/dev/sdc
# nast˛
epnie wkładamy kart˛
e SD do układu Galileo
# podłaczamy
˛
zasilanie i czekamy, aż system zostanie załadowany tak, jak opisano w poprzednim podpunkcie
# opcjonalnie można monitorować post˛
ep kopiowania za pomoca˛ polecenia pv
dd if=iot-devkit-latest-mmcblkp0.direct | pv | dd of=/dev/sdc
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Połączenie i konfiguracja systemu operacyjnego Yocto
w powłoce systemu operacyjnego Yocto w układzie Galileo za pośrednictwem RS i putty (jako root)
clanton login: root
# powłoka powinna nas powitać w nast˛
epujacy
˛
sposób:
root@clanton:~#
# na poczatku
˛
prosz˛
e ustawić hasło roota:
passwd
Changing password for root
Enter the new password (minimum of 5, maximum of 8 characters)
Please use a combination of upper and lower case letters and numbers.
New password:
Re-enter new password:
passwd: password changed.
# prosz˛
e zapami˛
etać ustawione hasło
# nast˛
epnie prosz˛
e sprawdzić konfiguracj˛
e połaczenia
˛
ethernetowego:
ifconfig eth0
eth0
Link encap:Ethernet HWaddr 98:4F:EE:01:75:8D
inet addr:192.168.0.23 Bcast:192.168.0.255 Mask:255.255.255.0
inet6 addr: fe80::9a4f:eeff:fe01:758d/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:65066 errors:0 dropped:2285 overruns:0 frame:0
TX packets:72 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:5062703 (4.8 MiB) TX bytes:9513 (9.2 KiB)
Interrupt:40 Base address:0xc000
# statyczny adres IP np. 192.168.0.23 z maska˛ 255.255.255.0 można ustawić nast˛
epujaco:
˛
ifconfig eth0 192.168.0.23 255.255.255.0
# aby połaczenie
˛
internetowe było konfigurowane automatycznie przy właczeniu
˛
systemu,
# należy wyedytować plik /etc/network/interfaces, np.:
auto eth0
iface eth0 inet static
address 192.168.0.23
netmask 255.255.255.0
network 192.168.0.0
gateway 192.168.0.1
# lub dla użycia dhcp:
auto eth0
iface eth0 inet dhcp
4
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
# a nast˛
epnie zrestartować połaczenie
˛
internetowe:
/etc/init.d/networking stop
Deconfiguring network interfaces... done.
/etc/init.d/networking start
Configuring network interfaces... [68481.556663] eth0: device MAC address 98:4f:ee:01:75:8d
[68481.578461] IPv6: ADDRCONF(NETDEV_UP): eth0: link is not ready
udhcpc (v1.20.2) started
Sending discover...
[68483.560262] libphy: stmmac-1:01 - Link is Up - 100/Full
[68483.565563] IPv6: ADDRCONF(NETDEV_CHANGE): eth0: link becomes ready
Sending discover...
Sending select for 192.168.0.23...
Lease of 192.168.0.23 obtained, lease time 90000
ip: RTNETLINK answers: File exists
ip: RTNETLINK answers: File exists
/etc/udhcpc.d/50default: Adding DNS 153.19.48.1
/etc/udhcpc.d/50default: Adding DNS 192.168.0.1
done.
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym
# po konfiguracji sieci można zalogować si˛
e w systemie Yocto za pośrednictwem ssh
# poza logowaniem protokół ssh daje możliwość kopiowania plików na zdalny serwer np.:
echo "Jestem na komputerze laboratoryjnym." > plik.txt
scp plik.txt [email protected]:~
The authenticity of host ’192.168.0.23 (192.168.0.23)’ can’t be established.
ECDSA key fingerprint is 2c:f5:db:5d:b7:9e:87:ff:40:3f:37:60:98:90:2e:9b.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added ’192.168.0.23’ (ECDSA) to the list of known hosts.
[email protected]’s password:
plik.txt
100%
37
# prosz˛
e si˛
e upewnić, czy układ Galileo jest podłaczony
˛
do sieci lokalnej
# logowanie na zdalnym układzie Galileo wyglada
˛
nast˛
epujaco:
˛
ssh [email protected]
[email protected]’s password:
root@clanton:~#
# od tej chwili jesteśmy zalogowani na płytce Galileo
w powłoce systemu operacyjnego Yocto w układzie Galileo za pośrednictwem ssh (jako root)
# prosz˛
e sprawdzić czy udało si˛
e skopiować plik.txt:
ls ~
plik.txt
cat ~/plik.txt
Jestem na komputerze laboratoryjnym.
# prosz˛
e sprawdzić czy w systemie dost˛
epny jest interpreter j˛
ezyka python:
python
Python 2.7.3 (default, Oct 16 2014, 16:04:29)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
# jeżeli pojawi si˛
e powyższy komunikat, to znaczy, że można przejść do kolejnego punktu instrukcji
3.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
0.0KB/s
Konfiguracja przy pomocy systemowego menadżera pakietów – OPKG
w powłoce systemu operacyjnego Yocto w układzie Galileo (jako root)
# dodajemy dodatkowe wpisy konfiguracyjne
echo "src mraa-upm http://iotdk.intel.com/repos/1.1/intelgalactic" > /etc/opkg/mraa-upm.conf
# aktualizujemy informacje o dost˛
epnych pakietach
opkg update
Downloading http://iotdk.intel.com/repos/1.1/iotdk/Packages.
Updated list of available packages in /var/lib/opkg/iotdk.
Downloading http://iotdk.intel.com/repos/1.1/intelgalactic/Packages.
Updated list of available packages in /var/lib/opkg/mraa-upm.
# list˛
e wszystkich dost˛
epnych pakietów można wyświetlić za pomoca˛ polecenia:
opkg list
# tu si˛
e powinna wyświetlić długa lista pakietów...
# sprawdzamy czy sa˛ dost˛
epne pakiety mraa i upm:
opkg list | grep mraa
libmraa0 - 0.5.4.105 - mraa built using CMake
opkg list | grep upm
upm - 0.1.8.183 - upm built using CMake
# instalujemy dodatkowe oprogramowanie - upm i mraa
# jeżeli użyto obraz systemu iot-devkit, pakiety te sa˛ już zainstalowane
opkg install libmraa0
Package libmraa0 (0.5.4.105) installed in root is up to date.
opkg install upm
Package upm (0.1.8.183) installed in root is up to date.
# dodatkowo należy zaktualizować system za pomoca˛ opkg:
opkg upgrade
Upgrading libmraa0 on root from 0.4.5-r0 to 0.5.4.105...
Downloading http://iotdk.intel.com/repos/1.1/intelgalactic/libmraa0_0.5.4.105_i586.ipk.
Removing obsolete file /usr/lib/libmraa.so.0.4.5.
libmraa0 (0.5.4.105) already install on root.
Upgrading upm on root from 0.1.8-r0 to 0.1.8.183...
Downloading http://iotdk.intel.com/repos/1.1/intelgalactic/upm_0.1.8.183_i586.ipk.
upm (0.1.8.183) already install on root.
libmraa0 (0.5.4.105) already install on root.
Configuring libmraa0.
Configuring upm.
5
00:00
3.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
Konfiguracja połączenia SSH – logowanie bez hasła
w powłoce systemu operacyjnego Yocto w układzie Galileo (jako root)
# aby z układu Galileo łaczyć
˛
si˛
e za pośrednictwem SSH bez hasła należy wygenerować i skopiować odpowiednio klucze
# generowanie kluczy
ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/root/.ssh/id_rsa.
Your public key has been saved in /home/root/.ssh/id_rsa.pub.
The key fingerprint is:
6e:3b:88:fa:64:bc:7c:c3:d3:61:d8:d7:16:64:b2:90 root@quark01758d
The key’s randomart image is:
+--[ RSA 2048]----+
|
.
|
|
E . o
|
|
. =
|
|
. .
|
|
oS . .
|
|
. ..+ . o
|
|
+o +oo .
|
|
+..*.o.
|
| .o+. o..
|
+-----------------+
# przy pytaniu o hasło należy wcisnać
˛ ENTER - utworzony zostanie klucz bezhasłowy
# po wykonaniu tego polecenia, wygenerowane zostały dwa klucze:
# klucz prywatny został zapisany w pliku /home/root/.ssh/id_rsa - nie powinniśmy go udost˛
epniać nikomu
# drugi klucz, publiczny, pojawił si˛
e w pliku /home/rot/.ssh/id_rsa.pub
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako zwykły użytkownik)
cd ~
# kopiujemy wpis o kluczu publicznym z układu Galileo na komputer laboratoryjny
# Prosz˛
e pami˛
etać o sprawdzeniu adresów IP i nazw użytkowników
scp [email protected]:/home/root/.ssh/id_rsa.pub .
# wpisujemy informacj˛
e o kluczu do pliku konfiguracyjnego serwera SSH w katalogu domowym
cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
# od tej chwili logowanie z Galileo na komputer laboratoryjny jako zwykły użytkownik
# nie powinno wymagać podawania hasła. Jeżeli chcemy logować si˛
e jako root,
# to informacj˛
e o kluczu publicznym należy dodać również do pliku konfiguracyjnego
# w katalogu domowym tego użytkownika
w powłoce systemu operacyjnego Yocto w układzie Galileo (jako root)
# należy sprawdzić, czy można zalogować si˛
e przez SSH z układu Galileo nie używajac
˛ hasła
# np wykonujac
˛ tam zdalnie polecenie:
ssh [email protected] ’touch ~/nowy_pusty_plik;ls -lrt’
-rw-r--r-- 1 student student
0 lut 3 18:38 nowy_pusty_plik
# tu założono, że komputer laboratoryjny ma przyporzadkowany
˛
adres IP 192.168.0.70
# wcześniej należy sprawdzić, jaki adres ma komputer w laboratorium
# założono też, że użytkownik ma nazw˛
e student
# jeśli wszystko zostało skonfigurowane poprawnie, utworzony zostanie nowy pusty plik
4
Instalacja i konfiguracja przykładowego modułu Pythona
Wokół projektu Galileo rozwinęła się społeczność, która dostarcza różne narzędzia i moduły użyteczne przy
pracy z tym układem. W ramach laboratorium wykorzystano moduł rozszerzeniowy wiring-x86. Więcej
informacji na jego temat można znaleźć na stronie domowej projektu: https://github.com/emutex/wiring-x86
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako student)
# prosz˛
e przejść do katalogu domowego/roboczego
cd ~
# nast˛
epnie ściagn
˛ ać
˛ wymagany moduł np. za pomoca˛ aplikacji wget
wget https://github.com/emutex/wiring-x86/archive/master.zip
# rozpakowujemy ściagni˛
˛
ete archiwum
unzip master.zip
# w lokalnym katalogu powinien pojawić si˛
e nowy katalog wiring-x86-master zawierajacy
˛
omawiany moduł
# nast˛
epnie prosz˛
e skopiować go na układ Galileo na kart˛
e SD za pomoca˛ ssh - prosz˛
e wpisać właściwy adres IP
scp -r wiring-x86-master [email protected]:/media/mmcblk0p1
# oraz logujemy si˛
e na układzie Galileo:
ssh [email protected]
w powłoce systemu operacyjnego Yocto w układzie Galileo za pośrednictwem ssh (jako root)
# w pierwszej kolejności należy przenieść si˛
e do odpowiedniego katalogu
# wcześniej upewniamy si˛
e do jakiego katalogu zostały skopiowane pliki modułu
cd /media/mmcblk0p1/wiring-x86-master/
# możliwości, jakie daje konfigurator dostarczony z modułem, można sprawdzić nast˛
epujaco:
˛
python setup.py --help-commands
# powinna zostać wyświetlona lista dost˛
epnych opcji
# nast˛
epnie sprawdzamy integralność modułu
python setup.py check
running check
# budujemy moduł lokalnie
# jeżeli nie wydamy tego polecenia w tym miejscu, to zostanie ono automatycznie wywołane przy instalacji
python setup.py build
running build
running build_py
6
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
creating build
creating build/lib
copying wiringx86.py -> build/lib
# oraz wybieramy instalacj˛
e
# dzi˛
eki czemu wymagane pliki zostana˛ skopiowane do odpowiednich lokalizacji w systemie plików
python setup.py install
running install_lib
copying build/lib/wiringx86.py -> /usr/lib/python2.7/site-packages
writing byte-compilation script ’/tmp/tmpuWHagM.py’
/usr/bin/python /tmp/tmpuWHagM.py
removing /tmp/tmpuWHagM.py
running install_egg_info
Writing /usr/lib/python2.7/site-packages/Wiring_x86-1.0.0-py2.7.egg-info
# nast˛
epnie przechodzimy do katalogu z przykładami
cd examples
# przykłady sa˛ napisane dla platformy Intel Edison
# dlatego w skryptach należy zmienić nazw˛
e platformy na Intel Galileo gen. 2
cat blink.py | sed s/GPIOEdison/GPIOGalileoGen2/g > blink-galileo.py
# nast˛
epnie należy uruchomić poprawiony skrypt i obserwować diod˛
e nr 13
python blink-galileo.py
Setting up pin 13
Blinking pin 13 now...
5
Przygotowanie infrastruktury do testowania portów układu Galileo, opracowanie testów i ich implementacja w języku Python.
Na początku należy wyprowadzić zasilanie i masę na płytkę testową. Proszę o zachowanie dużej ostrożności,
aby nie dokonać zwarcia – może się to skończyć uszkodzeniem układu Galileo. Na poniższych schematach skrót
GND oznacza masę, odpowiednio 3.3 V i 5.0 V oznacza zasilanie, liczby oznaczają numery pinów. Pozostałe
oznaczenia znajdują się pod schematami, których dotyczą. Zaprezentowano przykłady układów testowych –
studenci mogą zaproponować własne, jednak proszę o zachowanie ostrożności. Szczególnie będzie oceniany
stopień skomplikowania zaimplementowanych algorytmów i inwencja twórcza.
Należy przetestować działanie następujących elementów układu Galileo:
• Cyfrowe wyjścia – należy napisać skrypt w Pythonie, który będzie sterował mruganiem diody D1
podłączonej do portu numer 13. Diody należy podłączyć z odpowiednim rezystorem R1. Oporność
przykładowego rezystora wynosi 1 kΩ – ewentualnie należy ją dobrać w zależności od użytej diody.
Rys. 1.2. Schemat.
7
• Cyfrowe wejścia – należy napisać skrypt w Pythonie, który będzie sterował mruganiem diody D1 podłączonej do portu numer 13. Diody należy podłączyć z odpowiednim rezystorem R1. Diodą należy sterować
w zależności od odczytanego stanu z portu numer 7, który można ustawić za pomocą przełącznika P1.
Oporności rezystorów R1 i R2 wynoszą po 1 kΩ – ewentualnie należy je dobrać w zależności od użytej diody.
Rys. 1.3. Schemat.
• Wyjścia PWM – do testowania wyjścia PWM (ang. pulse-width modulation; modulacja szerokości
impulsów) można zastosować schemat z Rys. 1.2. Proszę zwrócić uwagę, aby zmienić numer portu
np. na 5. Należy napisać skrypt w Pythonie, który będzie płynnie sterował jasnością świecenia diody.
Wygenerowany sygnał należy zaprezentować na oscyloskopie. Dodatkowo należy zademonstrować kilka
różnych wypełnień impulsów prostokątnych oraz częstotliwości ich występowania.
• Analogowe wejścia – należy zbudować obwód zawierający połączone szeregowo rezystory – tak jak na
schemacie na Rys. 1.4. oraz zmierzyć przy pomocy wejścia analogowego wartość napięcia na poszczególnych połączeniach rezystorów. Ćwiczenie należy wykonać podłączając układ do zasilania 3.3 oraz 5.0
V. Wyniki proszę umieścić w tabelce oraz porównać z teoretycznymi wynikami obliczonymi na podstawie
wzoru z dzielnika napięciowego:
n
P
Ri
i=0
Un = Umax N
(1)
P
Ri
i=0
Gdzie N oznacza liczbę wszystkich rezystorów, Umax napięcie zasilania, zaś n numer połączenia pomiędzy rezystorami. Dodatkowo przed połączeniem proszę obliczyć prąd płynący w układzie i tak dobrać
rezystory, żeby nie przekroczyć wydajności prądowej.
8
Rys. 1.4. Schemat.
6
Obsługa wyświetlacza LCD przy pomocy Pythona
Należy podłączyć wyświetlacz LCD (Grove – LCD RGB) za pomocą przewodu I2 C do płytki z wyprowadzeniami tych interfejsów (Grove – Base Shield). Płytka powinna być połączona z układem Galileo za pomocą pinów
rozmieszczonych w dwóch równoległych rzędach. Następnie proszę upewnić się, że wyświetlacz jest wykrywany
na magistrali I2 C i uruchomić skrypt demonstracyjny w języku Python zamieszczony poniżej.
Rys. 1.5. Base shield i wyświetlacz LED.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
w powłoce systemu operacyjnego Yocto w układzie Galileo (jako root)
# prosz˛
e sprawdzić czy wyświetlacz LCD jest wykrywany na magistrali I2C
# można si˛
e posłużyć poleceniem i2cdetect
# wcześniej prosz˛
e si˛
e upewnić, czy zainstalowano pakiet i2c-tools
# jeżeli nie, to należy go zainstalować za pomoca˛ menadżera opkg
i2cdetect -y -r 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00:
-- -- -- -- -- -- -- -- -- -- -- -- -10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -20: -- -- -- -- -- UU UU UU -- -- -- -- -- -- -- -30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -40: -- -- -- -- -- -- -- UU -- -- -- -- -- -- -- -50: -- -- -- -- UU UU UU UU -- -- -- -- -- -- -- -60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -70: -- -- -- -- -- -- -- -# nast˛
epnie należy uruchomić poniższy skrypt demonstracyjny w j˛
ezyku Python
9
1
2
demonstracyjny skrypt w j˛
ezyku Python
# skrypt w pierwszej linii wyświetlacza wypisuje coraz wi˛
eksze liczby
# w drugiej linii - cyfry, które sa˛ dzielnikami tych liczb
3
4
5
import pyupm_i2clcd as i2clcd
import time
# załadowanie wymaganych modułów
def clear(display):
display.setCursor(1, 0)
lcd.write(str(16*" "))
# samodzielne zdefiniowanie funkcji czyszczacej
˛
wyświetlacz
# można tu użyć również funkcji wbudowanej w moduł
6
7
8
9
10
11
12
lcd = i2clcd.Jhd1313m1(0, 0x3E, 0x62)
lcd.setColor(0,255,0)
# podświetlenie wyświetlacza na zielono
13
14
15
16
count=1
while count<10**16:
clear(lcd)
# dlaczego akurat 10**16 ?
17
18
19
lcd.setCursor(0, 0)
lcd.write(str(count))
# ustawienie kursora na poczatku
˛
pierwszej linii
# wpisanie tam liczby
info = "dziel: "
for n in range(9):
if not count%(n+1):
info = info+str(n+1)
# utworzenie napisu w drugiej linii
lcd.setCursor(1, 0)
lcd.write(info)
# ustawienie kursora na poczatku
˛
drugiej linii
# wpisanie tam cyfr, które sa˛ dzielnikami
count+=1
time.sleep(1)
# skrypt czeka jedna˛ sekund˛
e
20
21
22
23
24
25
26
27
28
29
30
7
Zbudowanie woltomierza
Zadanie należy wykonać samodzielnie korzystając ze zdobytej dotąd wiedzy oraz z dokumentacji. Skrypty
mają być napisane w języku Python. Opracowany system pomiarowy powinien:
• działać w zakresie od zera do pięciu woltów,
• umożliwiać pomiar napięcia przy pomocy wejść analogowych układu Galileo,
• pomiaru powinno się dokonywać uruchamiając odpowiedni skrypt,
• woltomierz powinien być wyposażony w wyświetlacz LCD podłączony przez interfejs I2 C,
• wynik pomiaru powinien być pokazywany na wyświetlaczu LCD,
• początkowe pomiary powinny być zweryfikowane przez dodatkowy pomiar oscyloskopem lub profesjonalnym multimetrem,
• wynik pomiaru powinien być zapisywany na zdalnym hoście (serwerze centralnym) – adres i sposób autoryzacji zostanie podany na zajęciach,
• należy zapisać: wartość pomierzonego napięcia, datę i godzinę pomiaru, adres IP układu Galileo, z którego
zapisywane są dane oraz imię i nazwisko operatora (studenta),
• należy wykonać kilka przykładowych pomiarów, np. wykorzystując połączenie szeregowe rezystorów.
Wszystkie wykonane pomiary powinny być widziane na stronie internetowej udostępnianej z serwera centralnego.
Bonus. Kompilacja skrośna
1
2
3
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# najpierw prosz˛
e przygotować system plików, który posłuży do zbudowania programu
# do nowo utworzonej lokalizacji:
mkdir -p /opt/clanton-tiny/1.4.2/sysroots
4
5
6
7
8
1
2
3
4
5
6
# prosz˛
e skopiować z Arduino odpowiednie katalogi:
cd /where/you/extracted/the/archive/arduino-1.5.3/hardware/tools/sysroots
cp -R i586-poky-linux-uclibc /opt/clanton-tiny/1.4.2/sysroots/
cp -R x86_64-pokysdk-linux /opt/clanton-tiny/1.4.2/sysroots/
demonstracyjny program w j˛
ezyku C o nazwie /home/student/test.c
/* prosty demonstracyjny program - hello world */
#include <stdio.h>
int main(int argc, char const* argv[]){
printf("Hello, World!\,n");
return 0;
}
10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako student)
# kolejnym krokiem powinno być przygotowanie pliku Makefile
# prosz˛
e pobrać jego wzór z repozytoium GIT - jest tam również dost˛
epny demonstracyjny program:
git clone https://github.com/tokoro10g/galileo-makefile.git
cp galileo-makefile/Makefile /home/student
cd /home/student
# prosz˛
e dostosować plik Makefile, jeżeli jest to konieczne:
emacs Makefile
# a nast˛
epnie skompilować program:
make
/opt/clanton-tiny/1.4.2/sysroots/x86_64-pokysdk-linux//usr/bin/i586-poky-linux-uclibc/i586-poky-linux-uclibc-g++
-O2 -pipe -g -feliminate-unused-debug-types -fpermissive -Wall -I /opt/clanton-tiny/1.4.2/sysroots/i586-poky-lin
ux-uclibc//usr/include -I /opt/clanton-tiny/1.4.2/sysroots/i586-poky-linux-uclibc//usr/include/c++ -I /opt/clant
on-tiny/1.4.2/sysroots/x86_64-pokysdk-linux//usr/lib/i586-poky-linux-uclibc/gcc/i586-poky-linux-uclibc/4.7.2/inc
lude
-m32 -march=i586 --sysroot=/opt/clanton-tiny/1.4.2/sysroots/i586-poky-linux-uclibc/ -c -o test.o
test.c
/opt/clanton-tiny/1.4.2/sysroots/x86_64-pokysdk-linux//usr/bin/i586-poky-linux-uclibc/i586-poky-linux-uclibc-g++
-Wl,-O1 -Wl,--hash-style=gnu -Wl,--as-needed -L /opt/clanton-tiny/1.4.2/sysroots/i586-poky-linux-uclibc//lib -L
/opt/clanton-tiny/1.4.2/sysroots/i586-poky-linux-uclibc//usr/lib -L /opt/clanton-tiny/1.4.2/sysroots/i586-pokylinux-uclibc//usr/lib/i586-poky-linux-uclibc/4.7.2 -lstdc++ -m32 -march=i586 --sysroot=/opt/clanton-tiny/1.4.2/
sysroots/i586-poky-linux-uclibc/ test.o -o test
demonstracyjny plip Makefile dla kompilacji programu /home/student/test.c
SHELL = /bin/sh
DISTRO = clanton-tiny
TARGET_NAME = i586-poky-linux-uclibc
NATIVE_NAME = x86_64-pokysdk-linux
GCC_VERSION = 4.7.2
6
7
8
9
TARGET_BIN
TARGET_ARCH
INCLUDE_DIRS
10
11
12
LIBRARY_DIRS
13
14
15
COMPILE_OPTS
= test
= -m32 -march=i586 --sysroot=$(SYSROOT_TARGET)
= -I $(SYSROOT_TARGET)/usr/include \
-I $(SYSROOT_TARGET)/usr/include/c++ \
-I $(SYSROOT_NATIVE)/usr/lib/$(TARGET_NAME)/gcc/$(TARGET_NAME)/$(GCC_VERSION)/include
= -L $(SYSROOT_TARGET)/lib \
-L $(SYSROOT_TARGET)/usr/lib \
-L $(SYSROOT_TARGET)/usr/lib/$(TARGET_NAME)/$(GCC_VERSION)
= -O2 -pipe -g -feliminate-unused-debug-types -fpermissive -Wall $(INCLUDE_DIRS)
16
17
18
SYSROOT_TARGET = /opt/$(DISTRO)/1.4.2/sysroots/$(TARGET_NAME)/
SYSROOT_NATIVE = /opt/$(DISTRO)/1.4.2/sysroots/$(NATIVE_NAME)/
19
20
TOOLDIR = $(SYSROOT_NATIVE)/usr/bin/$(TARGET_NAME)
21
22
23
24
25
26
27
28
29
CC
=
CXX
=
AS
=
LD
=
AR
=
CFLAGS =
CXXFLAGS=
LDFLAGS =
$(TOOLDIR)/i586-poky-linux-uclibc-g++
$(CC)
$(CC)
$(CC)
$(TOOLDIR)/i586-poky-linux-uclibc-ar
$(COMPILE_OPTS)
$(COMPILE_OPTS)
-Wl,-O1 -Wl,--hash-style=gnu -Wl,--as-needed $(LIBRARY_DIRS) -lstdc++
30
31
all: target
32
33
34
target: $(patsubst %.c,%.o,$(wildcard *.c)) $(patsubst %.cpp,%.o,$(wildcard *.cpp))
$(LD) $(LDFLAGS) $(TARGET_ARCH) $^ -o $(TARGET_BIN)
35
36
37
clean:
rm -f $(TARGET_BIN) *.o
11
Laboratorium 2
(Intel Galileo, Debian, CRON, Gstreamer)
Zadania do wykonania
1. Przygotowanie obrazu systemu Debian na karcie SD. (10%)
2. Zwiększenie rozmiaru partycji zawierającej system plików. (15%)
3. Połączenie i konfiguracja systemu operacyjnego: (20%)
• konfiguracja systemu
• aktualizacja systemu przy pomocy menadżera pakietów
• instalacja Gstreamera
4. Cykliczne wykonywanie zadań za pomocą systemu CRON (10%)
5. Przesyłanie plików używając Gstreamera i protokołu UDP – konfiguracja w powłoce BASH (10%)
6. Strumieniowanie audio używając Gstreamera i protokołu UDP
– konfiguracja w powłoce BASH (15%)
7. Opracowanie autorskiej aplikacji cyklicznego strumieniowania audio (20%)
1
Przygotowanie obrazu systemu Debian na karcie SD
System operacyjny Debian Wheezy z jądrem Linuksa w wersji 3.8.7 dedykowany dla platformy Intel Galileo
(w tym gen. 2) jest udostępniony na wolnej licencji. Projekt zawiera obraz systemu oraz cały system plików,
który posłużył do zbudowania tego obrazu. Dzięki czemu możliwe jest przygotowanie własnej dedykowanej
dystrybucji Debiana. W omawianym projekcie udostępniono tzw. minimalny obraz, który jednak można rozbudować po instalacji przy pomocy menadżera pakietów APT bez konieczności dodatkowej kompilacji – w ramach
projektu zostało utworzone repozytorium kompatybilne z menadżerem APT.
1
2
3
4
5
6
7
8
9
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako student)
# uwaga wst˛
epna:
# jeżeli jakikolwiek program wymagany do przeprowadzenia tego ćwiczenia,
# jest niedost˛
epny to należy go zainstalować za pomoca˛ menadżera pakietów:
apt-get update
apt-get install parted
Czytanie list pakietów... Gotowe
Budowanie drzewa zależności
Odczyt informacji o stanie... Gotowe
parted jest już w najnowszej wersji.
10
11
12
13
14
# właściwa˛ nazw˛
e
apt-cache search
gparted - Edytor
parted - Program
pakietu można odszukać za pomoca:
˛
parted
partycji dla GNOME
do zarzadzania
˛
partycjami dyskowymi
15
16
17
18
19
20
21
22
23
24
# przy okazji prosz˛
e docenić poczucie humoru twórców oprogramowania open source:
apt-get moo
(__)
(oo)
/------\/
/ |
||
* /\---/\
~~
~~
..."Have you mooed today?"...
25
26
27
28
29
30
31
# zaleca si˛
e zapoznanie również z innym popularnym/konkurencyjnym menażdżerem pakietów typu APT
# o nazwie aptitude:
aptitude search parted
i
gparted
- Edytor partycji dla GNOME
i
parted
- Program do zarzadzania
˛
partycjami dyskowymi
# twórcy zalecaja˛ używanie jednego menażdżera APT
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# Prosz˛
e rozpoczać
˛ ten punkt od przejścia do katalogu roboczego/domowego:
cd ~
# pełen system plików systemu można ściagn
˛ ać
˛ z repozytorium git:
git clone git://git.code.sf.net/p/galileodebian/code galileodebian-code
# wcześniej prosz˛
e si˛
e upewnić czy narz˛
edzie git jest dost˛
epne
# podczas laboratorium zalecane jest ściagni˛
˛
ecie tylko wypreparowanego obrazu karty SD:
wget http://sourceforge.net/projects/galileodebian/files/SD%20card%20Image/galileo-1.2.img.gz
# lub przez przegladark˛
˛
e internetowa˛ ze strony:
# https://sourceforge.net/projects/galileodebian/files/
# prosz˛
e wybrać najnowsza˛ wersj˛
e obrazu
# kolejnym krokiem, jaki należy wykonać, jest rozpakowanie obrazu:
gunzip galileo-1.2.img.gz
# jeżeli nie wystapiły
˛
żadne bł˛
edy, powinien pojawić si˛
e plik z obrazem: galileo-1.2.img
12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# należy podłaczyć
˛
kart˛
e SD do komputera laboratoryjnego
# i sprawdzić, który plik specjalny w katalogu /dev/ reprezentuje t˛
e kart˛
e
# można to zrobić odczytujac
˛ ostatnie komunikaty jadra
˛
systemu:
dmesg
[125999.757685] sdc: sdc1 sdc2
[125999.758993] sd 4:0:0:0: [sdc] Attached SCSI removable disk
# kolejna˛ czynnościa˛ jest skopiowanie obrazu bezpośrednio na kart˛
e SD
# wcześniej można jeszcze usunać
˛ wszystkie dane znajdujace
˛
si˛
e na karcie:
dd if=/dev/zero of=/dev/sdc
# kopiowanie obrazu na kart˛
e:
dd if=galileo-1.2.img of=/dev/sdc
1843200+0 przeczytanych recordów
1843200+0 zapisanych recordów
skopiowane 943718400 bajtów (944 MB), 297,821 s, 3,2 MB/s
15
16
17
18
19
20
# nast˛
epnie prosz˛
e podłaczyć
˛
kart˛
e SD do układu Galileo i podłaczyć
˛
zasilanie
# jednocześnie prosz˛
e obserwować informacje przesyłane do komputera za pomoca˛ interfejsu szeregowego:
putty
# parametry połaczenia
˛
należy ustawić tak, jak na loratorium 1: pr˛
edkość równa˛ 115200 bodów na sekund˛
e
# i komunikować si˛
e za pośrednictwem pliku /dev/ttyUSB0 - choć to może być zależne od systemu operacyjnego
21
22
23
24
25
26
27
28
1
# Program rozruchowy GRUB powinien wyświetlić poniższe menu:
|Debian GNU/Linux, with Linux 3.8.7
|
|Debian GNU/Linux, with Linux 3.8.7 (recovery mode)
|
|Debian GNU/Linux, with Linux 3.2.0-4-486
|
|Debian GNU/Linux, with Linux 3.2.0-4-486 (recovery mode)
|
# należy wybrać pierwsza˛ opcj˛
e: Debian GNU/Linux, with Linux 3.8.7 (jest to domyślny wybór)
# i uruchomić system operacyjny
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem RS i putty (jako root)
Debian GNU/Linux 7 galileo ttyS1
2
3
4
5
6
galileo login: root
Password:
# domyślnym hasłem jest: root
# ale powinno ono być zmienione
7
8
9
10
11
12
13
# wcześniej jednak prosz˛
e sprawdzić ilość dost˛
epnego miejsca na dysku np.
df | grep -i -e mmcblk -e available
Filesystem
1K-blocks
Used Available Use% Mounted on
/dev/mmcblk0p2
810940 391228
378520 51% /
# domyślnie jest ona stosunkowo niewielka
# dlatego należy rozszerzyć t˛
e partycj˛
e
2
1
2
3
4
5
6
7
8
9
10
11
Zwiększenie rozmiaru partycji zawierającej system plików
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# obraz jest zgrany z karty SD o rozmiarze około 1 GB, dlatego należy zaktualizować informacj˛
e
# o dost˛
epnej przestrzeni fizycznego nośnika
parted /dev/sdc print
Warning: Not all of the space available to /dev/sdc appears to be used,
you can fix the GPT to use all of the space (an extra 13680640 blocks) or continue with the current setting?
Fix/Ignore? F
Model: Mass Storage Device (scsi)
Disk /dev/sdc: 7948MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:
12
13
14
15
Number
1
2
Start
17,4kB
100MB
End
100MB
944MB
Size
100MB
844MB
File system
fat16
ext3
Name
Flags
boot, esp
msftdata
16
17
18
19
20
21
22
# nast˛
epnie należy ustalić docelowy rozmiar modyfikowanej partycji (czyli partycji numer 2):
# maksymalny rozmiar partycji zależy od wielkości dost˛
epnej przestrzeni na karcie SD
# można je odczytać z komunikatu wyświetlonego po wykonaniu polecenia: parted /dev/sdc print
parted /dev/sdc resizepart 2
End? [7940MB]? 7948MB
Information: You may need to update /etc/fstab.
23
24
25
26
27
28
# prosz˛
e sprawdzić czy napewna wykonana operacja odniosła efekt:
parted /dev/sdc print
Number Start
End
Size
File system Name Flags
1
17,4kB 100MB
100MB
fat16
boot, esp
2
100MB
7948MB 7848MB ext3
msftdata
29
30
31
32
33
# ewentualnie należy dodać dziennik do systemu plików ext3:
tune2fs -j /dev/sdc2
tune2fs 1.42.12 (29-Aug-2014)
System plików już ma kronik˛
e.
34
35
36
37
38
39
# prosz˛
e uzupełnić system plików na całej partycji:
resize2fs /dev/sdc2
resize2fs 1.42.12 (29-Aug-2014)
Zmiana rozmiaru systemu plików /dev/sdc2 na 1916011 (4k) bloków.
System plików na /dev/sdc2 ma teraz 1916011 (4k) bloków.
13
1
2
3
4
5
6
7
8
9
10
11
12
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# zarówno zaraz po nagraniu minimalnego obrazu na kart˛
e SD,
# jak i na końcu, prosz˛
e sprawdzić poprawność systemu pliku:
e2fsck -f /dev/sdc2
e2fsck 1.42.12 (29-Aug-2014)
/dev/sdd2: odtwarzanie z kroniki
Przebieg 1: Sprawdzanie i-w˛
ezłów, bloków i rozmiarów
Przebieg 2: Sprawdzanie struktury katalogów
Przebieg 3: Sprawdzanie łaczności
˛
katalogów
Przebieg 4: Sprawdzanie liczników odwołań
Przebieg 5: Sprawdzanie sumarycznych informacji o grupach
Bł˛
edna liczba wolnych bloków (1790842, naliczono 1790791).
Poprawić<t>? tak
13
14
15
1
2
3
4
5
/dev/sdd2: ***** SYSTEM PLIKÓW ZMODYFIKOWANY *****
/dev/sdd2: 18945/434240 plików (3.4% nieciagłych),
˛
125220/1916011 bloków
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem RS i putty (jako root)
# o prawidłowym wykonaniu zadania b˛
edzie świadczyło to czy w systemie operacyjnym uruchomionym na układzie Galileo
# zmodyfikowana partycja b˛
edzie miała wi˛
ekszy rozmiar:
df | grep -i -e mmcblk -e available
Filesystem
1K-blocks
Used Available Use% Mounted on
/dev/mmcblk0p2
7554940 391776
6779996
6% /
2.1
Zwiększenie rozmiaru partycji za pomocą Gparted (alternatywnie)
• Po uruchomieniu programu Gparted może pojawić się komunikat z ostrzeżeniem o tym, że cała przestrzeń
dysku nie jest dostępna rys. 2.1. Aplikacja może automatycznie rozwiązać ten problem. Proszę kliknąć
Napraw lub Fix (dla anglojęzycznego interfejsu).
Rys. 2.1. Zrzut ekranu – program gparted.
• W panelu głównym programu Gparted należy wybrać właściwy plik reprezentujący kartę SD – w prezentowanym przykładzie jest to plik /dev/sdd. Jak widać na poniższym rysunku (rys. 2.2.) po nagraniu
minimalenego obrazu niewykorzystanych pozostaje ponad 6.5 GB przestrzeni dyskowej.
Rys. 2.2. Zrzut ekranu – program gparted.
14
• Należy zmienić rozmiar drugej partycji klikając na nią prawym przyciskiem myszy (dla trybu praworęcznego) i wybierajac z menu kontekstowego Zmień rozmiar / przenieś. Powinno pojawić się okno
analogiczne do tego przedstawionego poniżej na rys. 2.3. Następnie proszę przesunąć prawą krawędź
prostokąta symbolizującego rozmiar partycji maksymalnie do prawej strony.
Rys. 2.3. Zrzut ekranu – program gparted.
• Następnie proszę zatwierdzić tę operację – w tym celu proszę wybrać z menu Edycja przycisk Zastosuj
wszystkie działania. Po zapisaniu zmian na karcie SD układ partycji powinien wyglądać tak jak na
poniższym rysunku (rys.2.4).
Rys. 2.4. Zrzut ekranu – program gparted.
• Podczas zapisywania zmian na karcie SD powinno pojawić się analogiczne okno, jak poniżej.
Rys. 2.5. Zrzut ekranu – program gparted.
15
1
2
3
4
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem RS i putty (jako root)
# Pozostaje już tylko sprawdzić dost˛
epne miejsce w systemie działajacym
˛
na układzie Galileo
df | grep -i -e mmcblk -e available
Filesystem
1K-blocks
Used Available Use% Mounted on
/dev/mmcblk0p2
7554116 391776
6779212
6% /
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem RS i putty (jako root)
# w pierwszej kolejności po ustawieniu hasła roota, należy skonfigurować połaczenie
˛
internetowe
# domyślna˛ konfiguracja˛ systemu jest ustawienie interfejsu eth0 w tryb dhcp
ifconfig eth0
eth0
Link encap:Ethernet HWaddr 98:4f:ee:01:75:8d
inet addr:192.168.0.23 Bcast:192.168.0.255 Mask:255.255.255.0
inet6 addr: fe80::9a4f:eeff:fe01:758d/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:15642 errors:0 dropped:0 overruns:0 frame:0
TX packets:162 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:1157343 (1.1 MiB) TX bytes:15025 (14.6 KiB)
Interrupt:40
# aby zmienić t˛
e konfiguracj˛
e np. w celu ustawienia stałego adresu IP
# należy wyedytować odpowiednio plik /etc/network/interfaces
# prosz˛
e wzorować si˛
e na przykładzie podanym na poprzednim laboratorium przy okazji konfiguracji systemu Yocto
# domyślna˛ konfiguracja˛ interfejsu eth0 jest tryb dhcp:
cat /etc/network/interfaces
auto eth0
iface eth0 inet dhcp
3.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Połączenie i konfiguracja systemu operacyjnego
Konfiguracja przy pomocy systemowego menadżera pakietów – ATP
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem RS i putty (jako root)
# kolejnym etapem konfiguracji systemu jest jego aktualizacja za pomoca˛ menażdżera pakietów APT
# prosz˛
e sprawdzić aktualne ustawienia repozytoriów, powinny one wygladać
˛
jak poniżej
cat /etc/apt/sources.list
deb http://ftp.us.debian.org/debian wheezy main contrib non-free
deb http://ftp.us.debian.org/debian wheezy-updates main contrib non-free
deb http://security.debian.org/ wheezy/updates main contrib non-free
# nast˛
epnie prosz˛
e zaktualizować wpisy znanym nam już menażdżerem:
apt-get update
# oraz zaktualizować system:
apt-get upgrade
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following packages will be upgraded:
apt apt-utils base-files bash cpio debian-archive-keyring krb5-locales
libapt-inst1.5 libapt-pkg4.12 libc-bin libc6 libgcrypt11 libgssapi-krb5-2
libk5crypto3 libkeyutils1 libkrb5-3 libkrb5support0 libssl1.0.0 libtasn1-3
linux-image linux-image-3.2.0-4-486 multiarch-support ntpdate perl-base
rsyslog tzdata wget
27 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.
Need to get 46.3 MB of archives.
After this operation, 509 kB disk space will be freed.
Do you want to continue [Y/n]? Y
# ten proces może potrwać kilka minut
# jeżeli zostały zaktualizowane elementy jadra
˛
systemu lub został wygenerowany nowy plik initrd.img
# powinno si˛
e zrestartować układ:
reboot
28
29
30
31
32
33
34
35
36
37
38
# dodatkowo prosz˛
e sprawdzić czy jest zainstalowany serwer ssh
apt-cache search openssh | grep server
gesftpserver - sftp server submodule for OpenSSH
openssh-server - secure shell (SSH) server, for secure access from remote machines
# jeżeli nie to prosz˛
e go zainstalować
apt-get install openssh-server
Reading package lists... Done
Building dependency tree
Reading state information... Done
openssh-server is already the newest version.
3.2
Konfiguracja połączenia SSH – logowanie bez hasła
Po konfiguracji sieci, ustawieniu hasła oraz aktualizacji systemu należy zalogować się w systemie na układzie
Galileo za pośrednictwem SSH. W ramach konfiguracji należy wygenerować i skopiować odpowiednio klucze
SSH, tak aby możliwe było zdalne logowanie nie używając hasła. Opis tej procedury był przedstawiony w
instrukcji do poprzedniego laboratorium.
16
3.3
Instalacja środowiska GStreamer
GStreamer to projekt open source (rozpowszechniany na zasadzie licencji LGPL) – jest to środowisko przeznaczone do tworzenia aplikacji multimedialnych. Pełni funkcję silnika przetwarzającego strumienie multimedialne oraz udostępnia interfejs dla wyższych warstw aplikacji głównie graficznego interfejsu użytkownika.
GStreamer działa na zasadzie systemu wtyczek, które tworzą struktury i potokowo przetwarzają dane. Zostały
opracowane interfejsy w różnych językach programowania m.in. w języku python, które ułatwiaja budowę aplikacji wykorzystujące GStreamer. Więcej informacji na ten temat można uzyskać na wykładach do niniejszego
przedmiotu oraz na stronie projektu: http://gstreamer.freedesktop.org/.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem SSH (jako root)
# kolejnym etapem jest instalacja środowiska GStreamer
apt-get install gstreamer-tools libgstreamer0.10-0
The following extra packages will be installed:
gstreamer0.10-tools libclass-isa-perl libffi5 libglib2.0-0 libglib2.0-data libpcre3 libswitch-perl
libxml2 perl perl-modules pkg-config sgml-base shared-mime-info xml-core
Suggested packages:
gstreamer0.10-plugins-base perl-doc libterm-readline-gnu-perl libterm-readline-perl-perl make
libpod-plainer-perl sgml-base-doc debhelper
The following NEW packages will be installed:
gstreamer-tools gstreamer0.10-tools libclass-isa-perl libffi5 libglib2.0-0 libglib2.0-data libgstreamer0.10-0
libpcre3 libswitch-perl libxml2 perl perl-modules pkg-config sgml-base shared-mime-info xml-core
0 upgraded, 16 newly installed, 0 to remove and 0 not upgraded.
Need to get 15.5 MB of archives.
After this operation, 50.1 MB of additional disk space will be used.
Do you want to continue [Y/n]? Y
16
17
18
19
# dodatkowo menażdżer pakietów zaleca instalacj˛
e dodatkowych paczek m.in. gstreamer0.10-plugins-base,
# który zawiera zbiór podstawowych wtyczek, należy je także zainstalować wraz z zależnościami:
apt-get install gstreamer0.10-plugins-base
20
21
22
23
# dodatkowo prosz˛
e zainstalować paczk˛
e gstreamer0.10-plugins-good:
apt-get install gstreamer0.10-plugins-good
# może to zajać
˛ dłużdsza˛ chwil˛
e...
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# spis zainstalowanych wtyczek można uzyskać za pomoca˛ polecenia gst-inspect
# do przeprowadzenia laboratorium b˛
eda˛ potrzebne m.in. nast˛
epujace wtyczki:
# audiotestsrc, udpsink, filesrc, filesink
# prosz˛
e sprawdzić czy sa˛ one dost˛
epne w systemie:
gst-inspect | grep audiotestsrc
gst-inspect | grep udpsink
gst-inspect | grep -e filesrc -e filesink
# szczegóły dotyczace
˛
konfiguracji poszczególnych wtyczek można wyświetlić
# podajac
˛ nazw˛
e wtyczki jako argument polecenia gst-inspect np.:
gst-inspect udpsink
Factory Details:
Long name:
UDP packet sender
Class:
Sink/Network
Description:
Send data over the network via UDP
Author(s):
Wim Taymans <[email protected]>
...
4
Cykliczne wykonywanie zadań za pomocą systemu CRON
CRON to system (demon) przeznaczony do cyklicznego wykonywania zadań. Jego konfiguracji można dokonać za pomocą tabel crontab. System przeszukuje m.in. następujące lokalizacje /var/spool/cron/crontabs/,
/etc/crontab oraz /etc/cron.*/. Tabele programu cron posiadają specjalny format: pierwsze pięć pozycji oddzielone spacją lub tabulatorem jest deskryptorem częstości wykonywania polecenia, które występuje na miejscu
szóstym tej tabeli.
1
2
3
demonstracyjny skrypt w j˛
ezyku BASH o nazwie /root/test.sh
# na poczatku
˛
prosz˛
e utworzyć prosty skrypt, który b˛
edzie cyklicznie wywoływany przez system CRON
# prosz˛
e ustalić nazw˛
epliku do logowania w katalogu /tmp:
logfile=/tmp/mylog
4
5
6
7
# skrypt powinien zapisać najpierw dat˛
e i godzin˛
e do pliku logowania:
echo ">> new log <<" >> $logfile
date >> $logfile
8
9
10
# a nast˛
epnie wpisać do niego 10 procesów, które najbardziej obcia˛żaja˛ procesor:
ps -eo pcpu,pid,user,args | sort -k 1 -r | head -10 >> $logfile
11
12
13
14
15
# oraz sprawdzić dost˛
epność wybranego hosta w sieci:
ping 192.168.0.70 -c 3 >> $logfile
echo " " >> $logfile
echo " " >> $logfile
16
17
18
# prosz˛
e zapoznać si˛
e ze wszystkimi opcjami przekazanymi do wywoływanych aplikacji
# np. man ps
17
1
2
3
4
5
6
1
2
3
4
5
6
7
8
9
10
11
demonstracyjny plik konfiguracyjny systemu CRON o nazwie /root/test.cron
# nast˛
epnie prosz˛
e utworzyć plik-tabel˛
e kompatybilna˛ z systemem CRON
# odpowiednio liczby wpisane na poszczególnych pozycjach oznaczaja˛
# minut˛
e godzin˛
e dzień miesiaca
˛
miesiac
˛
dzień tygodnia
polecenie
# (0-59) (0-23)
(1-31)
(1-12 or Jan-Dec) (0-6 or Sun-Sat) /bin/bash /root/test.sh
*/15 * * * * /bin/bash /root/test.sh
# powyższy wpis oznacza że skrypt /root/test.sh b˛
edzie wykonywany co 15 minut
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem SSH (jako root)
# aby dodać wpis odpowiedzialny za wywoływanie danego polecenia należy skorzystać z programu crontab
# crontab z opcja˛ -l listuje tabel˛
e zadań dla danego użytkownika wymienionego w argumencie opcji -u
crontab -l -u root
no crontab for root
# aby dodać wpis prosz˛
e podać nazw˛
e pliku konfiguracyjnego jako argument, tak jak poniżej
crontab -u root /root/test.cron
# odpowiedni wpis powinien teraz być wyświetlany przez polecenie crontab -l
crontab -lu root
*/15 * * * * /bin/bash /root/test.sh
# na koniec prosz˛
e si˛
e upewnić czy polecenie jest wykonywane cyklicznie, jeżeli tak to prosz˛
e wyczyścić tabel˛
e
crontab -r -u root
5
Przesyłanie plików używając Gstreamera i protokołu UDP
– konfiguracja w powłoce BASH
W niniejszym punkcie należy przetestować działanie Gstreamera i sprawdzić jego przydatność pod kątem
przesyłania plików tekstowych za pomocą protokołu UDP. Zadanie to proszę wykonać za pomocą narzędzi
pochodzących z pakietu gst-tools: gst-inspect i gst-launch oraz postępując zgodnie z poniższymi wskazówkami.
1
2
3
4
5
6
7
# na samym
# używajac
˛
gst-launch
Ustawianie
Potok jest
Ustawianie
New clock:
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako student)
poczatku
˛
należy zestawić tor odbiorczy
wtyczek udpsrc oraz filesink
udpsrc port=5088 ! filesink location=plik-rec.txt
potoku na PAUZOWANIE...
na żywo i nie wymaga PRZEWINIECIA...
˛
potoku na ODTWARZANIE...
GstSystemClock
8
9
# po wydaniu takiego polecenia tor odbiorczy b˛
edzie oczekiwał na przesłanie danych
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
#
#
#
#
#
#
#
gst-launch to aplikacja, która pozwala szybko uruchomić łańcuch wtyczek
każdej wtyczce można ustawić jej tzw. właściwości, spis wszystkich właściwości można uzyskać
za pomoca˛ polecenia gst-inspect
wtyczka udpsrc pozwala na ustawienie m.in. numeru portu, na którym b˛
edzie prowadzony nasłuch
wtyczka filesink - nazwy pliku na dysku, do którego b˛
edzie prowadzony zapis
należy użyć znaku równości do ustawienia poszczególnych właściwości
oraz znaku wykrzyknika do połaczenia
˛
poszczególnych wtyczek
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem SSH (jako root)
# analogicznie (komplementarnie) należy zestawić tor nadawczy na układzie Galileo
# najpierw prosz˛
e wygenerować plik tekstowy do przesłania
i=0
while [[ $i -lt 16 ]]; do
i=$[$i+1];
echo "$i linia w pliku";
done > plik.txt
# prosz˛
e upewnić si˛
e co zawiera wygenerowany plik:
cat plik.txt
1 linia w pliku
2 linia w pliku
...
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# nast˛
epnie zestawić tor nadawczy:
gst-launch filesrc location=plik.txt ! udpsink host=192.168.0.70 port=5088
Setting pipeline to PAUSED ...
Pipeline is PREROLLING ...
Pipeline is PREROLLED ...
Setting pipeline to PLAYING ...
New clock: GstSystemClock
Got EOS from element "pipeline0".
Execution ended after 9281999 ns.
Setting pipeline to PAUSED ...
Setting pipeline to READY ...
Setting pipeline to NULL ...
Freeing pipeline ...
27
28
29
30
31
1
2
3
4
5
#
#
#
#
wtyczka filesrc pozwala na ustawienie m.in. nazwy czytanego pliku - za pomoca˛ właściwości location
dla poprawnego działania należy ustawić dwie właściwości wtyczki udpsink:
port - numer portu na którym prowadzony jest nasłuch
host - adres ip docelowej maszyny
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako root)
# finalnie należy sprawdzić, czy udało si˛
e przesłać zawartość pliku z układu Galileo na komputer laboratoryjny
cat plik-rec.txt
1 linia w pliku
2 linia w pliku
...
18
6
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
Strumieniowanie audio używając Gstreamera i protokołu UDP
– konfiguracja w powłoce BASH
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako student)
# najpierw prosz˛
e upewnić si˛
e czy wtyczki obsługujace
˛
system ALSA sa˛ zainstalowane:
apt-get update
apt-get install gstreamer1.0-alsa
Czytanie list pakietów... Gotowe
Budowanie drzewa zależności
Odczyt informacji o stanie... Gotowe
gstreamer1.0-alsa jest już w najnowszej wersji.
# jeżeli nie, to prosz˛
e je zainstalować
w powłoce systemu operacyjnego Debian w komputerze laboratoryjnym (jako student)
# nast˛
epnie prosz˛
e przełaczyć
˛
si˛
e na zwykłego użytkownika (student)
# oraz zestawić tor odbiorczy:
gst-launch udpsrc port=5088 ! audio/x-raw-float,rate=4000,width=64,channels=1,endianness=1234 /
! audioconvert ! alsasink
Ustawianie potoku na PAUZOWANIE...
Potok jest na żywo i nie wymaga PRZEWINIECIA...
˛
Ustawianie potoku na ODTWARZANIE...
New clock: GstSystemClock
9
10
11
12
# tor odbiorzy powinien teraz oczekiwać na przesłanie strumienia audio na port nr 5088
# Gstreamer posiada wbudowany mechanizm negocjacji formatu przesyłanych danych
# jednak czasem może wystapić
˛
potrzeba wymuszenia alternatywnego formatu
13
14
15
# kolorem purpurowym oznaczono tzw. CAPS - jest to skrót od Capabilities
# CAPS wykorzystuje si˛
e do wymuszenia właściwego formatu strumienia danych multimedialnych
16
1
2
3
4
5
6
7
8
9
w powłoce systemu operacyjnego Debian w układzie Galileo za pośrednictwem SSH (jako root)
# sygnał dźwi˛
ekowy prosz˛
e wyemitować za pomoca˛ układu Intel Galileo i wtyczki audiotestsrc
# komplementarny tor nadawczy można zrealizować w nast˛
epujacy
˛
sposób:
gst-launch audiotestsrc freq=500 ! audio/x-raw-float,rate=4000,width=64,channels=1,endianness=1234 /
! udpsink host=192.168.0.70 port=5088
Setting pipeline to PAUSED ...
Pipeline is PREROLLING ...
Pipeline is PREROLLED ...
Setting pipeline to PLAYING ...
New clock: GstSystemClock
10
11
12
13
14
15
#
#
#
#
#
tor nadawczy powinien emitować ciagły
˛
sygnal jednotonowy o cz˛
estotliwości 500 Hz
tu wymuszony został taki sam format strumienia danych jak w torze odbiorczym
zawsze prosz˛
e upewnić si˛
e, czy zadany format danych jest dost˛
epny dla danej wtyczki
sygnał audio powinien być przesyłany za pomoca˛ prodokołu UDP na adres podany jako host
do portu karty sieciowej określonej przez numer przypisany właściwości port
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# aby określić czas trwania sygnału, należy ustawić właściwość num-buffers
gst-launch audiotestsrc freq=500 num-buffers=3 ! audio/x-raw-float,rate=4000,width=64,channels=1,endianness=1234 /
! udpsink host=192.168.0.70 port=5088
Pipeline is PREROLLING ...
Pipeline is PREROLLED ...
Setting pipeline to PLAYING ...
New clock: GstSystemClock
Got EOS from element "pipeline0".
Execution ended after 765127542 ns.
Setting pipeline to PAUSED ...
Setting pipeline to READY ...
Setting pipeline to NULL ...
Freeing pipeline ...
30
31
# o jakiej najwi˛
ekszej cz˛
estotliwości ton można przesyłać przy zadanym formacie danych?
32
33
34
# tor nadawczy można uruchamiać wiele razy,
# tymczasem tor odbiorczy powinien odtwarzać kolejno otrzymane sygnały
7
Opracowanie aplikacji cyklicznego strumieniowania audio
Zadanie należy wykonać samodzielnie korzystając ze zdobytej dotąd wiedzy oraz z dokumentacji. Aplikacja
może być napisana jako skrypty BASH lub w języku Python. Opracowany system powinien:
• przesyłać strumienie audio za pomocą frameworka Gstreamer,
• przesyłać zróżnicowane sygnały dźwiękowe (czas trwania, częstotliwość),
• sygnały powinny być dobierane np. ze względu na godzinę lub napięcie występujące na portach GPIO,
• być synchronizowany przez system CRON,
• wykrywać wyłączenie toru odbiorczego i automatyczne go włączać,
• może przesyłać do odtwarzania pliki audio np. w formacie WAV.
19