Bazaar

A l'asso on utilise bazaar pour stocker nos données sur le serveur. Ce tutoriel à pour but de vous expliquer comment se servir de bazaar sous windows.
 
Tout d'abors, il faut connaitre l'adresse où sont stockées les données :
http://bzr.arenib.org/web/
 
Dans ce dossier, il y a un dossier par an. Le bazzar ayant été réinstallé fin 2011, il y a pour l'instant que le dossier coupe2012 et les archives

 
Le dossier coupe2012 contient les "branches" pour cette année. Chacune de ses branches peut être récupérées individuellement sur n'importe quel pc, connecté à internet et sur lequel est installé bazaar (A l'asso, sur ton portable, sur le pc de papa et moman...).

 
Comment récupérer ce qui est sur le serveur ?
Admettons que l'on veuille récupéré la branche "Asservissement". Et que l'on veuille la stocker sur son pc à C:\test\.
Dans ce dossier, on fait un clic droit->Bazaar Miroir/créer une Branche...

 
Un formulaire s'affiche,

 
dans "Branche source" entrez l'url de la branche que vous voulez récupérer, ici : http://bzr.arenib.org/coupe2012/Asservissement. Il vous indique qu'un dossier au même nom que la branche sera créé dans "test".
Attention, il ne doit pas y avoir de / à la fin de l'url !!!

Cochez "Make a local copy of the branch" et cliquez sur OK
Votre login et mot de passe vous seron demandés.
Félicitations, vous avez récupéré votre première branche.

 

Copier une carte SD bootable

Suivre le lien (en) : http://pixhawk.ethz.ch/wiki/tutorials/omap/copy_sd_card

Créer une bibliothèque (avec CMake)

Il est expliqué ici sommairement comment créer une bibliothèque dynamique (ou librairie si on traduit mal de l'anglais) via CMake.
CMakeList.txt racine
Il faut y ajouter le nom du répertoire de la nouvelle librairie :

INCLUDE_DIRECTORIES(autresLibs ... dossierDeLaLib ...)

ADD_SUBDIRECTORY(libenvironment)
 
CMakeList.txt de la nouvelle bibliothèque
Voici le squelette du CMakeList.txt à ajouter dans le répertoire la nouvelle librairie.

SET(QT_USE_QTSCRIPT true)
SET(QT_USE_QTXML true)

INCLUDE( ${QT_USE_FILE} )

SET(nomNouvelleLib_moc_headers
" classe1.h"
" classe2.h"
" ..."
" )"

SET(nomNouvelleLib_sources
" classe1.cpp"
" classe2.cpp"
" ..."
" )"

QT4_WRAP_CPP(environment_moc_src ${nomNouvelleLib_moc_headers})
ADD_LIBRARY(environment SHARED ${nomNouvelleLib_sources} ${nomNouvelleLib_moc_src})

Autres CMakeList.txt
Enfin il faut rajouter la nouvelle librairie aux CMakeList.txt de celles qui en ont potentiellement besoin.

TARGET_LINK_LIBRARIES(blablabla... nomNouvelleLib...)
_Astuce : Sous QtCreator rechercher dans tout le projet (CTRL+SHIFT+F) un nom de librairie équivalent à celle créé. En remplissant le champ \"File pattern\" avec *.txt on trouve toutes les occurences de la librairie \"exemple\" dans tous les CMakeList.txt
 

CrossCompilation

Depuis la révision source:@54 il est possible de cross compiler le programme du robot pour la Beagle Board.

Il faut tout d'abord récupérer builroot :

wget http://buildroot.uclibc.org/downloads/buildroot-2009.11.tar.bz2
tar xf buildroot-2009.11.tar.bz2

Le fichier de configuration pour buildroot est dans une branche bazaar on la récupère et on prépare la config de la compilation. Ca fait deux trois trucs puis ouvre une pseudo interface graphique. Faire tout bêtement \"Exit\".

bzr branch bzr+ssh://bzr@arenib.org/home/bzr/info/buildroot/ buildroot-arenib
make menuconfig

Ensuite on copie le fichier de config dans le répertoire de buildroot puis on compile (si vous avez un tracteur comme processeur ça peut prendre du temps).
+Attention+ : Même si on a un pc de kéké avec 8 processus simultannés ne pas se la péter avec un _make -j9_ ca fait échouer lamentablement le build.

cd buildroot-2009-11 && cp ../buildroot-arenib/config .config
make

Ensuite la cross-compilation on va dans le répertoire du code du robot on crée un dossier de build et on exécute cmake.
La valeur de la variable _BUILDROOT_DIR_ est l'emplacement où vous avez décompressé et compilé buildroot plus haut.

cd ~/dev/robot/arenibot/trunk
mkdir cross && cd cross
cmake -DCMAKE_TOOLCHAIN_FILE=../Toolchain-arm.cmake -DBUILDROOT_DIR=adresse_en_absolu_de_buildroot ..
Puis compiler le code

make
Enfin envoyé le code sur la beagle

make deploy
 

Créer un driver

Structure des classes
La bibliothèque _libcomponent_ contient les drivers de communication avec le bas niveau.
L'architechture d'héritages est globalement la suivante :

_Component_ <- _I2C/GPIO/Serial/.../Component_ <- Driver

Le driver hérite donc soit de _I2Component_ soit de _GPIOComponent_ ... selon ce dont on a besoin.
 
Ajout du driver dans le robot
Dans le constructeur de Robot (_robot.cpp_) il faut créer le driver :

_proximity = new Proximity();
_componentsHash.insert("proximity" _proximity);

Il peut être intéressant d'ajouter une méthode retournant un pointeur sur le driver.
Cas particulier : driver I2C
Dans le cas d'un driver I2C il faut remplir le fichier de config _arenibot/trunk/config/component.conf_ :
> config/component.conf

[Driver]
i2c_addr = XX
autresProprietes = yy
...
> src/libcomponent/driver.cpp

Driver::Driver() :
" I2cComponent(QSettings("config/components.conf" QSettings::NativeFormat).
" value("Driver/i2c_addr" XX).toInt())
{
" setObjectName("Driver");"
}

Envoyé un ordre en i2c à une carte

"QByteArray message; "
QDataStream stream(&message QIODevice::WriteOnly);
stream.setVersion(Arenibot::DataStreamVersion);
stream<

Envoyé une demande d'information en i2c à une carte
QByteArray trame;
trame.append(ORDER);

QByteArray data;
readTrame(trame "data); "

QDataStream stream(data);
stream.setVersion(Arenibot::DataStreamVersion);
stream >>DATA_1>>DATA_2;

MEMO : Attention la beagleBoard et les atmega atmel ne stock pas les données de la même façon (LittleEndian/BigEndian) l'utilisation de Arenibo::DataStreamVersion permet d'assurer le bonne ordre d'envoi des données.
 

Kicad

Extrait du site internet de kicad :
Kicad est une suite open source (GPL) pour la réalisation de schémas électroniques et de circuits imprimés.

Conçue et réalisée par Jean-Pierre Charras chercheur au LIS (Laboratoire des Images et des Signaux) et enseignant en électronique à l'IUT de Saint Martin d'Hères la suite Kicad est un ensemble de quatre logiciels et un gestionnaire de projets destinés à la réalisation de cartes électroniques:

• Schema:Entrée schématique.
• PcbNew:Logiciel de réalisation de circuits imprimés.
• Gerbview:Visualisation des documents générés au format GERBER (documents de phototraçage).
• Cvpcb:utilitaire de sélection des empreintes physiques des composants électroniques utilisés dans le schéma.
• Kicad:gestionnaire de projets.

Le gestionnaire de projets Kicad permet la sélection rapide d'un projet et le lancement de l'utilitaire voulu (Eeschema PcbNew ...).
Cette suite logiciels est diffusée gratuitement en open source sous licence GPL par le LIS à toutes les personnes intéressées.
Il est destiné à toute personne ayant à créer et réaliser des circuits imprimés simples ou complexes.
Ces logiciels (ils sont basés sur WXWIDGETS.) sont MULTI-PLATEFORME et tournent sous LINUX et Windows et sont maintenus régulièrement.

Page sourceforge : http://kicad.sourceforge.net/wiki/index.php/Main_Page
Page Launchpad : https://launchpad.net/kicad
Télécharger Kicad : http://kicad.sourceforge.net/wiki/index.php/Download

AVR Dragon

Nous permet de programmer tous nos AVR.
Lien vers la page dédiée sur le site d'atmel : http://www.atmel.com/dyn/products/tools_card.asp?tool_id=3891&category_id=163&family_id=607&subfamily_id=760
Notice d'utilisation : http://www.epsilonrt.com/avrdragon/avrdragon-notice.pdf

Avrdude

Allez jeter un oeil par la : http://www.silicium628.fr/electron/atmega/atmega.htm

Bibliotèque pour atmega

Ici vous pouvez télécharger tous les drivers et modules que l'on utilise.
Soit en téléchargeant chaque fichiers séparément ou l'archive contenant tout les fichiers voir ci-dessous :
Les drivers :
Conversion analogique->numérique.
Documentation :
Fichiers :

• adc_drv.h
• adc_drv.c

Les modules :
SMBSlave.
Documentation :
Fichiers :

• SMBSlave.c
• SMBSlave.h
• SMBSlaveConfig.h

SMBMaster.
Documentation :
Fichiers :

• SMBMaster.c
• SMBMaster.h
• SMBMasterConfig.h

Moteur pas-à-pas.
Documentation :
Voir également :
Dépendances :

• aucunes

Fichiers :

• moteurPasAPas.c
• moteurPasAPas.h
• moteurPasAPas_config.h

Servo-moteur.
Documentation :
Voir également :
Dépendance:

• aucunes

Fichiers :

• servoMotor.c
• servoMotor.h

Télémètre laser.
Documentation :
Voir également : Télémètre laser

Dépendances :

• Conversion analogique->numérique:

 

• adc_drv.h
• adc_drv.c

Fichiers :

• telem.h
• telem.c

Le tout :
Documentation :
L'archive :

Chaîne de développement 8bit

Linux
Je vous conseille vivement de récupérer la chaîne de développement sur le site d'atmel. Sans quoi vous risquez d'avoir des problèmes de composants non supportés ou ne pas pouvoir compiler leur bibliothèque. Atmel AVR Toolchain 3.2.3 for Linux.
Décompressez l'archive à un endroit judicieux, ensuit il vous faut configurer votre IDE (Voir si dessous).
Il vous reste plus qu'à installer Avrdude et à prendre en main un IDE comme : CodeBlock ou Eclipse.
Windows
Le plus simple est d'utiliser AVR Studio.

Vous pouvez tout de même utiliser la méthode "Linux"
Atmel AVR Toolchain 3.2.3 for Windows

Conventions

Unités et Communication avec le bas niveau
Lors des communications I2C entre le haut et bas niveau les distances sont transmises sous forme d'entiers.
Le haut niveau fonctionne avec des mètres et des radians. Les distances sont normalement toujours transmises en dixièmes de millimètres dans les communications I2C soit des mètres multipliés par un coefficient de 10.000. Idem pour les radians ils sont transmis en dix-millièmes de radians.
Dans _arenibot.h_ il existe un _#define COEF 10000_ par lequel on multiplie lorsqu'on reçoit (ou divise quand on envoie) des informations.

Avr Studio

Avr Studio est l'IDE fournit pour la compagnie Atmel pour développer avec ces micro-contrôleur.
C'est aussi la méthode la plus simple (et je pence la plus efficace) sous windows (Peux fonctionner sous virtualbox) pour le développement des AVRs.
Il est gratuit et ne fonctionne que sous windows néanmoins il est possible de développer sous linux à l'aide de l'IDE Eclipse et d'un plugin particulier.
 
Lien vers la v5 : http://www.atmel.com/microsite/avr_studio_5/default.asp?source=redirect
Lien vers la v4 : http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725&category_id=163&family_id=607&subfamily_id=760

Code Block

Code blocks est un IDE principalement pour le C/C++.
Code Block et les AVRs
Vous pouvez vous reporter à "Chaîne de développement 8bit" pour récupérée la Toolchain proposer par ATMEL qui contiens entre autre le compilateur avr-gcc.
Dans la suit de ce document les manipulations seront faites sous linux mais ça devrais être les même pour windows.
Configurer Code Block pour avr-gcc
Si vous avais choisi de télécharger la Toolchain sur le site d'ATMEL vous avez sûrement besoin de dire à Code Block où ce trouve avr-gcc.
Sinon il ne devriez pas avoir de problème.

bq. Aller dans le menu Settings->Compiler and Debugger ...
Puis dans "Global compiler settings" et dans "Selected Compiler". Sélectionner "GNU AVR GCC Compiler".
Puis dans l’onglet "Toolchain executables" et dans le compartiment "compiler's installation directory" sélectionner le répertoire ou ce trouve "bin/avr-gcc" par exemple pour moi c'est "/home/antoine/Programmation/avr/avr8-gnu-toolchain-linux_x86_64/"
!GlobalCompilerSettings.png!

Vous pouvez maintenant crée un nouveau projet.
Crée un nouveau projet
A l'ouverture de Code Block cliquer sur "Create a new project" ou fait File->New->Project...

!codeblocksavr1.png!
Sélectionner "AVR Project" et cliquer sur "go".

!codeblocksavr2.png!
Rien à faire de particulier ici cliquer sur "Next >".

!codeblocksavr3.png!
Ici vous nommé votre projet par exemple "myfirstavr" puis l'emplacement de votre nouveau projet. Code Block créera automatiquement un dossier du non de votre projet.
Puis cliquer sur "Next >".

!codeblocksavr4.png!
Ici le mieux et de laisser par défaut.
Puis cliquer sur \"Next >\".

!codeblocksavr5.png!
Enfin sélectionner votre composent (ici atmega644).
Vous pouvez aussi définir le define F_CPU qui est la vitesse de votre composent (ici 20 MHz) et je conseil de le définir surtout si vous utiliser les fonctions _delay_.
Puis cliquer sur "Finish".
Le reste des options par défaut devrai suffire.

Vous pouvez maintenant compiler en cliquent sur le bouton builde (ctrl+F9).
Configurer Code Block pour avrdude (connexion à la dragone)
Malheureusement pour nous il n’existe pas encore de plugins pour Code Block.
Ceci dit il y a un moyen de ce servir d'avrdude avec Code Block pour l'envoi du .hex dans l'AVR.
Faisons un exemple avec un atmega644.
Aller dans le menu Tools->Configure tools ...
Puis cliquer sur Add.
!CBavrdude.png!
Name : Vous donner un non à votre outils par exemple "prog -> m644".
Executable : Là sais l’exécutable ce sera "avrdude".
Parameters : Ce son les paramétrés à envoyer à avrdude on metra "-p m644 -c dragon_jtag -P usb -U flash:w:${TARGET_OUTPUT_BASENAME}.elf.hex"
Working directory : C'est le dossier de travailler d'avrdude on metra "${PROJECT_DIR}/${TARGET_OUTPUT_DIR}"

Ici je donne les paramètres d'avrdude pour différend composants.

• atmega644 en jtag

"-p m644 -c dragon_jtag -P usb -U flash:w:${TARGET_OUTPUT_BASENAME}.elf.hex"

• atmega644 en isp

"-p m644 -c dragon_isp -P usb -U flash:w:${TARGET_OUTPUT_BASENAME}.elf.hex"

• atxmega32a4 en pdi

"-p x32a4 -c dragon_pdi -P usb -U flash:w:${TARGET_OUTPUT_BASENAME}.elf.hex"

Pour plus d'information sur [[avrdude]].
Pour plus d'information sur [[AVR Dragon]].
Configurer Code Block pour avarice (GDB)
Pour plus d'information sur [[Avarice]].
Code Block et les SAMs
 

Eclipse

Eclipse et un IDE ou plutôt un couteau suisse pour la programmation.
Pour les AVR.
Il faut d'abord installer la chaîne de développement.
Sous Windows :

• WinAVR (est-ce qu'il contient tout ?)

Sous Linux :

• gcc-avr (compilateur)
• avr-libc (librairie C)
• avrdude (programmation)
• avarice (débugger via JTAG)

_(nom des paquets sous Debian à adapter en fonction de la distribution)_

Il faut ensuite dans Eclipse installer le plugin.
Pour cela aller dans Help > Install New Software
Puis dans la nouvelle fenêtre: Sur le champ Work with: cliqué sur Add afin d'ajouter un dépôt.
Name: « AVR Eclipse Plugin » Location: « http://avr-eclipse.sourceforge.net/updatesite »

Puis installer les plugins suivant :

• AVR Eclipse Plugin (taper AVR dans le champs de recherche)
• Eclipse C/C++ GDB Hardware Debugging (Si vous voulez pouvoir effectuer du debug en ligne taper Hardware dans le champs de recherche)

Configuration du programmeur :

• Window -> Preferences
• puis dans l'onglet AVR -> AVRDude ajouter une entrée dans Programmer configurations
• Indiquer le nom voulu et la commentaire associé.
• Sélectionner le programmeur (Atmel AVR Dragon in JTAG mode) puis le port (-P) utilisé taper simplement usb.
• Valider

WiP
Pour les SAM.
Je ne sais pas faire."