#################### # Sommaire - Orientation de la carte - Architecture - Documents fournis - Mise sous tension - Programmation (Mise en flash d'un programme) - Connectique et pinout - Ressources externes - Objectifs et RoadMap #################### # Orientation de la carte Le coin haut gauche est celui avec le port JTAG, lorsque les composants sont sur le dessus et que la carte SD est dessous. #################### # Architecture La carte s'articule autour du micro-contrôleur LPC1764 (coeur Cortex M3) de NXP. Elle fournit : - Une entrée d'alimentation 5V (P2) (Connecteur au format JST-B2P) - Un port USB device (P13) (Micro-USB) (Permet aussi d'alimenter la carte, mais pas les ports de charge USB) - Un port Ethernet 10/100 (J2) derrière un Phy Ethernet LAN8720A - Un port carte SD - Un port de programmation série (P14) en UART (3.3V) qui donne accès au mode ISP du micro-contrôleur LPC1764 - 4 ports au format UEXT (P3, P6, P5 et P8) (http://en.wikipedia.org/wiki/UEXT ou https://www.olimex.com/Products/Modules/UEXT/) - Deux ports d'extension (P4 et P7) pour deux des ports "Modules" avec 5 GPIO et trois alimentations (+5V, +3.3V et GND) - Un port d'extension "CPL" (P1) qui se trouve sous la carte - Un port d'extension (P9) avec 4 gpio utilisables pour n'importe quel module - Une Led utilisateur (User LED, à côté du connecteur Ethernet) - Un port JTAG (P10) (Format ARM JTAG, mais sur 16 pins, sans les pins 17, 18, 19 et 20, inutilisées) - Deux ports de charge USB (P11 et P12) - Un bouton reset #################### # Documents fournis Le Dossier principal contient ce fichier et deux dossiers: - tools : Les outils de programmation (avec leur code source) - control : le (tout) début de code - lpc1764.ld : le script de link : devrait être OK - bootstrap.c : le strict minimum du bootstrap, initialise la mémoire (BSS) et appelle main : devrait être OK - le reste vient du code que je fais pour le LPC1114 (cortex M0), donc tout à reprendre. #################### # Mise sous tension Il est possible d'alimenter la carte par le port USB Device (micro-USB, P13). La led Power s'allume. (Elle est rouge, à côté du port USB P12) Dans ce cas la les ports de charge USB (P12 et P11) ne sont pas alimentés. L'autre façon d'alimenter la carte est d'utiliser un connecteur JST-B2P et de le connecter au port P2 (tout en bas à gauche de la carte). Il faut alors alimenter en 5V, le 5V est au bord de la carte. #################### # Programmation (Mise en flash d'un programme) Pour l'instant la programmation se fait par la ligne série, sur le port "Prog" (P14, 5 pins) sur la droite de la carte. Ce port est une UART, pas une RS232, et fonctionne donc avec des niveau logiques 0/3.3V. Il n'est pas possible d'utiliser un adaptateur USB-to-RS232 (la pluspart des adaptateurs USB-Serial disposant d'un connecteur DB9). J'utilise un adaptateur acheté chez Sparkfun : https://www.sparkfun.com/products/718 : Breakout Board for FT232RL USB to Serial. Connexion : - Le signal "Reset" (pin 5) est le même que celui du bouton poussoir à gauche, et peut être laissé flotant. - Le signal "ISP_Sel" (pin 2) est le même que celui du bouton poussoir SW2 - ISP, et peut aussi être laissé flotant. - Les signaux "UART_0_Tx" (pin 4) et "UART_0_Rx" (pin 3) sont à relier à un adaptateur USB-to-UART (ou à un port UART d'une autre carte :) - Il est conseillé de connecter le signal "GND" (pin 1) à la masse de l'adaptateur USB-to-UART. La programmation se fait ensuite avec l'utilitaire "prog" qui se trouve dans le répertoire tools (avec ses sources) Utilisé sans arguments cet utilitaire affiche l'aide. Pour fonctionner, il a besoin du port série utilisé pour dialoguer avec la cible, (par exemple "/dev/ttyUSB0") et d'une commande (dump, flash, id, blank, go) et de ses arguments éventuels. Par exemple : ./prog /dev/ttyUSB0 id Affichera : Device session openned. Part ID is 0x26011922 UID: 0x17170e0e - 0x5356004c - 0x4ef171b7 - 0xf5000000 Boot code version is 2.4 "Device session openned." indique qu'un périphérique a répondu à l'étape de synchronisation et que la communication est ouverte. Les lignes suivantes donnent les diverses informations d'identification du périphérique. Pour flasher un programme, il suffit d'utiliser la commande suivante : ./prog /dev/ttyUSB0 -u flash L'option -u permet de demander à l'utilitaire de calculer le checksum nécessaire au micro-contrôleur pour démarrer le programme et de le flasher au bon endroit (huitième mot de la flash, voir chapitre 32 (Flash memory interface and programming) du manuel du LPC1764 (UM10360.pdf). #################### # Connectique et pinout Le pinout des connecteurs usuels ou standardisés respecte les standards ou le pinout usuel (USB, Ethernet, carte SD) Le port "Prog" (P14) utilise le pinout suivant : 1 : GND 2 : ISP_Sel (Le micro-contrôleur démare en mode ISP si ce signal est relié à la masse (GND)) 3 : UART_0_Rx 4 : UART_0_Tx 5 : Reset (Reset le micro-contrôleur lorsque ce signal est relié à la masse (GND)) Le port JTAG (P10) utilise le pinout standard ARM, mais ne fournit pas les pins 17, 18, 19 et 20, qui sont inutilisées sur le connecteur ARM standard. Les 4 Ports au format UEXT (P3, P6, P5 et P8) respectivement pour les modules 0, 1, 2 et 3, respectent le format proposé par la société Olimex et décrit ici : http://en.wikipedia.org/wiki/UEXT _______________________ | | | 2 4 6 8 10 | | | | 1 3 5 7 9 | |_________ _________| 1 : +3.3V 2 : GND 3 : TxD (UART Tx) (TXD* -> '*' = numéro du module) 4 : RxD (UART Rx) (RXD* -> '*' = numéro du module) 5 : SCL (Horloge I2C) (SDA1) 6 : SDA (I2C Data) (SCL1) 7 : MISO (SPI Master In Slave Out) (MISO0) 8 : MOSI (SPI Master Out Slave In) (MOSI0) 9 : SCK (SPI Clock) (SCK0) 10 : SSEL (SPI Chip Select) ((SSEL0 & SPI0_CS*) -> '*' = numéro du module) À noter : - Chaque UART est indépendante, et correspond au numéro du module (UART 0 sur module 0, ...) - L'UART 0 est celle utilisée sur le port "Prog" (P14) - L'I2C est le même sur tous les modules (et sur le module CPL) - Le Chip Select est (sera) utilisé lors du boot pour identifier les modules et leur emplacement par la lecture d'une eeprom I2C. Ce signal est donc actif soit lorsque le chip select générél du SPI et la GPIO correspondante sont actifs, soit lorsque le signal "Power_Up_Detect" (pin 33, P1_19) et la gpio correspondante est active. - Les chip select du SPI sont générés par un "ET" logique entre les GPIO P1_25, P1_26, P1_28 et P1_29 (respectivement pour les modules 0, 1, 2 et 3 et notées SPI0_CS* sur le schéma) et le signal SSEL0 (noté SPI0_SSEL sur le schéma). Les deux ports d'extension (P4 et P7) sont dediés pectivement aux modules 2 (P5) et 3 (P8) Ils utilisent le pinout suivant (même mode de numérotation que les connecteur UEXT) Extension Module 2 (P4) Extension Module 3 (P7) 1 : +3.3V 2 : GND 3 : +5V 4 : GPIO (External Int) GPIO_EINT1 (P2_11 - /EINT1) GPIO_EINT2 (P2_12 - /EINT2) 5 : GPIO (ADC) GPIO_ADC2 (P0_25 - AD0_2) GPIO_ADC0 (P0_23 - AD0_0) 6 : GPIO (PWM) GPIO_PWM2 (P2_4 - PWM1_5) GPIO_PWM0 (P3_25 - PWM1_2) 7 : GPIO (ADC) GPIO_ADC3 (P0_26 - AD0_3) GPIO_ADC1 (P0_24 - AD0_1) 8 : GPIO (PWM) GPIO_PWM3 (P2_5 - PWM1_6) GPIO_PWM1 (P3_26 - PWM1_3) Le port d'extension (P9) fourni 4 GPIO supplémentaires utilisables par n'importe quel module Il utilise le pinout suivant (même mode de numérotation que les connecteur UEXT) 1 : +3.3V 2 : GND 3 : +5V 4 : GPIO_1 (pin 80 - P0_5) 5 : GPIO_0 (pin 81 - P0_4) 6 : GPIO_3 (pin 82 - P4_28) 7 : GPIO_2 (pin 85 - P4_29) 8 : GND Le port d'extension CPL (P1) utilise le même connecteur que les ports UEXT mais a le pinout suivant : 1 : +3.3V 2 : GND 3 : +5V 4 : GPIO (X10_IN pour le X10) 5 : SCL (Horloge I2C) 6 : GPIO (X10_PWM_Out pour le X10) 7 : SDA (I2C Data) 8 : GPIO (X10_Zero_Cross pour le X10) 9 : CPL_Detect (Utilisé pour l'identification du module par I2C au démarrage) 10 : GPIO Les deux leds (Utilisateur et Power) peuvent être désactivées en enlevant le jumper qui se trouve juste à côté (J4 pour la led Power et J6 pour la led Utilisateur) La led Utilisateur est pilotée par la GPIO P0_4 (pin 81) (noté EXT_GPIO_0 sur le schéma) Les signaux USB des ports de charge (P11 et P12) ne sont pas connectés. La charge n'est possible que quand la carte est alimentée par le connecteur d'alimentation 5V (P2). #################### # Ressources extrenes La page du micro-contrôleur sur le site de NXP (le fabriquant) : http://www.nxp.com/products/microcontrollers/cortex_m3/lpc1700/LPC1764FBD100.html Entre autre plusieurs notes d'application et exemples de code : http://www.nxp.com/products/microcontrollers/cortex_m3/lpc1700/LPC1764FBD100.html#documentation A noter : - AN11053 : Ethernet throughput on the NXP ARM microcontrollers (v.1.0) - AN11071 : In-Application Programming for the LPC1700 (v.1.0) - AN11070 : Accessing SDC/MMC card using SPI/SSP on LPC1700 (v.1.0) - AN11241 : AES encryption and decryption software on LPC microcontrollers (v.1.0) - AN10866 : LPC1700 secondary USB bootloader (v.2.1) - AN10859 : LPC1700 Ethernet MII Management (MDIO) via software (v.1.0) La page de la carte de démo du micro-contrôleur chez Embedded Artists : http://www.embeddedartists.com/products/lpcxpresso/lpc1769_xpr.php Cette carte utilise le même phy Ethernet. Voir entre autre le portage de FreeRTOS : http://www.embeddedartists.com/sites/default/files/ext/FreeRTOS-Demo-and-Docs-for-the-LPCXpresso-LPC1768.zip #################### # Objectifs et RoadMap Phase 1 : --------- - Être capable de dialoguer sur ethernet en IP (IPv4 / IPv6), TCP ou UDP - Possibilité de lire et écrire sur la carte SD en Ext2 - Utilisation de tous les modules : - Identification des modules (Utilisation de Power_Up_Detect et SPI0_CS* pour activer l'eeprom I2C du module et lecture de l'eeprom I2C) - Utilisation des signaux des connecteur UEXT : UART, I2C et SPI - Utilisation de toutes les GPIO des modules (UART en GPIO, GPIO des ports d'extension des modules 2 et 3 en tant que GPIO et que ADC, PWM ou source d'interruption externe - Identification du module CPL (I2C + CPL_Detect) - Utilisation des GPIO du module CPL (comme GPIO et pour le X10) - Test du fonctionnement du port JTAG - Test de l'USB device. Phase 2 : --------- - Création d'un "second stage bootloader" qui écoute sur le port USB device si il est branché, et, le cas échéant, fournit une interface de programmation compatible avec dfu_utils. - Sélection et portage d'un OS (CoOS ? FreeRTOS ? contiki-os ?) - Spécification d'un mécanisme de chargement du code relatif à un module à partir d'un identifiant et d'un numéro de version d'un module (depuis l'ethernet, la carte SD, ou l'eeprom I2C du module), et enregistrement en flash - Support du protocole xPL (http://en.wikipedia.org/wiki/XPL_Protocol) Phase 3 : --------- - Création et support de nouveau modules.