Stellaris Luminary Lm3s6965

N'hésitez pas à enrichir cette page

Ce kit est construit autour d'un microcontrolleur ARM Cortex-M3 Lm3s6965 de marque Luminary Micro appartenant au groupe Texas Instrument.

Les principales caratéristiques et intérêts de ce kit sont:


 * Processeur ARM 32bit Cortex-M3
 * Port Ethernet
 * Ecran OLED monochrome 128 x 64 pixels (16 niveaux)
 * Un bon support d'OpenOCD
 * Support de eLua (port du langage de script Lua)

=Ressources=
 * Site officiel du kit Stellaris Luminary Lm3s6965


 * LM3S6965: Tips & Tricks / OpenOCD :


 * Building toolchain and OpenOCD for Stellaris on Linux :


 * Test qemu + arm + gdb + ld ... :


 * ARM Projets divers :


 * Tutorial général: [[Media:Tuto_lm3s6965.pdf]]


 * Le document technique (datasheet) du microcontrolleur Lm3s6965: [[Media:Datasheet-LM3S6965.pdf‎]]

= Exemples d'utilisation =

Les exemples ci-dessus rassemblent un ensemble d'outils et de codes complétant ceux proposé par le constructeur dans une vision opensource. Une image virtuelle est aussi fournie, voir ci-dessous.

=Debut avec la Carte Stellaris=

Pour programmer la carte, il faut tout d'abord installer la chaîne de compilation.

Compilation du toolchain
Suivre Binaire Linux pour récupérer la chaîne de compilation Sourcery G++ Lite. D'autres paquets disponibles sur le site du logiciel

Compilation des exemples
Une fois le toolchain installé, il est intéressant de regarder les fichiers de tests disponible sur le CD d'Installation. L'éxecutable SW-EK-LM3S6965.exe propose un grand nombre de test recompilable à l'aide des fichiers adjacents. Ces codes étant fournis par le constructeur, ce sont eux qui vont valider la bonne émulation de la carte.

Compilation d'exemples plus simples
Les fichiers test-cortex-m3.c, startup_gcc.c et lm3s.ld utilisés ci-aprés sont disponibles dans l'archive: [[Media:Test-cortex-m3.tar]]

Construction de l'exécutable

arm-none-eabi-gcc -c -mcpu=cortex-m3 -mthumb test-cortex-m3.c -o test-cortex-m3.o arm-none-eabi-gcc -c -mcpu=cortex-m3 -mthumb startup_gcc.c -o startup_gcc.o arm-none-eabi-ld -T lm3s.ld startup_gcc.o test-cortex-m3.o -o test-cortex-m3.elf arm-none-eabi-nm test-cortex-m3.elf

Juste pour voir le code déassemblé arm-none-eabi-objdump -d test-cortex-m3.elf

Il faut une version binaire simple à charger et non la version trop riche arm-none-eabi-objcopy -O binary test-cortex-m3.elf test-cortex-m3.bin

Le binaire peut ensuite être placé(flashé) sur la carte avec OpenOCD ou utilisé avec l'émulateur QEMU, voir ci-dessous.

Utilisation avec OpenOCD sous linux
Récupérer le script setup_lm3s6965.sh sur. Ce script va récupérer et compiler openocd. Une copie est disponible [[Media:Setup_lm3s6965.txt]]

sh setup_lm3s6965.txt

Construire et installer le bon pilote FTDI

wget http://www.intra2net.com/en/developer/libftdi/download/libftdi-0.18.tar.gz tar -xzf libftdi-0.18.tar.gz cd libftdi-0.18/ sudo apt-get install libusb-dev ./configure make sudo make install sudo ldconfig
 * 1) install open FTDI drivers

On lance openocd en root

sudo openocd -f /usr/local/share/openocd/scripts/board/ek-lm3s6965.cfg

Et on peut flash le microcontrolleur telnet localhost 4444 halt flash write_image erase /tmp/main.bin 0 reset
 * 1) flash mcu with some code at address 0x00000 and execute

Exemple avec le déboggeur gdb

= Debut avec QEMU =

Compilation et première utilisation
Récupération et compilation du qemu version qemu-0.13.0 wget http://wiki.qemu.org/download/qemu-0.13.0.tar.gz tar zxvf qemu-0.13.0.tar.gz cd qemu-0.13.0 ./configure --target-list=arm-softmmu # On configure pour ne pas tout compiler make

Note : La version qemu-0.14.0 a été réalisée le 18/02/11

Lancement de l'émulation avec qemu (faire crtl a + x pour sortir ou crtl a + c pour accéder au moniteur) ./qemu-0.13.0/arm-softmmu/qemu-system-arm -M lm3s6965evb -nographic -kernel test-cortex-m3.bin Hello world! QEMU 0.13.0 monitor - type 'help' for more information (qemu) quit

Moniteur (console de commande et d'interrogation de Qemu)
Qemu dispose d'un moniteur assez puissant. Utilisez l'option -S pour lancer le moniteur dès le démarrage l'émulation sera alors suspendu, puis faire crtl+a c pour accèder à la console d moniteur

./qemu-0.13.0/arm-softmmu/qemu-system-arm -S -M lm3s6965evb -nographic -kernel test-cortex-m3.bin crtl+a c

(qemu) info roms addr=00000000 size=0x0001e0 mem=rom name="test-cortex-m3.bin" (qemu) info registers R00=000001d0 R01=20000000 R02=0000000a R03=00000000 R04=00000000 R05=00000000 R06=00000000 R07=2000fff0 R08=00000000 R09=00000000 R10=00000000 R11=00000000 R12=00000000 R13=2000fff0 R14=000001c9 R15=00000160 PSR=60000173 -ZC- T svc32

Malheureusement pour une émulation des cpus cortex-M3, l'ensemble des fonctions du moniteur ne sont pas toutes supportées. Par exemple le déassembleur intégré ne décode pas correctement les instructions. Pour aller plus loin, il faut utiliser le déboggeur cf suite.

Qemu et GDB
On peut attaché GDB à Qemu

./qemu/qemu-0.13.0/arm-softmmu/qemu-system-arm -M lm3s6965evb -nographic -monitor null -serial null -semihosting -kernel  /tmp/hello.bin  -S  -gdb tcp::51234

arm-none-eabi-gdb /tmp/hello.axf

(gdb) target remote localhost:51234 ... (gdb) load (gdb) break main (gdb) continue Continuing. Breakpoint 1, 0x000000f4 in main (gdb) stepi 0x00000640 in SysCtlClockSet (gdb) disassemble 0x640 Dump of assembler code for function SysCtlClockSet: 0x00000640 :	ldr	r3, [pc, #308]	; (0x778 ) 0x00000642 :	push	{r4, r5, r6, lr} 0x00000644 :	ldr	r2, [r3, #0] ....

On peut attaché GDB à Qemu http://cgi.cs.indiana.edu/~geobrown/stm32/Main/Simulation http://garden.seeedstudio.com/index.php?title=DSO_Nano/Qemu_gdb&redirect=no

=Modifications réalisée sur QEMU=

Suivi et accès des GPIO en sortie
Le principe va être d'utiliser le code élémentaire de clignotement de LED blinky.bin disponible dans le répertoire StellarisWare puis de modifier le fichier stellaris.c dans repertoire hw de qemu pour repérer et intercepter les changement d'état

Comprendre l'émulation du stellaris proposé par QEMU suppose de se plonger dans le code. On peut notamment explorer les fichiers suivant, liste non exhaustive:

hw/irq.c hw/qdev.c  hw/stellaris.c       hw/stellaris_input.c  hw/sysbus.h hw/irq.h  hw/qdev.h  hw/stellaris_enet.c  hw/sysbus.c           qemu-common.h

Il est important d'observer la struct qemu_irq. Dans le stellaris.c nous notons la déclaration suivante

static void stellaris_init(const char *kernel_filename, const char *cpu_model,                          stellaris_board_info *board) {   static const int uart_irq[] = {5, 6, 33, 34}; static const int timer_irq[] = {19, 21, 23, 35}; static const uint32_t gpio_addr[7] = { 0x40004000, 0x40005000, 0x40006000, 0x40007000, 0x40024000, 0x40025000, 0x40026000}; static const int gpio_irq[7] = {0, 1, 2, 3, 4, 30, 31};

qemu_irq *pic; DeviceState *gpio_dev[7]; qemu_irq gpio_in[7][8]; qemu_irq gpio_out[7][8];

La déclaration qemu_irq gpio_out[7][8]; va permettre l'émulation des 8 fils de sortie des 7 port d'E/S (A,B,C,D,E,F,G).

Si on suit 'qemu_irq à travers les fichiers, nous avons:

Dans qemu-common.h qemu_irq est un pointer sur IRQState

typedef struct IRQState *qemu_irq;

IRQState dans hw/irq.c

struct IRQState { qemu_irq_handler handler; void *opaque; int n; };

Dans hw/irq.h: typedef void (*qemu_irq_handler)(void *opaque, int n, int level);

qemu_irq_handler est un pointeur sur une fonction qui sera appelée lorsque le fils changera de valeur, voir la fonction qemu_set_irq dans irq.c:

void qemu_set_irq(qemu_irq irq, int level) {   if (!irq) return;

irq->handler(irq->opaque, irq->n, level); }

On va maintenant maintenant de modifier le fichier stellaris.c pour suivre  l'état du bit 0 du port F en sortie  lequel est cablé un LED sur la carte physique (utilisé par le code blinky.bin).

static void print_yop(void *opaque, int line, int level) {  /* opaque is null, can by use to access to a global state ??? */  printf("poy line %d level %d\n",line,level); }

qemu_irq yop; /*test*/ yop = qemu_allocate_irqs(print_yop, NULL, 1)[0]; /* on alloue de ma mémoire  et on positionne le handler, ici print_yop*/

gpio_out[GPIO_F][0] = yop; /* /!\ à faire après l'intialisation de tous les gpio_out, si il y a écrassement */

Archive contenant le fichier modifié stellaris.c et le code de clignotement de LED blinky.bin [[Media:stellaris_mod_blinky.tar]]

./qemu-0.13.0/arm-softmmu/qemu-system-arm -M lm3s6965evb -nographic -kernel blinky.bin

poy line 0 level 1 poy line 0 level 0 poy line 0 level 1 poy line 0 level 0 poy line 0 level 1 poy line 0 level 0

Note Ctrl A puis x quitter QEMU, voir les commandes du moniteur pour plus de détail.

= Image de machine virtuelle = L'image de machine virtuelle ci-dessous contient les outils adaptés pour le LM3S6965EVB comme présenté précédemment: la chaîne de compilation Sourcery G++ Lite, l'outil de pilotage de sonde matérielle OpenOCD, et QEMU.


 * Image de système au format vdi pour VirtualBox:

= FAQ =

Quels sont les composants reconnus de la carte?

 * Extrait de la Documentation Officielle :

The Luminary Micro Stellaris LM3S6965EVB emulation includes the following devices:

Cortex-M3 CPU core. 256k Flash and 64k SRAM. Timers, UARTs, ADC, I^2C and SSI interfaces. OSRAM Pictiva 128x64 OLED with SSD0323 controller connected via SSI.

=Ressources=


 * Site officiel du kit Stellaris Luminary Lm3s6965