Wprawdzie na początku miał powstać poradnik dotyczący instalacji systemu operacyjnego dla Raspberry Pi za pomocą programu NOOBS, bo jakoś temat uciekł – to jednak szybko się okazało, że właściwie nie ma co tworzyć takiego poradnika, bo sprawa jest naprawdę prosta.

Zamiast tego będzie poradnik, jak… pozbyć się NOOBSa z naszej karty pamięci, zarazem zachowując działający system (w naszym przypadku będzie to Raspbian).

NOOBS (nie) jest zły

Sama idea stojąca za NOOBSem nie jest zła, choć tez nie wiem czy potrzebna – bo moim zdaniem instalacja na karcie pamięci np. czystego Raspbiana z pobranego obrazu nie dość, że jest chyba prostsza, to na pewno znacznie szybsza.

NOOBS (New Out Of the Box Software) pobieramy z internetu (wersja pełna, z systemem Raspbian, lub wersja Lite, która pobiera wybrany system z internetu), kopiujemy na kartę pamięci, wsadzamy do Raspberry Pi i z graficznego instalatora wybieramy system jaki chcemy zainstalować:

Sprawa prosta, choć powtórzę jeszcze raz – nie wiem, czy na pewno jest co upraszczać, bo wgranie systemu bezpośrednio z obrazu ISO/IMG wcale nie jest trudniejsze (piszę to na podstawie informacji uzyskanych od „mniej technicznych” posiadaczy Raspberry Pi).

Nie wszystko złoto…

NOOBS niestety ma swoje wady – na karcie pamięci robi się niezły bałagan jeśli chodzi o partycje. Zamiast 2 jak ma to miejsce w przypadku wgrywania czystego obrazu karty z Raspbianem mamy łącznie 5 czy 6 partycji, a do tego sporo nieprzydzielonych fragmentów:

To jeszcze pół biedy – zapewne dla większości użytkowników nie ma to znaczenia…

NOOBS vs config.txt

Dla mnie większym problemem był brak obsługi/respektowania ustawień w pliku config.txt – dla pewności plik edytowałem zarówno z poziomu Raspbiana:

sudo nano /boot/config.txt

Jak i z poziomu instalatora/menedżera NOOBS – zmiany były widoczne, ale system jakby sobie nic z nich nie robił (choćby ciągłe przełączanie telewizora na Raspberry Pi po każdorazowym restarcie, czy wyłączenie „startowej tęczy”).

Tym samym zapadła decyzja o pozbyciu się NOOBSa, ale, z racji tego, że Raspberry Pi z systemem instalowanym przez NOOBSa miała już przydzielone zadanie, a system był skonfigurowany – instalacja czystego Raspbiana nie wchodziła w grę (znaczy się wchodziła, ale wtedy nie byłoby tego poradnika ;-)).

Usuwanie NOOBSa z Raspberry Pi z zachowaniem zainstalowanego systemu Raspbian

Całą operację zacząłem od analizy tego, jak wygląda karta pamięci po instalacji systemu za pomocą NOOBSa:

sudo fdisk -l

Device         Boot    Start      End  Sectors   Size Id Type
/dev/mmcblk0p1          2048   242187   240140 117.3M  e W95 FAT16 (LBA)
/dev/mmcblk0p2        245760 31371263 31125504  14.9G 85 Linux extended
/dev/mmcblk0p3      31371264 31436799    65536    32M 83 Linux
/dev/mmcblk0p5        253952   376831   122880    60M  c W95 FAT32 (LBA)
/dev/mmcblk0p6        385024 31371263 30986240  14.8G 83 Linux

Od razu widać, że interesujące nas partycje, na których jest system to:

/dev/mmcblk0p5  /boot           vfat    defaults          0       2
/dev/mmcblk0p6  /

Czyli mmcblk0p5 i mmcblk0p6.

Przygotowania, czyli narzędzia

Wprawdzie można pewnie próbować operację wykonać z poziomu systemu Windows, to ja wychodzę z założenia, że nad systemem Linux lepiej pracować w systemie Linux (poza pewnymi wyjątkami).

Dlatego do operacji wykorzystam Raspberry Pi (z NOOBSem) i drugą kartę pamięci, na którą przeniosę czystego/samego Raspbiana.

Jeśli nie macie takiej możliwości – możecie skorzystać z jednej z wielu dystrybucji „LiveCD” z systemem Linux, choć ze względu na ew. różnice w niektórych komendach zalecą wybrać jakąś opartą na Debianie.

Dodatkowo, w tym poradniku postaram się przedstawić kilka metod na dojście do celu – wszystkie one będą się wprawdzie zazębić, ale pozwolą każdemu z Was wybrać najwłaściwszą dla siebie.

Dodatkowa karta pamięci

W części (w większości) opisanych tu metod/sposobów będę posiłkował się drugą karta, na którą będę przenosił pliki i/lub partycje związane z systemem Raspbian (z pominięciem NOOBSa).

Kartę taką możecie przygotować zapewne na kilka sposobów, ja opiszę 3, które różnią się zarówno stopniem skomplikowania (choć raczej w przedziale proste – bardzo proste – super proste ;-)), jak i wykorzystanymi narzędziami.

Wgranie czystego obrazu Raspbiana

Metoda najprostsza, choć teoretycznie trwa najdłużej – na kartę pamięci wgrywamy pobrany ze strony fundacji/projektu Raspberry Pi obraz z systemem Raspbian, co automatycznie utworzy nam wszystkie wymagane partycje.

Jak przeprowadzić taką operację pisałem w tym wpisie – zaprasza…

Utworzenie partycji za pomocą polecenia/programu fdisk

Kolejny sposób, to przygotowanie karty za pomocą linuksowego polecenia fdisk, z którego będzie również korzystać w późniejszych krokach.

Kartę wkładamy do czytnika, i podłączamy do portu USB – w Raspberry Pi, czy w innym systemie (np. LiveCD z Debianem).

Sprawdzamy cz karta jest widoczna w systemie i jakie ma oznaczenie za pomocą polecenia:

sudo fdisk -l

W naszym przypadku niech to będzie karta z jedną partycją FAT23 (Windows):

Device     Boot Start      End  Sectors  Size Id Type
/dev/sda1        2048 31305727 31303680 14.9G  b W95 FAT32

Uruchamiamy fdisk za pomocą polecenia:

sudo fdisk /dev/sda

I zaczynamy od skasowania istniejącej partycji za pomocą polecenia:

d

Następnie kolejno wciskamy/wpisujemy:

n
p
1
First sector: 8192
Last sector: 122879

Co utworzy nam pierwszą partycję, i tym samym możemy przystąpić do tworzenia drugiej partycji:

n
p
2
First sector: 8192
Last sector:

W pozycji „last sector” celowo nie podałem wartości, ponieważ chciałbym temu poświęcić ten akapit:

Domyślnie możemy wybrać maksymalną dostępną wartość (w przypadku mojej karty 166 GB będzie to 31305727), albo – gdy nie potrzebujemy aż tak dużej partycji – możemy wpisać mniejszą wartość, np. 10362879, co da nam partycję ok 4,9 GB, czyli najczęściej wystarczającą.

Na koniec jeszcze ustawiamy aktywną (startową) partycję:

a
1

I wychodzimy z programu naciskając klawisz „w”, dzięki czemu nasze zmiany zostaną zapisane na kartę (jakbyście coś namącili, to zawsze możecie wyjść za pomocą litery „w”, bez zapisywania zmian).

W wyniku tych operacji otrzymamy coś w tym stylu:

sudo fdisk -l

Device     Boot  Start      End  Sectors  Size Id Type
/dev/sda1  *      8192   122879   114688   56M 83 Linux
/dev/sda2       122880 10362879 10240000  4.9G 83 Linux

Można jeszcze pokusić się o sformatowanie utworzonych partycji, ale w większości przypadków nie ma takiej potrzeby:

sudo mkdosfs -F 16 /dev/sda1
sudo mkfs.ext4 /dev/sda2

Tworzenie partycji w trybie graficznym

Partycje na karcie możemy również utworzyć korzystając z programu pracującego w trybie graficznym, jak choćby GParted, który możecie zainstalować w systemie:

sudo apt-get install gparted -y

Lub pobrać jako obraz LiveCD, z którego – po nagraniu na płytę lub pamięć flash – uruchomicie komputer.

Mimo, że może się to wydawać najprostsza metoda, to nie zawsze tak jest, i czasem można się gdzieś pomylić…

Jakbyście chcieli uruchomić GParted bezpośrednio z Raspberry Pi, a nie macie podłączonej myszki/klawiatury, a korzystacie z połączenia SSH, to warto się zainteresować programem Xming (X11), o którym kiedyś już pisałem.

Kopiowanie plików z karty na kartę (rsync)

W pierwszym przykładzie skorzystam z drugiej karty, na którą wcześniej odpowiednio przygotuję (np. wgram czysty obraz systemu Raspbian), dzięki czemu będziemy mieli od razu gotowe partycje do dalszej pracy (po więcej informacji odsyłam do… wcześniejszych akapitów ;-)).

Po tej operacji dodatkową kartę umieszczam w czytniku kart i podłączam do Raspberry Pi (port USB).

Sprawdzam czy widać prawidłowo obie karty za pomocą polecenia:

sudo fdisk -l

Karta z systemem Raspbian i NOOBS:

Device         Boot    Start      End  Sectors   Size Id Type
/dev/mmcblk0p1          2048   242187   240140 117.3M  e W95 FAT16 (LBA)
/dev/mmcblk0p2        245760 31371263 31125504  14.9G 85 Linux extended
/dev/mmcblk0p3      31371264 31436799    65536    32M 83 Linux
/dev/mmcblk0p5        253952   376831   122880    60M  c W95 FAT32 (LBA)
/dev/mmcblk0p6        385024 31371263 30986240  14.8G 83 Linux

Karta z czystym systemem Raspbian:

Device     Boot  Start     End Sectors Size Id Type
/dev/sda1         8192  122879  114688  56M  c W95 FAT32 (LBA)
/dev/sda2       122880 8447999 8325120   4G 83 Linux

Naszym celem będzie skopiowanie plików z partycji mmcblk0p5 na partycję sda1, i z mmcblk0p6 na partycję sda2, za pomocą programu rsync (dzięki czemu zostaną zachowane wszystkie właściwości plików).

Zaczynamy od utworzenia 2 pomocniczych katalogów:

sudo mkdir /media/sd01
sudo mkdir /media/sd02

Które wykorzystamy do zamontowania partycji z dodatkowej (podłączonej do USB) karty pamięci:

sudo mount -t vfat /dev/sda1 /media/sd01
sudo mount -t ext4 /dev/sda2 /media/sd02

Szybki test:

df -h

Filesystem               Size  Used Avail Use% Mounted on
/dev/root                 15G  3.5G   11G  26% /
devtmpfs                 214M     0  214M   0% /dev
tmpfs                    218M     0  218M   0% /dev/shm
tmpfs                    218M  4.7M  213M   3% /run
tmpfs                    5.0M  4.0K  5.0M   1% /run/lock
tmpfs                    218M     0  218M   0% /sys/fs/cgroup
/dev/mmcblk0p5            60M   20M   41M  33% /boot
tmpfs                     44M     0   44M   0% /run/user/1000
tmpfs                     44M     0   44M   0% /run/user/0
/dev/sda1                 56M   20M   37M  36% /media/sd01
/dev/sda2                3.9G  3.0G  700M  82% /media/sd02

I widać, że partycje z karty zostały prawidłowo zamontowane w systemie plików.

Przed skopiowaniem plików musimy skasować już istniejące pliki (czystego systemu), co zrobimy za pomocą polecenia:

sudo rm -rf /media/sd01/*
sudo rm -rf /media/sd02/*

Po tej operacji możemy przystąpić do kopiowania plików:

sudo rsync -avzil --progress /boot/ /media/sd01
sudo rsync -avzil --progress --exclude={/dev/*,/proc/*,/sys/*,/tmp/*,/run/*,/mnt/*,/media/*,/boot/*} / /media/sd02

W drugiej komendzie pomijamy niektóre katalogi, dlatego te katalogi trzeba utworzyć jeszcze raz, ręcznie po całej operacji:

sudo mkdir /media/sd02/dev
sudo mkdir /media/sd02/proc
sudo mkdir /media/sd02/sys
sudo mkdir /media/sd02/tmp
sudo mkdir /media/sd02/run
sudo mkdir /media/sd02/mnt
sudo mkdir /media/sd02/media
sudo mkdir /media/sd02/boot

Dotego odpowiednie uprawnienia:

sudo chmod 0755 /media/sd02/dev
sudo chmod 0555 /media/sd02/proc
sudo chmod 0555 /media/sd02/sys
sudo chmod 1777 /media/sd02/tmp
sudo chmod 0755 /media/sd02/run
sudo chmod 0755 /media/sd02/mnt
sudo chmod 0755 /media/sd02/media
sudo chmod 0755 /media/sd02/boot

Oprócz tego pamiętajcie o podkatalogach służących do montowania zasobów dyskowych/sieciowych (zazwyczaj /media/* /mnt/*), które również należy utworzyć (jeśli nadal zamierzacie z nich korzystać).

Gdy proces kopiowania zostanie zakończony, musimy jeszcze zmienić opcje związane z montowaniem systemu plików:

sudo nano /media/sd02/etc/fstab

I zmieniamy:

/dev/mmcblk0p5  /boot           vfat    defaults          0       2
/dev/mmcblk0p6  /               ext4    defaults,noatime  0       1

na:

/dev/mmcblk0p1  /boot           vfat    defaults          0       2
/dev/mmcblk0p2  /               ext4    defaults,noatime  0       1

Jeśli kopiowaliście również również partycje /boot do katalogu sd01 (partycja sda1) to dodatkowo:

sudo nano /media/sd01/boot/cmdline.txt

I zmieniamy:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p6 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

na:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

Po tej operacji możecie wyłączyć Raspberry Pi, kartę z czytnika włożyć zamiast karty stworzonej za pomocą programu NOOBS, i po uruchomieniu powinien wystartować czysty Raspbian.

Kopiowanie plików z obrazu karty na kartę (rsync)

Kolejna metoda jest dość podobna, z tym, że jako źródło plików wykorzystamy nie działający system, a obraz systemu, który wcześniej należy wykonać.

Będę korzystał z obrazu, do którego jest taka ścieżka:

/media/sftp/rpi01_nobs_20151114.img

Wy musicie tu wstawić ścieżkę do Waszego obrazu.

Operację zaczynamy – podobnie jak poprzednio, ale tym razem tworzymy 4 katalogi pomocnicze.

2 dla obrazu karty:

sudo mkdir /media/img01
sudo mkdir /media/img02

I 2 dla karty SD w czytniku USB (z wgranym obrazem czystego Raspbiana):

sudo mkdir /media/sd01
sudo mkdir /media/sd02

Do których od razu montujemy partycje z karty pamięci:

sudo mount -t vfat /dev/sda1 /media/sd01
sudo mount -t ext4 /dev/sda2 /media/sd02

Następnie analizujemy plik z obrazem karty:

sudo fdisk -lu /media/sftp/rpi01_nobs_20151114.img

Disk /media/sftp/rpi01_nobs_20151114.img: 15 GiB, 16095641600 bytes, 31436800 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

Device                               Boot    Start      End  Sectors   Size Id Type
/media/sftp/rpi01_nobs_20151114.img1          2048   242187   240140 117.3M  e W95 FAT1
/media/sftp/rpi01_nobs_20151114.img2        245760 31371263 31125504  14.9G 85 Linux ex
/media/sftp/rpi01_nobs_20151114.img3      31371264 31436799    65536    32M 83 Linux
/media/sftp/rpi01_nobs_20151114.img5        253952   376831   122880    60M  c W95 FAT3
/media/sftp/rpi01_nobs_20151114.img6        385024 31371263 30986240  14.8G 83 Linux

To co nas interesuje to:

• Units: sectors of 1 * 512 = 512 bytes
• Oraz kolumna „start” dla partycji img5 (253952) i img6 (385024)

Do zamontowania partycji z obrazów potrzebujemy obliczyć ich adres/położenie (offset), co uzyskamy mnożąc rozmiar sektora z wartością z pozycji start każdej z partycji:

• img5: 253952 * 512 = 130023424
• img6: 385024 * 512 = 197132288

Mając już te wartości możemy przystąpić to zamontowania partycji:

sudo mount /media/sftp/rpi01_nobs_20151114.img /media/img01 -o offset=130023424 -t vfat
sudo mount /media/sftp/rpi01_nobs_20151114.img /media/img02 -o offset=197132288 -t ext4

Efekt ponownie możemy sprawdzić za pomocą polecenia:

df -h

/dev/loop0                60M   20M   41M  33% /media/img01
/dev/loop1                15G  3.5G   11G  26% /media/img02

Dalej postępujemy dość podobnie jak poprzednio, czyli najpierw kasujemy pliki:

sudo rm -rf /media/sd01/*
sudo rm -rf /media/sd02/*

A później za pomocą programu rsync kopiujemy dane – z tym, że tym razem jako źródła plików korzystamy z obrazu:

sudo rsync -avzil --progress /media/img01/ /media/sd01
sudo rsync -avzil --progress --exclude={/boot/*} /media/img02/ /media/sd02

Również w tym przypadku, gdy proces kopiowania zostanie zakończony, musimy jeszcze zmienić opcje związane z montowaniem systemu plików:

sudo nano /media/sd02/etc/fstab

I zmieniamy:

/dev/mmcblk0p5  /boot           vfat    defaults          0       2
/dev/mmcblk0p6  /               ext4    defaults,noatime  0       1

na:

/dev/mmcblk0p1  /boot           vfat    defaults          0       2
/dev/mmcblk0p2  /               ext4    defaults,noatime  0       1

Jeśli kopiowaliście również również dane do katalogu sd01 (partycja sda1) to dodatkowo:

sudo nano /media/sd01/boot/cmdline.txt

I zmieniamy:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p6 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

na:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

Po tej operacji możecie wyłączyć Raspberry Pi, kartę z czytnika włożyć zamiast karty stworzonej za pomocą programu NOOBS, i po uruchomieniu powinien wystartować czysty Raspbian.

Kopiowanie całych partycji za pomocą polecenia dd

Kolejna metoda to kopiowanie partycji za pomocą polecenia „dd”.

Nie będzie chyba niespodzianką, gdy napiszę, że również i tym razem zaczynamy od przygotowania drugiej karty z czystym Raspbiane, dzięki czemu będziemy mieli na niej już przygotowane partycje.

Zaczynamy (standardowo) od sprawdzenia jak wyglądają partycje karty z NOOBSem i karty SD, na którą przegramy czystego Rasbiana:

sudo fdisk -l

Device         Boot    Start      End  Sectors   Size Id Type
/dev/mmcblk0p1          2048   242187   240140 117.3M  e W95 FAT16 (LBA)
/dev/mmcblk0p2        245760 31371263 31125504  14.9G 85 Linux extended
/dev/mmcblk0p3      31371264 31436799    65536    32M 83 Linux
/dev/mmcblk0p5        253952   376831   122880    60M  c W95 FAT32 (LBA)
/dev/mmcblk0p6        385024 31371263 30986240  14.8G 83 Linux

Device     Boot  Start     End Sectors Size Id Type
/dev/sda1         8192  122879  114688  56M  c W95 FAT32 (LBA)
/dev/sda2       122880 8447999 8325120   4G 83 Linux

Partycje źródłowe to /dev/mmcblk0p5 i /dev/mmcblk0p6, a docelowe to odpowiednio /dev/sda1 i /dev/sda1.

Możemy przystąpić do bezpośrednio kopiowania partycji:

sudo dd bs=2M if=/dev/mmcblk0p5 of=/dev/sda1
sudo dd bs=2M if=/dev/mmcblk0p6 of=/dev/sda2

Lub jeśli mamy tylko jedną kartę pamięci i korzystamy z niezależnego systemu posiłujemy się obrazami partycji, które najpierw tworzymy:

sudo dd bs=2M if=/dev/sda5 of=/media/sftp/rpi01_nobs_p1.img
sudo dd bs=2M if=/dev/sda6 of=/media/sftp/rpi01_nobs_p2.img

(Gdzie sda5 i sda6 to odpowiedniki mmcblk0p5 i mmcblk0p6, tyle, że w czytniku kart SD)

A później (po przygotowaniu karty) wgrywamy/przywracamy:

sudo dd if=/media/sftp/rpi01_nobs_p1.img of=/dev/sda1
sudo dd if=/media/sftp/rpi01_nobs_p2.img of=/dev/sda2

Na koniec jeszcze zmieniamy opcje związane z montowaniem systemu plików, więc najpierw montujemy partycje:

sudo mkdir /media/sd01
sudo mkdir /media/sd02

sudo mount -t vfat /dev/sda1 /media/sd01
sudo mount -t ext4 /dev/sda2 /media/sd02

I modyfikujemy plik:

sudo nano /media/sd02/etc/fstab

W którym zmieniamy:

/dev/mmcblk0p5  /boot           vfat    defaults          0       2
/dev/mmcblk0p6  /               ext4    defaults,noatime  0       1

na:

/dev/mmcblk0p1  /boot           vfat    defaults          0       2
/dev/mmcblk0p2  /               ext4    defaults,noatime  0       1

Jeśli kopiowaliście również również dane do katalogu sd01 (partycja sda1) to dodatkowo:

sudo nano /media/sd01/boot/cmdline.txt

I zmieniamy:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p6 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

na:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait

Po tej operacji możecie wyłączyć Raspberry Pi, kartę z czytnika włożyć zamiast karty stworzonej za pomocą programu NOOBS, i po uruchomieniu powinien wystartować czysty Raspbian.

GParted, czyli w trybie graficznym

Teoretycznie to miał być koniec poradnika, ale pomyślałem, że pokażę, że można spróbować zmodyfikować kartę utworzoną przez instalator NOOBSa za pomocą programu graficznego GParted:

Od razu przyznam, że nie testowałem tego rozwiązania, i nie wiem czy przedstawione powyżej kroki to wszystkie jakie należy wykonać – w każdym razie warto wcześniej zrobić kopię karty…