Fedora-Fr - Communauté francophone Fedora - Linux

Planet de Fedora-Fr : la communauté francophone autour de la distribution Linux Fedora

A propos

Cette page est actualisée toutes les heures.

Cette page est une sélection de blogs autour de Fedora. Fedora-Fr.org décline toute responsabilité au sujet des propos tenus par les auteurs des blogs de ce planet. Leurs propos sont leur entière responsabilité.

Le contenu de ce planet appartient à leurs auteurs respectifs. Merci de consulter leur blogs pour obtenir les licences respectives.

Mot-clefs : Embedded

Maixduino : mise en oeuvre avec Arduino IDE

Patrice Kadionik

Salut.

Le kit Maixduino de Sipeed que nous avons présenté précédemment peut être utilisé avec un atelier de développement logiciel comme Arduino IDE. On pourra alors programmer avec le langage C/C++.

On installera dans un premier temps Arduino IDE. On suppose que l'on est sous Linux. La procédure d'installation est décrite dans ce document.

On récupère Arduino IDE pour Linux (ici pour la version 64 bits) à l'adresse : https://www.arduino.cc/en/Main/Software. A ce jour, il s'agit de la version 1.8.13.

On installe ensuite Arduino IDE (pour moi sous Fedora 64 bits) :

$ tar -xvJf arduino-1.8.13-linux64.tar.xz

On validera l'accès au port USB pour dialoguer avec le kit et on installera les paquetages Python nécessaires :

$ sudo usermod -a -G dialout $(whoami)
$ sudo dnf install python3 python3-pip
$ sudo pip3 install pyserial

On lancera ensuite Arduino IDE :

$ cd arduino-1.8.13
$ ./arduino

Il faudra ensuite configurer Arduino IDE et rajouter le profil des cartes Sipeed en allant dans le menu Fichier > Préférences.

On ajoutera dans le champ "URL de gestionnaire de cartes supplémentaires" l'adresse suivante : http://dl.sipeed.com/MAIX/Maixduino/package_Maixduino_k210_index.json.

Il faudra ensuite ajouter la carte Maixduino à Arduino IDE. Pour cela on va dans le menu Outils > Type de carte > Gestionnaire de carte. On filtrera pour choisir le kit Maixduino et on installera le support Maixduino (version 0.3.11 à ce jour).

Dans le menu Outils, on ajustera les paramètres suivants :

  • Type de carte : Sipeed Maixduino Board.
  • Port : /dev/ttyUSB0.
  • Programmateur : k-flash.

Tout est maintenant installé. On peut alors tester avec un croquis de base. On choisit le croquis Blink disponible sous Fichier > Exemples > 01.Basics.

On cliquera sur le bouton Téléverser ou via le menu Croquis > Téléverser. Le croquis est compilé puis téléversé et programmé en mémoire Flash de la carte Maixduino.

Si tout va bien, la led  TX-K210 doit clignoter.

Cela correspond à la valeur 1 pour la constante LED_BUILTIN qui est définie dans le fichier ~/.arduino15/packages/Maixduino/hardware/k210/0.3.11/variants/sipeed_maixduino/pins_arduino.h. 

Le pinout de la carte Maixduino est disponible ici.

La documentation pour développer avec Arduino IDE est disponible ici. Cela reste en fait de la programmation traditionnelle sous Arduino.

++

Maixduino : processeur RISC-V K210

Patrice Kadionik

Salut.

Le kit Maixduino de Sipeed est équipé d'un processeur RISC-V développé par la société chinoise Canaan et appelé K210 (K pour Kendryte).

Ce processeur est basé sur une architecture de jeu d'instructions (Instruction Set Architecture) libre RISC-V. Le projet RISC-V est intéressant car c'est un projet de matériel libre (open hardware) que peut implanter tout un à chacun. On vous dit bien sûr quoi faire mais pas comment le faire.

Il existe à l'heure actuelle peu de processeurs RISC-V hardcores et qui supportent Linux en plus.  On peut citer :

  • Le processeur SiFive U540 de la société SiFive qui est le premier processeur hardcore supportant Linux comportant 4+1 cœurs RISC-V 64 bits.
  • Le processeur Kendryte K210 comportant 2 cœurs RISC-V 64 bits et un processeur d'Intelligence Artificielle (IA) et supportant Linux et FreeRTOS.
  • Le microcontrôleur GD32V de la société GigaDevice.
Il existe aussi des implantations en tant que processeurs softcores. On peut citer :
  • Le projet LowRISC. On a un processeur RISC-V 64 bits. Le projet LowRISC peut tourner sur une carte FPGA Nexys 4 DDR ou A7 de Digilent et supporte Linux.

La codification d'un processeur RISC-V est normalisée. Le préfixe est RV (pour RISC-V) suivi de 32, 64 ou 128 selon la taille du processeur puis suivi de I ou E (pour Embedded). Exemple : RV32I, RV64I...

Le préfixe est suivi d'une ou plusieurs lettres décrivant les extensions rajoutées :

  • M : Standard Extension for Integer Multiplication and Division
  • A : Standard Extension for Atomic Instructions
  • F : Standard Extension for Single-Precision Floating-Point
  • D : Standard Extension for Double-Precision Floating-Point
  • G : raccourci pour MAFD
  • Q : Standard Extension for Quad-Precision Floating-Point
  • C : Standard Extension for Compressed Instructions. Instructions courtes sur 16 bits
Par exemple, le microcontrôleur GD32V est un RISC-V RV32IMAC. Le processeur K210 est un RISC-V RV64IMAFDC ou de façon plus concise un RISC-V RV64GC.

Le processeur K210 possède les fonctionnalités suivantes :


Le processeur K210 vise des applications d'IA et de traitement du son :
  • Détection d'objets
  • Classification d'images
  • Détection et reconnaissance de visages
  • Obtention de la taille et des coordonnées d'une cible en Temps Réel
  • Détection de l'orientation d'une source de son
  • Reconnaissance de la voix
  • ...

Le processeur K210 contient différents périphériques :
  • 2 coeurs RISC-V RV64GC à 400 MHz
  • 1 processeur KPU (Knowledge Processor Unit) pour l'IA et accélérateur de calcul pour un réseau de neurones convolutionnel CNN
  • 1 processeur APU (Audio Processor Unit) pour le traitement du son
  • 1 accélérateur pour les transformées de Fourier rapides FFT et IFFT sur 64, 128, 256 ou 512 points
  • Accélérateurs pour le chiffrement SHA256 et AES128, AES192 et AES256
  • 8 Mo de SRAM
  • Transferts DMA
  • Périphériques divers  : UART, GPIO, SPI, I²C, I²S, WDT, TIMER, RTC...
  • JTAG
  • ...
Les spécifications du processeur K210 sont disponibles ici (fichier kendryte_datasheet_20181011163248_en.pdf).

Des kits de développement sont disponibles pour le processeur K210 :
  • Kit Kendryte KD2333 de Canaan. Ne semble plus disponible
  • Kit Maixduino de Sipeed pour 23,90 USD
  • Kit MaixCube de Sipeed pour 24,90 USD
  • Kit Maix Go de Sipeed pour 40,90 USD
  • Kit Maix Bit Suit de Sipeed pour 20,90 USD
Il faut noter que la société Sipeed a intégré le processeur K210 dans un module qu'elle a développé : le module Maix-I.

Le module Maix-I ou M1 intègre outre le processeur K210 16 Mo de mémoire Flash et une interface Wifi (M1w à 8,90 USD) ou non (M1 à 7,90 USD). Il permet de réaliser plus facilement sur propre circuit PCB.

La figure suivante montre le module M1.

Nous verrons dans un prochain billet quels sont les environnements de développement disponibles pour le processeur K210 et donc pour le kit Maixduino.

++

Maixduino : un kit avec un processeur RISC-V pour faire de l'IA

Patrice Kadionik

Salut.

Je viens de recevoir mon kit Maixduino de Sipeed acheté chez Seeed pour 23,90 USD.

Maixduino

Ce kit est intéressant à plusieurs titres pour :

  • Etude du processeur RISC-V.

  • Développement bare metal avec le langage C avec les IDE Arduino IE ou PlatformIO.

  • Développement Temps Réel avec le langage C avec FreeRTOS.

  • Mise en oeuvre de Linux embarqué (Linux sans MMU).

  • Développement avec le langage Python grâce à l'interpréteur Python MaixPy.

  • Développement d'algorithmes d'IA Python avec Tensorflow et Keras.

La bête possède les caractéristiques suivantes :

  • CPU: RISC-V Dual Core 64bit, with FPU; 400MHz neural network processor

  • QVGA@60FPS/VGA@30FPS image identification

  • Onboard ESP32 module support 2.4G 802.11. b/g/n and Bluetooth 4.2

  • Arduino Uno form factor, Arduino compatible interfaceOnboard omnidirectional I2S digital output MEMS Microphone

  • 24P 0.5mm FPC connector for DVP Camera

  • 8bit MCU LCD 24P 0.5mm FPC connector

  • Support self-elastic micro SD card holder

  • Reset and boot button; 3W DAC+PA Audio output

  • Just connect the USB Type-C cable to complete the downloadMachine vision based on convolutional neural network

  • High performance microphone array processor for machine hearing
    Support MaixPy IDE, Arduino IDE, OpenMV IDE, and PlatformIO IDE

  • Support Tiny-Yolo, Mobilenet and TensorFlow Lite for deep learning

Je consacrerai d'autres billets sur ce kit, le processeur RISC-V ou l'IA (que j'étudie depuis 6 mois sous l'angle de l'embarqué) au fur et à mesure.

++

Raspberry Pi et commandes apt

Patrice Kadionik

Salut.

Quand on utilise une carte Raspberry Pi avec une distribution Raspbian prête à l'emploi, il est fréquent à avoir à installer de nouveaux paquets et à utiliser des commandes apt Debian.

Voici pour mémoire la liste des opérations apt les plus courantes :

Mise à jour liste des paquets :

% sudo apt-get update


Mise à jour du système :

% sudo apt-get upgrade


Recherche dun  paquet :

% sudo apt-cache search nom_paquet


Informations sur un  paquet :

% sudo apt-cache show nom_paquet


Installation dun  paquet :

% sudo apt-get install nom_paquet


Suppression dun  paquet :

% sudo apt-get remove nom_paquet


Suppression dun  paquet y compris ses fichiers de configuration:

% sudo apt-get purge nom_paquet

++

Linux Temps Réel sur ARM AT91RM9200. Séance 2 : installation de l'environnement

Patrice Kadionik

Salut.

Pour cette deuxième séance, nous allons installer en premier lieu lenvironnement de développement sur son PC sous Linux.

Il faut d'abord récupérer les tarballs du compilateur croisé et du kit de développement "maison" (SDK) pour la carte cible :

% wget http://kadionik.vvv.enseirb-matmeca.fr/pub/cpuat91/CPUAT91.tgz
% wget http://kadionik.vvv.enseirb-matmeca.fr/pub/cpuat91/arm-2014.05.tgz

On installe dans un premier temps le compilateur croisé :

% tar -xvzf arm-2014.05.tgz
% sudo mv arm-2014.05 /opt

Puis, on configure sa variable PATH via le fichier .bash_profile si l'on utilise le shell Bash :

% echo "export PATH=/opt/arm-2014.05/bin:$PATH" >> ~/.bash_profile
% source ~/.bash_profile

On vérifie alors que l'on a accès au compilateur croisé gcc pour ARM :

% arm-none-linux-gnueabi-gcc -v
Using built-in specs.
COLLECT_GCC=arm-none-linux-gnueabi-gcc
COLLECT_LTO_WRAPPER=/opt/arm-2014.05/bin/../libexec/gcc/arm-none-linux-gnueabi/4.8.3/lto-wrapper
Target: arm-none-linux-gnueabi
Configured with: /scratch/maciej/arm-linux-2014.05-rel/src/gcc-4.8-2014.05/configure ...
Thread model: posix
gcc version 4.8.3 20140320 (prerelease) (Sourcery CodeBench Lite 2014.05-29)

Il ne reste plus qu'à installer le kit de développement maison (SDK) pour la carte cible :

% tar -xvzf CPUAT91.tgz
% cd CPUAT91
% ls
linux-3.14.17 linux-3.14.17-xenomai rootfs tst xenomai xenomai-2.6-2.6.4

Suite au prochain billet...

++

Linux Temps Réel sur ARM AT91RM9200. Séance 1 : présentation de la carte

Patrice Kadionik

Salut.

Comme je l'avais fait il y a quelques années avec la carte mini2440, je vais consacrer ce billet et les suivants à la mise en oeuvre de Linux Temps Réel Xenomai sur une ARM Eukréa AT91RM9200.

On verra les points suivants :

  • Mise en œuvre de Linux embarqué.
  • Mise en œuvre de lextension Temps Réel dur Xenomai pour Linux embarqué.
  • Mesures de temps de latence.

Xenomai est une solution Temps Réel dur sous Linux.

Je vais dans ce premier billet présenter la carte cible.

La carte cible AT91 est une carte de développement de la société bordelaise permettant de mettre en œuvre le processeur ARM9 AT91RM9200. Le processeur AT91RM9200 supporte Linux avec MMU.

Larchitecture du processeur AT91RM9200 est donnée sur les figures suivantes :

at91_processeur1.jpg

at91_processeur2.jpg
 
La carte cible possède les fonctionnalités suivantes :

  • ARM920T ARM Thumb Processor, v4T Architecture
  • 200 MIPS at 180 MHz
  • Memory Management Unit
  • 16-KByte Data Cache, 16-KByte Instruction Cache
  • In-circuit Emulator including Debug Communication Channel
  • 16K Bytes of SRAM and 128K Bytes of ROM
  • Ethernet MAC 10/100 Base-T
  • USB 2.0 Full Speed
  • Multimedia Card Interface
  • 4 Universal Synchronous/Asynchronous Receiver/Transmitters
  • Master/Slave Serial Peripheral Interface SPI
  • Two 3-channel, 16-bit Timer/Counters
  • IEEE 1149.1 JTAG Boundary Scan
  • Synchronous dynamic random access memory (SDRAM)
  • 32MB (MICRON - 128Mb x 2)
  • Flash memory
  • 8 MB (MICRON MT28F640J3)
  • Ethernet interface
  • 10-BaseT (10 Mb/s) and 100-BaseT (100 Mb/s) Ethernet Media Access Controller (MAC)
  • MICREL KS8721BL
  • 5 Universal asynchronous receiver/transmitter (UART)
  • USB host and USB device connectors
  • SD/MMC slot
  • 1 Push button : 1 reset

La carte cible possède donc :

  • 8 Mo de mémoire Flash : on y mettra le bootloader u-boot, le noyau Linux et le système de fichiers root.
  • 32 Mo de RAM SDRAM.


 at91_carte.jpg
 
Le mapping mémoire externe de la carte cible est le suivant :

at91_mapping.jpg
 
On notera que :

  • La mémoire RAM va de $2000 0000 à $21FF FFFF (Chip Select 1).
  • La mémoire Flash contenant u-boot (et éventuellement le noyau Linux et le système de fichiers root) va de $1000 0000 à $107F FFFF (Chip Select 0).


Le processeur AT91 possède une MMU (Memory Management Unit) qui protège les accès mémoire. On utilisera donc le noyau Linux standard pour processor ARM9 de type v4T.

Suite au prochain billet...

++

mini2440. Séance 8 : bilan... provisoire

Patrice Kadionik

Salut.

Pour cette séance 8 de mise en oeuvre de la carte mini2440, nous allons faire un bilan provisoire...

Nous avons pu voir au cours de 7 séances la construction détaillée et pas à pas d'un système Linux embarqué pour la carte mini2440 :

  • Séance 1 : mise en place de l'environnement de compilation croisée
  • Séance 2 : compilation et programmation du bootloader u-boot
  • Séance 3 : construction d'un système de fichiers root minimal
  • Séance 4 : configuration et compilation de busybox
  • Séance 5 : configuration et compilation du noyau Linux
  • Séance 6 : configuration et compilation de la bibliothèque tslib pour l'écran tactile
  • Séance 7 : configuration et compilation de Qt

La carte mini2440 offre d'autres ressources à explorer comme les GPIO, l'I2C, le SPI..., ce qui fera l'objet d'autres futurs billets.

Ces 7 séances doivent vous permettre maintenant dappréhender sereinement l'environnement Linux embarqué pour cette carte cible.

Une phase d'optimisation est de diminuer le temps de boot. Cela fera l'objet d'un prochain billet pour donner des références sur cet exercice particulier...

++

mini2440. Séance 7 : configuration et compilation de Qt/embedded

Patrice Kadionik

Salut.

Pour cette séance 7 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler Qt pour la carte mini2440. Nous avons ici utilisé un écran 7" de type A70. Qt utilise la bibliothèque tslib précédemment compilée.

On installe dans un premier temps les sources de Qt disponibles ici :

$ cd mini2440
$ tar -xvzf qt-everywhere-opensource-src-4.7.3.tar.gz

On configurera Qt avec le shell script goconfig :

$ cd qt-everywhere-opensource-src-4.7.3 
$ unset $CC
$ unset $CROSS_COMPILE
$ cat goconfig
./configure \
-embedded arm \
-xplatform qws/linux-arm-g++ \
-prefix /usr/local/qt \
-qt-mouse-tslib \
-little-endian
$ ./goconfig

On notera que linstallation ne se fera pas directement dans le système de fichiers root sous root_fs/ mais dans le répertoire absolu /usr/local/qt/ du PC hôte. Il faut procéder comme cela car Qt/embedded aura codé en dur ces chemins absolus et lon ne peut pas avoir un chemin en /home/… sous peine de non fonctionnement.

Il convient de modifier le fichier qt-everywhere-opensource-src-4.7.3/mkspecs/qws/linux-arm-g++/qmake.conf en suivant les indications dans le document Upgrade Qt4.6.2 in mini2440. On obtient au final le fichier qt-everywhere-opensource-src-4.7.3/mkspecs/qws/linux-arm-g++/qmake.conf suivant.

On compilera Qt avec le shell script go :

$ cat go
make
$ unset $CC
$ unset $CROSS_COMPILE
$ ./go

La compilation prend plusieurs dizaines de minutes… Il faut prendre garde à bien supprimer les variables denvironnement  $CC et $CROSS_COMPILE que l'on avait définies lors de la séance 1.

On installera Qt avec le shell script goinstall sous /usr/local/qt/ du PC hôte en étant superutilisateur :

$ cat goinstall
make install
$ su
# ./goinstall

Qt sera installé dans le système de fichiers root sous root_fs/ : cp -r /usr/local/qt/lib/* ./root_fs/usr/local/qt/lib/

Il faut au préalable configurer des variables denvironnement pour Qt en plus de celles pour tslib comme on a pu le voir lors de la séance 6. On placera ces variables denvironnement dans le fichier root_fs/etc/init.d/rcS :

# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

# Set Qt environment
export QWS_MOUSE_PROTO=tslib:/dev/input/event0
# Ecran 7" A70
export QWS_DISPLAY=LinuxFB:mmWidth=310:mmHeight=190
# Ecran 3"1/2 T35 #export QWS_DISPLAY=LinuxFB:mmWidth=160:mmHeight=100
export QWS_SIZE=800x480
export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib
export QTDIR=/usr/local/qt

if [ -f /etc/pointercal ]; then
echo "Touchscreen already calibrated..."
else
echo "Calibrating Touchscreen..."
/usr/local/tslib/bin/ts_calibrate
fi

On placera aussi ces variables denvironnement dans le fichier root_fs/etc/profile pour quelles soient renseignées quand on accède au shell Linux de la carte mini2440 :

$ cat root_fs/etc/profile
USER="`id -un`"
LOGNAME=$USER
PS1='[\u@\h \W]\# '

# PATH
PATH=/usr/local/jamvm/bin:/usr/local/tslib/bin/:$PATH
HOSTNAME=`/bin/hostname`
export USER LOGNAME PS1 PATH HOSTNAME

# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

# Set Qt environment
export QWS_MOUSE_PROTO=tslib:/dev/input/event0
# Ecran 3"1/2 T35 #export QWS_DISPLAY=LinuxFB:mmWidth=160:mmHeight=100
# Ecran 7" A70 export QWS_DISPLAY=LinuxFB:mmWidth=310:mmHeight=190
export QWS_SIZE=800x480

export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib
export QTDIR=/usr/local/qt

Le test de fonctionnement de Qt a été réalisé sur la carte mini2440 avec le système de fichiers root complet mis à jour en utilisant lapplication de démonstration Nokia patientcare exécutée sur la carte mini2440 :

# ./patientcare –qws

08-07-11_1749.jpg

28-06-11_1442.jpg

Il faut noter que l'on utilise ici le framebuffer qui a été validé lors de la configuration du noyau Linux...

Nous avons donc au final un système Linux embarqué opérationnel et minimal pour la carte mini2440 avec Qt et tslib pour pouvoir utiliser l'écran tactile (A70 pour ces séances).

Prochaine séance : petit bilan sur la mise en oeuvre de la carte mini2440...

++

Sources :

mini2440. Séance 6 : configuration et compilation de la bibliothèque tslib pour l'écran tactile

Patrice Kadionik

Salut.

Pour cette séance 6 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler la bibliothèque tslib pour l'écran tactile de la carte mini2440. Nous avons ici utilisé un écran 7" de type A70.

On installe dans un premier temps les sources de tslib :

$ cd mini2440
$ git clone http://github.com/kergoth/tslib.git

On  procédera comme précédemment maintenant. On configurera tslib avec le shell script goconfig :

$ cd tslib
$ cat goconfig
./autogen.sh
./configure --host=arm-none-linux-gnueabi --prefix=/usr/local/tslib --enable-static --enable-shared
$ ./goconfig

On notera que linstallation ne se fera pas directement dans le système de fichiers root sous root_fs/ mais dans le répertoire absolu /usr/local/tslib/ du PC hôte. Il faut procéder comme cela car Qt/embedded aura codé en dur ces chemins absolus et lon ne peut pas avoir un chemin en /home/… comme précédemment sous peine de non fonctionnement.

On compilera tslib avec le shell script go :

$ cat go
make
$ ./go

On installera tslib avec le shell script goinstall sous /usr/local/tslib/ du PC hôte en étant superutilisateur :

$ cat goinstall
make install
$ su
# ./goinstall

tslib sera installé dans le système de fichiers root sous root_fs/ :

$ cd mini2440
$ su
# cp -r /usr/local/tslib/* ./root_fs/usr/local/tslib/
On créera un fichier ts.conf dont le contenu est le suivant que l'on mettra sous ./root_fs/usr/local/tslib/etc :
module_raw input
module pthres pmin=1
module variance delta=30
module dejitter delta=100
module linear
Il faut au préalable configurer des variables denvironnement pour tslib. On placera ces variables denvironnement dans le fichier root_fs/etc/init.d/rcS :
# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib

if [ -f /etc/pointercal ]; then
echo "Touchscreen already calibrated..."
else
echo "Calibrating Touchscreen..."
/usr/local/tslib/bin/ts_calibrate
fi
On placera aussi ces variables denvironnement dans le fichier root_fs/etc/profile pour quelles soient renseignées quand on accède au shell Linux de la carte mini2440 :
PATH=/usr/local/tslib/bin/:$PATH 
HOSTNAME=`/bin/hostname`
export USER LOGNAME PS1 PATH HOSTNAME

# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib
On mettra à jour le système de fichiers root de la carte mini2440 soit en NAND Flash, soit sur la carte SD.
On reboote la carte. Si on lance la commande ts_calibrate, on voit apparaître la fenêtre suivante :
# ts_calibrate

calibrate.png

Il faut noter que l'on utilise ici le framebuffer qui a été validé lors de la configuration du noyau Linux...

Prochaine séance : configuration et compilation de Qt/embedded pour la carte mini2440...

++

Sources :

mini2440. Séance 5 : configuration et compilation du noyau Linux

Patrice Kadionik

Salut.

Pour cette séance 5 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler le noyau Linux qui sera ensuite installé dans la mémoire NAND Flash de la carte mini2440.

On installe dans un premier temps les sources du noyau Linux 2.6.32.2 pour la carte mini2440 ici :

$ cd mini2440
$ tar -xvzf linux-2.6.32.2-mini2440_20110305.tgz

Le noyau Linux est ensuite configuré puis compilé pour la carte mini2440.

On se placera dans le répertoire des sources du noyau. On créera au préalable le lien symbolique kernel :

$ ln -s linux-2.6.32.2 kernel
$ cd kernel


On configurera le noyau Linux avec le shell script goconfig :

$ cd kernel
$ cat goconfig
make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- menuconfig
$ ./goconfig


Le fichier de configuration est sauvegardé dans le fichier .config. On pourra utiliser les fichiers config suivants adaptés à la carte mini2440 que l'on recopiera en lieu et place du fichier .config (il existe des fichiers de configuration par défaut config_mini2440_* correspondant à différents types d'écrans LCD sous kernel/) :


On compile le noyau Linux avec le shell script go :

$ cat go
make -j4 ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi-
make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- uImage
$ ./go


On compile les modules éventuels du noyau Linux avec le shell script gomodules :

$ cat gomodules 
ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- make modules
$ ./gomodules


1.2.    Installation

On installera les modules du noyau Linux avec le shell script gomodules_install dans le système de fichiers root (répertoire root_fs/)  :

$ cat gomodules_install
make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- INSTALL_MOD_PATH=/home/eddy33/mini2440/root_fs modules_install
$ ./gomodules_install


On ajustera au préalable la variable INSTALL_MOD_PATH vers le chemin absolu du répertoire root_fs/ en fonction de son environnement de développement sur le PC hôte.

Il faudra bien sûr alors mettre à jour son système de fichiers root installé dans la mémoire NAND Flash ou sur la carte SD de la carte mini2440...

On installera le noyau Linux via le fichier uImage avec le shell script goinstall :

$ cat goinstall
cp arch/arm/boot/uImage /tftpboot
$ ./goinstall


Le noyau Linux uImage est installé dans le répertoire /tftpboot/. Il sera téléchargé via le protocole TFTP en RAM avec u-boot puis programmé dans la partition MTD 2 de la mémoire NAND Flash avec u-boot.

On télécharge donc le fichier uImage depuis u-boot en RAM de la carte mini2440 puis on le programme dans la partition MTD 2 de la mémoire NAND Flash. On suppose que le PC hôte a comme adresse IP 192.168.0.1 et la carte mini2440 a comme adresse IP 192.168.0.100. On configurera u-boot en conséquence :

MINI2440 # setenv netmask 255.255.255.0
MINI2440 # setenv ipaddr 192.168.0.100
MINI2440 # setenv serverip 192.168.0.1
MINI2440 # saveenv
MINI2440 # tftp 32000000 uImage
dm9000 i/o: 0x20000300, id: 0x90000a46
DM9000: running in 16 bit mode
MAC: 08:08:11:18:12:27
TFTP from server 192.168.0.1; our IP address is 192.168.0.100
Filename 'uImage'.
Load address: 0x32000000
Loading: T #################################################
###################################################
done
Bytes transferred = 2058212 (1f67e4 hex)
MINI2440 # nand erase kernel
MINI2440 # nand write.e 0x32000000 kernel

On pourra éventuellement créer la macro u-boot gokernel pour faciliter les prochaines programmations :

MINI2440 # setenv gokernel tftp 32000000 uImage\;nand erase kernel\;nand write.e 0x32000000 kernel
MINI2440 # saveenv

La programmation du fichier uImage se fera alors simplement par la commande u-boot :

MINI2440 # run gokernel

On précise enfin la variable u-boot bootargs qui correspond aux paramètres passés au noyau Linux :

MINI2440 # setenv bootargs root=/dev/mtdblock3 rootfstype=jffs2 console=ttySAC0,115200 mini2440=1tb rootnowait 
MINI2440 # saveenv

On rappelle que le paramètre mini2440 précise la taille de l'écran LCD :

  • mini2440=0tb : écran 3"1/2
  • mini2440=1tb : écran 7"


On fait un reset de la carte mini2440. On doit avoir les traces de boot du noyau Linux (qui ne trouve pas encore son système de fichiers root…) :

## Booting kernel from Legacy Image at 32000000 ...
Image Name: Linux-2.6.32.2
Created: 2011-06-24 11:33:32 UTC
Image Type: ARM Linux Kernel Image (uncompressed)
Data Size: 2058148 Bytes = 2 MB
Load Address: 30008000
Entry Point: 30008000
Verifying Checksum ... OK
Loading Kernel Image ... OK
OK
Starting kernel                                                                             
Uncompressing Linux.............................................................
Linux version 2.6.32.2 (kadionik@ipcchip) (gcc version 4.3.2 (Sourcery G++ Lite1
CPU: ARM920T [41129200] revision 0 (ARMv4T), cr=c0007177
CPU: VIVT data cache, VIVT instruction cache
Machine: FriendlyARM Mini2440 development board
Memory policy: ECC disabled, Data cache writeback
CPU S3C2440A (id 0x32440001)
S3C24XX Clocks, (c) 2004 Simtec Electronics
S3C244X: core 405.000 MHz, memory 101.250 MHz, peripheral 50.625 MHz
CLOCK: Slow mode (1.500 MHz), fast, MPLL on, UPLL on
. . .

On a alors accès au login. Cela valide ainsi toutes ces 5 séances. Nous avons au final un système Linux embarqué opérationnel sur la carte mini2440

Prochaine séance : configuration et compilation de la bibliothèque tslib pour l'écran tactile de la carte mini2440...

++

Sources :

  • Sources du noyau 2.6.32.2 pour la carte mini2440

mini2440. Séance 4 : configuration et compilation de busybox

Patrice Kadionik

Salut.

Pour cette séance 4 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler busybox qui sera ensuite installé dans le système de fichiers root.

Busybox est LE couteau suisse quand on fait du Linux embarqué ! Il permet à l'aide d'un seul exécutable d'avoir accès à un ensemble configurable de commandes Linux. Chaque commande est un lien symbolique vers l'exécutable busybox : on exploite ainsi dans les sources C de busybox l'argument argv[0]...

On installe dans un premier temps les sources de busybox disponibles ici :

$ cd mini2440
$ tar -xvzf linux-busybox-mini2440-1.13.3.tgz
$ cd busybox-1.13.3

La configuration par défaut correspond au shell script godefconfig :

$ cd busybox-1.13.3
$ cat godefconfig
cp fa.config .config

On pourra éventuellement configurer busybox avec le shell script goconfig afin de sélectionner les commandes Linux (applets) que l'on veut en plus :

$ cat goconfig
make ARCH=arm CC=arm-linux-gcc menuconfig
$ ./goconfig

On compilera busybox avec le shell script go :

$ cat go
make ARCH=arm CC=arm-linux-gcc
$ ./go

On installera busybox avec le shell script goinstall dans le système de fichiers root que l'on a construit lors de la séance 3 (répertoire root_fs/)  :

$ cat goinstall
make ARCH=arm CC=arm-linux-gcc CONFIG_PREFIX=/home/eddy33/mini2440/root_fs install
$ su
# ./goinstall

On ajustera au préalable la variable CONFIG_PREFIX vers le chemin absolu du répertoire root_fs/ en fonction de son environnement de développement sur le PC hôte.

Notre système de fichiers root est presque opérationnel. Il reste à rajouter les bibliothèques pour le processeur ARM :

$ cd mini2440
$ su
# \cp -a ./arm-2008q3/arm-none-linux-gnueabi/libc/armv4t/lib/* ./root_fs/lib
# \cp ./arm-2008q3/arm-none-linux-gnueabi/libc/armv4t/usr/lib/* ./root_fs/usr/lib

Il manque éventuellement les modules Linux et le firmware des périphériques à rajouter sous root_fs/lib (on verra cela à la prochaine séance) mais le système de fichiers root sous root_fs/ doit être utilisable en l'état...

Les tests peuvent se faire en utilisant le système de fichiers root ainsi créé soit en mémoire NAND flash (partition MTD 3), soit sur la carte SD.

Pour mettre le système de fichiers root en mémoire NAND Flash de la carte mini2440, il faut au préalable le convertir en système de fichiers de type JFFS2. On utilisera la commande mkfs.jffs2. On utilisera le shell script gojffs2 :

$ cd mini2440
$ cat gojffs2
mkfs.jffs2 -lqnp -e 16 -r ./root_fs -o rootfs.jffs2
cp rootfs.jffs2 /tftpboot
$ su
# ./gojffs2
On suppose que le PC hôte a comme adresse IP 192.168.0.1 et la carte mini2440 a comme adresse IP 192.168.0.100. On configurera u-boot en conséquence :
MINI2440 # setenv netmask 255.255.255.0
MINI2440 # setenv ipaddr 192.168.0.100
MINI2440 # setenv serverip 192.168.0.1
MINI2440 # saveenv
On utilisera ensuite u-boot pour télécharger par TFTP le fichier image JFFS2 rootfs.jffs2 puis on le programmera dans la partition MTD 3 de la mémoire NAND Flash :
MINI2440 # tftp 32000000 rootfs.jffs2
MINI2440 # nand erase rootfs
MINI2440 # nand write.jffs2 32000000 rootfs $(filesize)

On pourra éventuellement créer la macro u-boot gorootfs pour faciliter les prochaines programmations :

MINI2440 # setenv gorootfs tftp 32000000 rootfs.jffs2\;nand erase rootfs\;nand write.jffs2 32000000 rootfs \$(filesize)
MINI2440 # saveenv

La programmation du fichier rootfs.jffs2 se fera alors simplement par la commande u-boot :

MINI2440 # run gorootfs

Pour recopier le système de fichiers root sur la carte SD, on utilisera le shell script gosd. On branchera au préalable un lecteur de cartes SD sur le PC hôte, la carte SD sera enfichée dans le lecteur.

Pour la première fois, la carte SD sera formatée au format ext3. On suppose que la carte SD est vue comme le périphérique /dev/sde :

$ cd mini2440
$ su
# fdisk -l
# fdisk /dev/sde
Command (m for help): n
Command action
e extended
p primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-1016, default 1):
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-1016, default 1016):
Using default value 1016
Command (m for help): w
The partition table has been altered!
Calling ioctl() to re-read partition table.
Syncing disks.
# mkfs.ext3 /dev/sde1

On copiera ensuite le répertoire root_fs/ sur la carte SD ainsi formatée à laide du shell script gosd :

# cat gosd
umount /dev/sde1
mount -t ext3 /dev/sde1 /mnt
\rm -rf /mnt/*
sync
\cp -r root_fs/* /mnt
sync
umount /dev/sde1
# ./gosd

Pour utiliser le système de fichiers root en mémoire NAND Flash, on configurera u-boot comme suit :

MINI2440 # setenv boot_nand setenv bootargs root=/dev/mtdblock3 rootfstype=jffs2 mini2440=1tb console=tty0,115200 console=ttySAC0,115200 rootwait \; nboot.e kernel \; bootm
MINI2440 # setenv bootcmd run boot_nand
MINI2440 # saveenv

Pour utiliser le système de fichiers root sur la carte SD, on configurera u-boot comme suit :

MINI2440 # setenv boot_sd setenv bootargs console=tty0,115200 console=ttySAC0,115200 mini2440=1tb rootfstype=ext3 root=/dev/mmcblk0p1 rw rootwait \; nboot.e kernel \; bootm
MINI2440 # bootcmd run boot_sd
MINI2440 # saveenv

Il faut noter que le paramètre mini2440 précise la taille de l'écran LCD :

  • mini2440=0tb : écran 3"1/2
  • mini2440=1tb : écran 7"

On pourra tester notre système de fichiers root une fois que l'on aura un noyau Linux opérationnel pour la carte mini2440, ce qui sera expliqué à la prochaine séance.

Prochaine séance : configuration et compilation du noyau Linux pour la carte mini2440...

++

Sources :

mini2440. Séance 3 : construction d'un système de fichiers root minimal

Patrice Kadionik

Salut.

Pour cette séance 3 de mise en oeuvre de la carte mini2440, nous allons voir comment construire un système de fichiers root minimal.

Avoir un système de fichiers root est indispensable pour avoir un noyau Linux fonctionnel car l'un ne marche pas sans l'autre. Le système de fichiers root peut être local en RAM, en mémoire NAND Flash ou sur la carte SD pour la carte mini2440 ou bien distant monté par NFS. Le choix se fera par des paramètres passés au boot du noyau Linux, paramètres sauvegardés comme variables d'environnement (setenv) du bootloader u-boot.

Pour construire le système de fichiers root, on doit respecter le standard FHS (Filesystem Hierarchy Standard) dont la structure globale est la suivante :

rootfs (/)
|--bin
|--dev
|--etc
| |--init.d
|--lib
|--mnt
|--proc
|--sys
|--sbin
|--tmp
|--usr
| |--bin
| |--sbin
|--var

Nous allons donc construire le système de fichiers root en s'aidant du document Build Root File System...

Tout sera mis dans le répertoire root_fs/ :

$ cd mini2440
$ mkdir root_fs

Le système de fichiers root ainsi construit sera minimal (et non opérationnel) car cela ne sera qu'un squelette qu'il faudra compléter avec busybox, avec les bibliothèques dynamiques pour le processeur ARM sous root_fs/lib/ ainsi qu'éventuellement les modules du noyau Linux. On verra cette étape à la prochaine séance consacrée à busybox...

On crée les répertoires de base :

$ cd root_fs
$ mkdir dev
$ mkdir -p etc/init.d
$ mkdir lib
$ mkdir mnt
$ mkdir proc
$ mkdir sys
$ mkdir -m 777 tmp
$ mkdir var

On crée l'entrée console sous root_fs/dev/ :

$ cd root_fs/dev
$ su
# mknod -m 622 console c 5 1

Les principaux fichiers de configuration, notamment ceux qui seront utilisés par busybox sont sous root_fs/etc/.

On créera le fichier root_fs/etc/inittab utilisé par le processus init dont le contenu est le suivant :

::sysinit:/etc/init.d/rcS
::askfirst:-/bin/sh
::ctrlaltdel:/sbin/reboot
::shutdown:/bin/umount -a -r
::shutdown:/sbin/swapoff -a
::restart:/sbin/init
#::respawn:/sbin/getty -L 115200 /dev/ttySAC0 vt100
console::respawn:/sbin/getty -L 9600 tty0 vt100

On créera le fichier root_fs/etc/init.d/rcS, shell script exécuté après le lancement du processus init dont le contenu est le suivant :

#! /bin/sh

# Setup the bin file location and export to system PATH
PATH=/sbin:/bin:/usr/sbin:/usr/bin
umask 022
export PATH

# mount the filesystem directories
mount -a
mkdir /dev/pts
mount -t devpts devpts /dev/pts -o mode=0622

# create device nodes and directories
echo /sbin/mdev>/proc/sys/kernel/hotplug
mdev -s
mkdir /var/lock

# start logging utility services
klogd
syslogd

# set system clock from RTC
hwclock -s

# set host and config loopback interface
ifconfig lo 127.0.0.1
ifconfig eth0 192.168.0.100

On créera le fichier root_fs/etc/mdev.conf pour le processus mdev de création dynamique des points d'entrée sous /dev dont le contenu est le suivant :

# system all-writable devices
full 0:0 0666
null 0:0 0666
ptmx 0:0 0666
random 0:0 0666
tty 0:0 0666
zero 0:0 0666

# console devices
tty[0-9]* 0:5 0660
vc/[0-9]* 0:5 0660

# serial port devices
s3c2410_serial0 0:5 0666 =ttySAC0
s3c2410_serial1 0:5 0666 =ttySAC1
s3c2410_serial2 0:5 0666 =ttySAC2
s3c2410_serial3 0:5 0666 =ttySAC3

# loop devices
loop[0-9]* 0:0 0660 =loop/

# i2c devices
i2c-0 0:0 0666 =i2c/0
i2c-1 0:0 0666 =i2c/1

# frame buffer devices
fb[0-9] 0:0 0666

# input devices
mice 0:0 0660 =input/
mouse.* 0:0 0660 =input/
event.* 0:0 0660 =input/
ts.* 0:0 0660 =input/

# rtc devices
rtc0 0:0 0644 >rtc
rtc[1-9] 0:0 0644

# misc devices
#mmcblk0p1 0:0 0600 =sdcard */bin/hotplug
#sda1 0:0 0600 =udisk * /bin/hotplug

On créera le fichier root_fs/etc/fstab pour le montage des divers systèmes de fichiers (virtuels) dont le contenu est le suivant :

# device mount-point type options dump fsck order
proc /proc proc defaults 0 0
sysfs /sys sysfs defaults 0 0
tmpfs /dev tmpfs defaults 0 0
tmpfs /tmp tmpfs defaults 0 0
var /var tmpfs defaults 0 0

On créera le fichier root_fs/etc/profile qui est exécuté quand on se connecte au système dont le contenu est le suivant :

USER="`id -un`"                                                 
LOGNAME=$USER
PS1='[\u@\h \W]\# '
PATH=$PATH
HOSTNAME=`/bin/hostname`
export USER LOGNAME PS1 PATH HOSTNAME

On créera le fichier root_fs/etc/issue qui contient le message de bienvenue dont le contenu est le suivant :

Welcome to Mini2440
Kernel \r on an \m (\l)
On créera le fichier root_fs/etc/passwd avec un seul utilisateur, root dont le contenu est le suivant :
root::0:0:root:/:/bin/sh
On créera le fichier root_fs/etc/group dont le contenu est le suivant :
root:x:0:root
Enfin, nous réajustons les droits attribués à root du répertoire root_fs/ qui sera recopié soit sur une carte SD, soit transformé en fichier image JFFS2 :
$ cd mini2440
$ su
# chown -R root:root root_fs
$
Nous en avons fini avec ce système de fichiers root minimal. Il n'est pas encore opérationnel car il convient de le compléter avec :
  • busybox
  • Les bibliothèques pour processeur ARM
  • les modules du noyau Linux ainsi que les firmwares si nécessaire

Le résultat de la construction de ce système de fichiers root est disponible ici.


Prochaine séance : compilation et mise en oeuvre de busybox et intégration dans le système de fichiers root minimal...

++

Sources :

mini2440. Séance 2 : compilation et programmation du bootloader u-boot

Patrice Kadionik

Salut.

Pour cette séance 2 de mise en oeuvre de la carte mini2440, nous allons voir comment compiler et installer le bootloader u-boot en mémoire NAND Flash de la carte.

u-boot est un moniteur spécialisé pour Linux embarqué qui possède, outre les fonctionnalités d'un moniteur classique, les capacités de récupérer un noyau Linux généralement stocké en mémoire Flash et passer des arguments au noyau Linux avant de le lancer. Le système de fichiers root peut être en mémoire Flash, sur carte SD, en mémoire RAM ou bien monté par NFS via le réseau...

On installera les sources d'u-boot pour la carte mini2440  : 

$ cd mini2440
$ mkdir u-boot
$ cd u-boot $ git clone git://repo.or.cz/u-boot-openmoko/mini2440.git
$ cd u-boot
$ mv mini2440/* .
$ mv mini2440/.* .
$ rmdir mini2440

Le fichier shell script go suivant permet d'automatiser la procédure de compilation :

$ cat go
make mini2440_config
make

La compilation croisée d'u-boot se fera par :

$ ./go

J'utiliserai par la suite pour les séances suivantes le principe des shell scripts goxxx pour automatiser un peu les choses :

  • goclean : script de nettoyage
  • goconfig : script de configuration
  • go : script de compilation croisée
  • goinstall : script d'installation

Après compilation croisée, on récupère le fichier binaire u-boot.bin à programmer dans la mémoire NAND Flash.


La procédure dinstallation est décrite dans le document HOWTO: Compiling and Flashing U-Boot onto Mini2440.
Le fichier u-boot.bin généré ne sexécute pas correctement directement en mémoire RAM et on appliquera le contournement décrit dans le document en le programmant une première fois en mémoire NAND Flash pour partitionner la mémoire NAND Flash et détecter les bad blocs puis en le reprogrammant une deuxième fois :

  • 1. Switch the system to NOR and boot with supervivi
  • 2. hit v in supervivi
  • 3. i uploaded the u-boot.bin file
  • 4. switch the system to NAND and boot up with u-boot. You'll get some errors
  • 5. Run nand scrubs and createbbt
  • 6. switch back to NOR
  • 7. hit v again and upload U-boot since you just erased it
  • 8. switch back to nand and it should boot up with minimal errors using u-boot
  • 9. run the dynpart and dynenv and saveenv as mentioned above


On suit donc la procédure. La carte mini2440 est en position NOR. On fait un reset de la carte.
On accède au moniteur supervivi préprogrammé en mémoire NOR Flash que lon conservera et que lon neffacera pas en utilisant loutil minicom configuré en 115200,8,N,1. Loutil minicom permet daccéder au port série de la carte mini2440 :
Le paramètre 239636 correspond à la taille du fichier u-boot.bin :

$ su
# minicom
##### FriendlyARM BIOS 2.0 for 2440 #####
[x] format NAND FLASH for Linux
[v] Download vivi
[k] Download linux kernel
[y] Download root_yaffs image
[a] Absolute User Application
[n] Download Nboot for WinCE
[l] Download WinCE boot-logo
[w] Download WinCE NK.bin
[d] Download & Run
[z] Download zImage into RAM
[g] Boot linux from RAM
[f] Format the nand flash
[b] Boot the system
[s] Set the boot parameters
[u] Backup NAND Flash to HOST through USB(upload)
[r] Restore NAND Flash from HOST through USB
[q] Goto shell of vivi
[i] Version: 1026-2K
Enter your selection: v
Supervivi> load flash 0 239636 u
USB host is connected. Waiting a download.
Now, Downloading [ADDRESS:30000000h,TOTAL:239646]
RECEIVED FILE SIZE:  239646 (234KB/S, 1S)
Downloaded file at 0x30000000, size = 239636 bytes
Found block size = 0x00040000
Erasing... ... done
Writing... ... done
Written 239636 bytes
Supervivi>


On connecte ensuite un câble USB entre le port device de la carte mini2440 et le PC de développement. Dans une autre fenêtre, on lance l'outil s3c2410_boot_usb disponible ici pour télécharger le fichier u-boot.bin :

$ cd u-boot
$ su
# ./s3c2410_boot_usb u-boot.bin
csum = 0xf15c
send_file: addr = 0x33f80000, len = 0x0003a814
Sending Chunks...........................................................
Sent: 239636 bytes
Downloading complete, no errors


Le bootloader Linux u-boot est programmé en mémoire NAND Flash. La carte mini2440 est en position NAND Flash. On fait un reset de la carte. On boote la carte mini2440 avec u-boot. On appuie sur une touche puis on effectue les opérations suivantes :

MINI2440 # nand info
MINI2440 # nand erase clean
MINI2440 # nand nand protect off
MINI2440 # nand scrub
MINI2440 # nand createbbt
MINI2440 # dynpart
mtdparts mtdparts=mini2440-nand:0x00040000(u-boot),0x00020000(u-boot_env),0x005)
MINI2440 # dynenv set u-boot_env
MINI2440 # saveenv
Saving Environment to NAND...
Erasing Nand...Writing to Nand... done
MINI2440 #


Lopération createbbt de création de la table des bad blocs prend 15 minutes avec la mémoire NAND Flash de 1Go. Il convient dattendre la fin de lopération patiemment…
Ces opérations ont effacé u-boot de la mémoire NAND Flash quil convient ensuite de reprogrammer une deuxième fois comme précédemment.
Une fois cette deuxième programmation du-boot réalisée, le bootloader Linux est définitivement installé sur la carte mini2440. On recommencera l'opération (dynpart, dynenv, saveenv) pour éviter l'erreur de CRC. Il ne reste plus quà configurer correctement u-boot comme on le verra plus tard…


La carte mini2440 est en position NAND. On fait un reset de la carte. On doit accéder au prompt du-boot :

U-Boot 1.3.2-mini2440 (Jun 23 2011 - 17:58:29)

I2C: ready
DRAM: 64 MB
NOR Flash not found. Use hardware switch and 'flinit'
Flash: 0 kB
NAND: 1024 MiB
Found Environment offset in OOB..
USB: S3C2410 USB Deviced
In: serial
Out: serial
Err: serial
MAC: 08:08:11:18:12:27
Hit any key to stop autoboot: 0
MINI2440 # dynpart
mtdparts mtdparts=mini2440-nand:0x00040000(u-boot),0x00020000(u-boot_env),0x005)
MINI2440 # dynenv set u-boot_env
MINI2440 # saveenv
Saving Environment to NAND...
Erasing Nand...Writing to Nand... done
MINI2440 #
MINI2440 # mtdparts

device nand0 <mini2440-nand>, # parts = 4
#: name size offset mask_flags
0: u-boot 0x00040000 0x00000000 0
1: env 0x00020000 0x00040000 0
2: kernel 0x00500000 0x00060000 0
3: root 0x3faa0000 0x00560000 0

active partition: nand0,0 - (u-boot) 0x00040000 @ 0x00000000

defaults:
mtdids : nand0=mini2440-nand
mtdparts: <NULL>


Des partitions MTD ont été créées par défaut dans la mémoire NAND Flash :

  • Partition MTD 0 : contient u-boot
  • Partition MTD 1 : contient les paramètres de configuration du-boot
  • Partition MTD 2 : pourra accueillir le noyau Linux
  • Partition MTD 3 : pourra accueillir un système de fichiers root utilisant le système de fichiers JFFS2


On installera donc le noyau Linux dans la partition MTD 2. Le système de fichiers root pourra être installé dans la partition MTD 3 ou bien être installé sur la carte SD. Le choix se fera en configurant correctement u-boot comme présenté plus tard dans une autre séance…

A partir de maintenant, la carte mini2440 reste en position NAND Flash. Nous avons maintenant un bootloader u-boot sur la carte mini2440 parfaitement opérationnel !

Prochaine séance : création d'un système de fichiers root minimal...

++

Sources :

mini2440. Séance 1 : mise en place de l'environnement de compilation croisée

Patrice Kadionik

Pour cette séance 1 d'une série de séances consacrées à la carte mini2440, il convient d'abord de mettre en place l'environnement de compilation croisée.

Il est possible d'utiliser buildroot pour se construire sa distribution Linux embarqué pour la carte mini2440. En tant que vieux geek de l'embarqué, je préfère construire ma propre distribution pour mini2440 par intégration des seuls paquetages m'intéressant.

La première chose est de se créer son répertoire de travail mini2440-bootstrap/ ainsi que le lien symbolique mini2440 :

$ mkdir mini2440-bootstrap
$ ln -s mini2440-bootstrap mini2440

On se placera par la suite pour toutes les séances à venir dans le répertoire mini2440/.

$ cd mini2440

On installera le compilateur croisé pour processeur ARM disponible ici :

$ wget
http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2
$ tar -xvjf arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2
$ ls arm-2008q3
arm-none-linux-gnueabi bin lib libexec share

On ajustera son fichier ~/.bash_profile en rajoutant les lignes suivantes :

# Linux ARM920T mini2440
PATH=$HOME/mini2440-bootstrap/arm-2008q3/bin:$PATH
export PATH
CROSS_COMPILE=arm-none-linux-gnueabi-
CC="${CROSS_COMPILE}gcc -march=armv4t -mtune=arm920t"
export CROSS_COMPILE
export CC

On prend en compte ces modifications :

$ source ~/.bash_profile

et l'on vérifie que le compilateur croisé est opérationnel :

$ arm-none-linux-gnueabi-gcc -v
Using built-in specs.
Target: arm-none-linux-gnueabi
Configured with: /scratch/julian/lite-respin/linux/src/gcc-4.3/configure --build=i686-pc-linux-gnu 
--host=i686-pc-linux-gnu --target=arm-none-linux-gnueabi --enable-threads --disable-libmudflap --disable-libssp
--disable-libstdcxx-pch --with-gnu-as --with-gnu-ld --enable-languages=c,c++ --enable-shared --enable-symvers=gnu
--enable-__cxa_atexit --with-pkgversion='Sourcery G++ Lite 2008q3-72'
--with-bugurl=https://support.codesourcery.com/GNUToolchain/ --disable-nls --prefix=/opt/codesourcery
--with-sysroot=/opt/codesourcery/arm-none-linux-gnueabi/libc
--with-build-sysroot=/scratch/julian/lite-respin/linux/install/arm-none-linux-gnueabi/libc
--with-gmp=/scratch/julian/lite-respin/linux/obj/host-libs-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu/usr
--with-mpfr=/scratch/julian/lite-respin/linux/obj/host-libs-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu/usr
--disable-libgomp --enable-poison-system-directories
--with-build-time-tools=/scratch/julian/lite-respin/linux/install/arm-none-linux-gnueabi/bin
--with-build-time-tools=/scratch/julian/lite-respin/linux/install/arm-none-linux-gnueabi/bin Thread model: posix gcc version 4.3.2 (Sourcery G++ Lite 2008q3-72)


Prochaine séance : compilation et mise en place du bootloader u-boot sur la carte mini2440...

++

Sources :

mini2440 : lancement d'un concours de go fast...boot !

Patrice Kadionik

Salut.

La société Open Wide Ingénierie, via son blog linuxembedded.fr sur les technologies libres et embarquées, a lancé ce 2 août un concours d'optimisation du temps de démarrage sur carte mini2440.

Il s'agit d'avoir le temps de démarrage le plus faible possible jusqu'au lancement d'une application graphique sur l'écran associé de la carte mini2440. C'est un challenge intéressant et il existe encore peu de littérature sur ce sujet actuellement. Je signalerais éventuellement plus tard quelques documentations "utiles"...

Avant d'optimiser son "fast boot", il convient d'avoir un environnement complet de développement croisé pour la carte mini2440... Comme je l'avais signalé dans mon précédent billet, cela fera l'objet des billets à venir qui auront ainsi toute leur utilité ;-)" class="smiley

Inscription au concours ici : http://www.linuxembedded.fr/concours/wiki/doku.php/participants

Bonne chance !

++

Sources :

Présentation de la carte mini2440

Patrice Kadionik

Salut.

Dans le cadre d'un projet, j'ai mis en oeuvre la carte mini2440 : http://www.friendlyarm.net/products/mini2440

Cette carte est très intéressante pour faire du Linux embarqué. Aussi, à travers une série de billets, je décrirai la mise en place d'u-boot, de Linux embarqué, de busybox, de Qt/embedded...

La carte mini2440 est basée sur un microprocesseur Samsung S3C2440 (ARM920T). Elle possède les caractéristiques suivantes :

  • Processeur : Samsung S3C2440A à 400MHz Main frequency, 533Mhz Peak Frequency.
  • Mémoire SDRAM : 64 Mo.
  • Mémoire Flash : 64Mo de  NAND Flash et 2Mo NOR Flash.
  •  Module LCD : version 7 choisie avec écran tactile.
  • Ressources et interfaces :

o       Ethernet 100M/s RJ-45 (DM9000).

o       3 ports série.

o       1 port USB Host

o       1 port USB Slave (B-type).

o       1 interface SD.

o       1 interface stéréo audio, 1interface MIC.

o       1 interface JTAG.

o       4 leds utilisateur.

o       6 buttons utilisateur.

o       1 buzzer.

o       1 résistance ajustable pour les tests de la conversion A/N.

o       1 bus I2C avec une mémoire série AT24C08.

o       1 interface caméra.

o       1 batterie RTC.

o       Alimentation 5V.

  • Interfaces dexpansion :

o       1 interface GPIO 34pin 2.0 mm.

o       1 interface bus système pin 2.0 mm.

  • Dimension : 100 x 100 mm.

mini2440.png

C'est une belle carte pour faire du Linux embarqué ! A suivre...

++

OpenSilicium : le magazine de l'open source pour l'électronique et l'embarqué

Patrice Kadionik

Salut.

Après les succès des hors séries de Linux Magazine sur l'électronique ou l'embarqué, les éditions Diamond ont décidé de lancer un nouveau magazine entièrement consacré à l'open source pour l'électronique et l'embarqué : OpenSilicium.

Ce trimestriel traitera du "développement de lopen source dans le secteur de lembarqué, en particulier dans les domaines de la téléphonie, de lélectronique et de la domotique. Conçu et rédigé par des professionnels de lembarqué à lattention des professionnels et des amateurs « éclairés », le magazine OpenSilicium propose un rédactionnel tourné vers lexpérimentation et la veille technologique concrète."

Le numéro 1 d'OpenSilicium sera dans les kiosques le 24 décembre prochain : un bien beau cadeau de Noël !

++

  • Site d'OpenSilicium

Tablette Internet tactile à 35 dollars !

Patrice Kadionik Salut.

Des chercheurs et entreprises indiennes ont réussi à développer une tablette Internet tactile pour 35 USD !

Superbe prouesse technique pour une tablette avec 2 Go de RAM, Wi-Fi, et ports USB. Le prototype tourne sous GNU/Linux !

++

 

Cours libres de Free Electrons

Patrice Kadionik

Salut.

Les copains de Free Electrons proposent un ensemble de cours libres complets sur Linux en général et Linux embarqué en particulier.

Leur formation Linux embarqué est disponible ici avec l'ensemble des transparents et exercices.

Félicitons cette initiative. Merci Michael et Thomas !

++

Le HS 47 de Linux Magazine est en kiosque !

Patrice Kadionik

Salut.

Le Hors Série 47 de Linux Magazine est en kiosque. Ce numéro est cette fois-ci dévolu à l'électronique et à l'embarqué sous Linux.


Ce numéro où l'on mélange hardware, software et Linux est encore une fois très intéressant. Voici donc son sommaire :

CRÉEZ UNE APPLICATION :

  • p. 4 Ma première application Android – 1ère partie
  • p. 11 Ma première application Android – 2nde partie
  • p. 16 Développez des applications pour Symbian en Python

CONSTRUISEZ UN SYSTÈME :

  • p. 20 Introduction à Buildroot
  • p. 34 Cas pratique dutilisation de Buildroot
  • p. 43 OpenWrt sur ACME Fox
  • p. 48 Mise en œuvre de Linux embarqué sur le processeur softcore libre LEON
DÉVELOPPEZ POUR LE MATÉRIEL :
  • p. 58 Étude dun système dexploitation pour microcontrôleur faible consommation (TI MSP430) : pilote pour le stockage de masse au format FAT sur carte SD
  • p. 78 Le VHDL pour les débutants

Mon collègue et moi proposons l'article sur la mise en oeuvre du processeur softcore libre LEON sous Linux embarqué...

Bonne lecture !

++