Modules d’affichage touchscreen 4D Systems


4D Systems est une société australienne.

Elle propose divers produits. dans cet article on s’intéresse aux modules 3,2  » dont le prix annoncé est de 79 $(US) ( voir la liste des resellers pour acheter en France et en Europe ).

Ce module µLCD-32PT existe en deux versions : GFX ou SGC.

µLCD-32PT

µLCD-32PT

Ce module se connecte directement au µProcesseur par une liaison série UART .

Il peut se connecter au PC en USB avec un petit module complémentaire, pour le programmer.

A titre d’exemple : µUSB-MD5

µUSB-MD5

µUSB-MD5

voir sur le site : accessoires.

L’application de programmation n’est disponible que pour Windows.

Encore une fois, avec Linux, on s’isole vraiment du monde de l’embarqué, en ne disposant pas des outils de développement gratuits proposés par les fabricants.
On comprend très bien qu ‘ils ne veulent pas se casser le bol à faire des outils pour chacune des distributions de Linux et suivre les changements de versions ; même si Linux est la base de plusieurs OS embarqués, libres ou propriétaires.

Le langage de programmation de l’afficheur et : 4D GL ( 4D Graphic language ) spécifique aux afficheurs 4D.

Un avantage par rapport à d’autres marques d’afficheurs : la doc est complète, claire et divers outils sont disponibles gratuitement.

http://www.4dsystems.com.au/prod.php?id=113

Ces modules sont disponibles en deux version SGL et GFX

How To Decide Between GFX or SGC

The architecture of the base PICASO chip is such that it can be reconfigured to operate in 2 distinctively different ways. To configure the device, a PmmC (Personality Module Micro-Code) is downloaded via its serial port. There are 2 types of PmmC available for PICASO.

SGC PmmC:

By loading the SGC (Slave Graphics Controller) PmmC, the module is ‘ready to go’ by simply connecting it to the serial port of your favourite micro-controller, and sending serial commands to it.

GFX PmmC:

By loading the GFX (Stand-Alone Graphics Controller) PmmC, the module is then like a microprocessor which you program, using the 4DGL language (very similar to C), to control the internal graphics and external interfaces.
The 4DGL language command set and functions for PICASO can be found here:
PICASO-GFX2-4DGL-Internal-Functions-rev2

Note:

At any time, you can reload the PICASO chip with either PmmC which allows you to explore the differences between the two configurations.

In general, documentation and PmmC’s for both configurations (PICASO-SGC or PICASO-GFX2) for the uLCD-32PT module can be found in the ‘Downloads’ tab of each link here:
uLCD-32PT(SGC) : with PICASO-SGC Slave configuration
uLCD-32PT(GFX) : with PICASO-GFX2 Stand-Alone configuration

On va s’interesser d’abord au modèle « Ready to Go » : le SGL.

Selon la doc , il est convertible en GFX en rechargeant le PmmC correspondant, et lycée de Versailles.

  • Low-cost LCD display graphics user interface solution.
  • 240 x 320 QVGA resolution, 65K true to life colours, TFT screen.
  • Display Viewing Area: 48.6 x 64.8mm
  • Integrated 4-Wire resistive Touch Panel.
  • Easy 5 pin interface to any host device: VCC, TX, RX, GND, RESET.
  • Asynchronous hardware serial port, TTL interface, with 300 baud to 256K baud
  • .

  • Powered by the 4D-Labs PICASO-SGC processor (also available as separate OEM IC for volume users).
  • On-board micro-SD memory card adaptor for multimedia storage and data logging purposes. HC card support is also available for cards 4Gb and larger.
  • DOS compatible file access (FAT16 format) as well as low level access to card memory.
  • Dedicated PWM Audio pin supports FAT16 audio WAV files and complex sound generation.
  • On-board audio amplifier with a tiny 8 Ohms speaker for sound generation and WAV file playback.
  • Comprehensive set of built in high level graphics functions and algorithms that can draw lines, circles, text, and much more.
  • Display full colour images, animations, icons and video clips.
  • Supports all available Windows fonts and characters (imported as external fonts).
    16 x General Purpose I/O pins. Upper 8 bits can be used as an I/O Bus for fast 8-bit parallel data transfers.
  • 2 x 30 pin headers for I/O expansion and
      future plug-in daughter boards
  • 4.0V to 5.5V range operation (single supply).
    Module dimensions: 55.1 x 77.0 x 13.8mm (not including mounting tabs).
  • 4 x snap-off mounting tabs with 3mm holes for mechanical support.
  • RoHS Compliant.
  • Un module est disponible chez Lextronic, à un prix beaucoup plus élevé.

    http://www.lextronic.fr/P3745-afficheur-tft-autonome-ulcd-32032-p1t.html

    Extrait de la doc :

    Conçu sur la base d’un puissant microcontrôleur cadencé à 50 Mips, l’afficheur « µLCD-32032-P1 » dispose d’un connecteur pour carte micro SD™ (livrée en option) ainsi que d’un connecteur au pas de 2,54 mm (faisant office de port de téléchargement) et de 2 connecteurs 30 points, lesquels donnent accès à différents ports d’entrées/sorties.

    Entièrement autonome, l’afficheur se programme à l’aide d’un langage de haut niveau appelé « 4DGL ». Très puissant et simple à assimiler, le « 4DGL » composé d’un éditeur, d’un compilateur et d’un Linker est disponible gratuitement en libre téléchargement. Doté d’une syntaxe proche du langage « C » et du « Basic », il vous permettra de concevoir des applications autonomes (sans aucun microcontrôleur externe) sur le « µLCD-32032-P1 ». Dès lors, votre application sera plus compacte, moins chère tout en bénéficiant d’une consommation plus réduite.

    Le programme écrit sous « 4DGL » pourra (une fois compilé) être téléchargé dans la mémoire du « µLCD-32032-P1 » via le port USB du PC (au moyen d’un petit module additionnel « uUSBCE5 » ou « uUSBMB5 » proposés en bas de page). Dès lors l’ensemble pourra être déconnecté du PC afin que vous disposiez d’un système autonome sur lequel votre programme pourra:

    Créer des fonctions,

  • gérer des instructions matématiques (valeurs min/max, Sinus, Cosinus, racine carré, valeur aléatoires),
  • générer des temporisations,
  • envoyer et recevoir des données sur le port série de l’afficheur,
  • effacer l’écran,
  • afficher un pixel avec sélection de sa couleur,
  • retourner la couleur d’un pixel sur l’écran, tracer un cercle (plein ou vide) avec sélection de sa couleur,
  • tracer une ellipse (pleine ou vide) avec sélection de sa couleur,
  • tracer une ligne avec sélection de sa couleur,
  • tracer un rectangle (plein ou vide) avec sélection de sa couleur,
  • tracer un triangle (plein ou vide) avec sélection de sa couleur,
  • tracer un polygone (plein ou vide) avec sélection de sa couleur,
  • tracer une suite de ligne consécutives avec sélection de la couleur,
  • dessiner un bouton avec sélection de sa couleur et du texte marqué dedans,
  • dessiner une barre de réglage avec sélection de son échelle et de sa couleur,
  • copier une partie de l’écran,
  • définir une zone de « rognage » à l’écran,
  • afficher une image « pixel par pixel »,
  • gérer des affichages par rapport à des coordonnées « x / y » de référence,
  • gérer différents type d’affichage de textes,
  • lire et écrire des données sur la carte micro SD™ (livrée en option),
  • gérer les informations de la dalle tactile de l’afficheur,
  • afficher des images fixes ou animées préalablement chargées depuis le PC dans la mémoire de la carte micro SD™,
  • gérer divers tests et manipulation sur les caractères,
  • activer des sorties logiques,
  • lire l’état d’entrée logique,
  • se synchroniser sur le balayage vidéo de l’écran…
  • Résumé : On va pouvoir décharger le microprocesseur de tout un tas de fonctions graphiques, il n’aura plus qu ‘à envoyer à l’afficheur les données variables de l’application embarquéee, et à gérer l’écran tactile..

    Description du langage « 4DGL »:

    Bénéficiant d’une interface conviviale, le langage « 4DGL » dispose d’un dispositif de numérotation de lignes, d’un repérage par colorations distinctes, d’une aide en ligne, d’une gestion de variable de type Integer (sur 16 bits), d’un mode Débug ou encore de la possibilité de pouvoir télécharger vos programmes dans la mémoire RAM ou Flash des afficheurs « 4D Systems ».

    Vous trouverez ci-dessous un petit apperçu de la liste des instructions du langage « 4DGL » (consultez sa documentation pour avoir accès à toutes les instructions).

    Instructions générales:func .. endfunc
    if .. else .. endif
    while .. wend
    repeat .. until/forever
    gosub .. endsub
    lookup8(…) and lookup16(…)
    to(…)
    print(…)
    putch(…)
    putstr(…)
    goto
    pause(..)
    serin()
    serout(..)
    setbaud(..) Gestion / Création de fonctions
    Instruction conditionnelle
    Gestion de boucles
    Gestion de boucles
    Gestion de sous-routine
    Recherche avec filtrage
    Redirection des données à afficher
    Affichage avec formatage sur l’écran
    Affichage avec redirection
    Affichage de chaîne de caractères
    Instruction de « saut »
    Temporisation
    Envoi de données sur le port série
    Lecture de données depuis de le port série
    Configuration du débit du port série

    Instructions mathématiques:

  • ABS Retourne la valeur absolue
  • MIN Retourne la valeur mini. entre 2 arguments
  • MAX Retourne la valeur max. entre 2 arguments
  • MIN3 Retourne la valeur mini. entre 3 arguments
  • MAX3 Retourne la valeur max. entre 3 arguments
  • SWAP Permutation mémoire
  • SIN Calcul Sinus
  • COS Calcul Cosinus
  • SQRT Calcul racine carrée
  • RAND Générateur pseudo aléatoire
  • SEED Initialisation module générateur aléatoire
  • Instructions mathématiques:
    gfx_Cls
    gfx_PutPixel
    gfx_GetPixel
    gfx_Circle
    gfx_Ellipse
    gfx_Line
    gfx_Rectangle
    gfx_Triangle
    gfx_Polygon
    gfx_Polyline
    gfx_Button
    gfx_Slider
    gfx_ScreenCopyPaste
    gfx_ClipWindow
    gfx_Bitmap
    gfx_MoveTo
    gfx_IncX
    gfx_IncY
    gfx_Dot
    gfx_LineTo
    gfx_LineRel
    gfx_OrbitInit
    gfx_Orbit
    gfx_BoxTo
    gfx_RGBto565
    gfx_332to565
    gfx_RGBto2B3G3R
    gfx_Set
    gfx_Get
    Efface l’écran
    Affiche un pixel avec sélection de sa couleur
    Retourne couleur d’un pixel sur l’écran
    Trace un cercle (plein ou vide) avec sélection de sa couleur
    Trace une ellipse (pleine ou vide) avec sélection de sa couleur
    Trace une ligne avec sélection de sa couleur
    Trace un rectangle (plein ou vide) avec sélection de sa couleur
    Trace un triangle (plein ou vide) avec sélection de sa couleur
    Trace un polygone (plein ou vide) avec sélection de sa couleur
    Trace une suite de ligne consécutives avec sélection de la couleur
    Dessine un bouton avec sélection couleur et texte marqué dedans
    Dessine barre de réglage avec sélection échelle et couleur
    Copie d’une partie de l’écran
    Définition d’une zone de « rognage » à l’écran
    Affiche une image « pixel par pixel »
    Déplace les coordonnées de référence « x / y »
    Incrémente la coordonnée de référence « x »
    Incrémente la coordonnée de référence « y »
    Affiche un pixel aux coordonnées de référence
    Affiche ligne depuis coordonnées de référence (+ MAJ « x / y »)
    Affiche une ligne depuis les coordonnées de référence
    Instruction de calcul de position
    Instruction de calcul de position
    Affiche rectangle depuis coordonnées de référence (+ MAJ « x / y »)
    Gestion / paramétrage des couleurs
    Gestion / paramétrage des couleurs
    Gestion / paramétrage des couleurs
    Paramétrage des options d’affichage
    Lecture des options d’affichage

    Instructions pour affichage de textes:

    txt_MoveCursor
    txt_Set
    Déplacement du curseur de textes
    Paramétrage de l’affichage (taille fonte, opacité, curseur « ON/OFF »…)

    Instructions de gestion de carte mémoire micro SD™:

    uSD_Init
    uSD_SetAdd
    uSD_RdByte
    uSD_WrByte
    uSD_SetSector
    uSD_RdSector
    uSD_WrSector
    uSD_Image
    uSD_Video
    Initialisation carte micro SD™
    Configuration pointeur d’adresse de la carte mémoire
    Lecture d’un octet depuis l’adresse mémoire de la carte
    Ecriture d’un octet à l’adresse mémoire de la carte
    Configuration d’un secteur d’adresse de la carte mémoire
    Lecture de 512 octets depuis l’adresse secteur de la carte
    Ecriture de 512 octets à l’adresse secteur de la carte
    Affiche une image stockée sur la carte mémoire
    Affiche une animation stockée sur la carte mémoire

    Instructions de gestion de la dalle tactile de l’écran:

  • touch_DetectRegion Retourne état dalle dns une partie de l’écran
  • touch_Set Configure paramètres dalle tactile
  • touch_Get Lecture paramètres dalle tactile
  • Instructions de gestion de chaînes:

    isdigit
    isxdigit
    isupper
    islower
    isalpha
    isalnum
    isprint
    isspace
    toupper
    tolower
    Vérifie si un caractère est correspond à un digit de 0 à 9
    Vérifie si un caractère est correspond à un Hexa de 0 à F
    Vérifie si un caractère est en majuscule
    Vérifie si un caractère est en minuscule
    Vérifie si un caractère est une lettre
    Vérifie si un caractère est un chiffre
    Vérifie si un caractère est un ASCII affichable
    Vérifie si un caractère est un espace
    Conversion en majuscule
    Conversion en minuscule

    Le langage « 4DGL » dispose également d’instructions spécifiques au différents modules d’affichages supportés par ce dernier (lecture d’entrées logiques, définition d’un niveau logique à appliquer sur des broches de sortie, synchronisation sur signal vidéo, etc…).

    Reportez-vous à la documentation du langage « 4DGL » pour plus d’infos.

    Manuel de référence 4DGL

    http://www.4dsystems.com.au/downloads/4DGL-Docs/4DGL-Programmers-Reference-Manual-rev2.pdf

    Exemple de programme 4DGL :

    http://www.4dsystems.com.au/code/index.php?node=37&id=70

    #platform « uOLED-GOLDELOX »

    /* 4DGL Demo Application
    – Scope Demo –
    — All GOLDELOX Platforms —
    */

    #inherit « 4DGL_16bitColours.fnc »

    // constants for the viewport
    #CONST
    windowXpos 30
    windowYpos 30
    windowWidth 78
    windowHeight 60
    #END

    #CONST
    TRIANGLE 3
    RECTANGLE 4
    PENTAGON 5
    HEXAGON 6
    LEFTCOLOUR 0xF800
    RIGHTCOLOUR 0xFFFF
    TOPCOLOUR 0x001F
    BOTTOMCOLOUR 0x07E0
    #END

    #CONST
    LEFTHIT 15
    RIGHTHIT 113
    TOPHIT 15
    BOTTOMHIT 113
    #END

    #constant XSPEED 3
    #constant YSPEED 2
    #constant WALL 4 // outer wall thickness

    // constant object definitions
    #constant ERASEBALL $ball_x, ball_y, 3, BLACK
    #constant DRAWBALL $ball_x, ball_y, 3, ball_colour

    #constant LEFTWALL $0, 0, WALL , 127, LEFTCOLOUR
    #constant RIGHTWALL $127-WALL , 0, 127, 127, RIGHTCOLOUR
    #constant TOPWALL $0, 0, 127-WALL, WALL , TOPCOLOUR
    #constant BOTTOMWALL $gfx_Rectangle(0, 127-WALL, 127, 127, BOTTOMCOLOUR)

    #constant BALLSIZE 10 // Notice constants can be post declared

    var ball_x, ball_y, ball_r, ball_colour;
    var xdir, ydir;
    var targetX, targetY;

    var Xcoords[6], Ycoords[6]; // big enough for a hexagon

    #constant SAMPLES 16

    var ScopeBuf[SAMPLES];
    var oldseed, loops;

    //—————————————————————————————-//
    func drawWalls()
    gfx_Set(PEN_SIZE, SOLID);
    gfx_Rectangle(TOPWALL); // Draw Top Wall
    BOTTOMWALL; // Draw Bottom Wall
    gfx_Rectangle(LEFTWALL); // Draw Left Wall
    gfx_Rectangle(RIGHTWALL); // Draw Right Wall
    endfunc
    //—————————————————————————————-//

    //—————————————————————————————-//
    func collision()
    if(ball_x = RIGHTHIT)
    ball_x := RIGHTHIT;
    ball_colour := RIGHTCOLOUR;
    xdir := -xdir;
    endif

    if (ball_y = BOTTOMHIT)
    ball_y := BOTTOMHIT;
    ball_colour := BOTTOMCOLOUR;
    ydir := -ydir;
    endif
    endfunc
    //—————————————————————————————-//

    //—————————————————————————————-//
    // blank the screen, draw scope if start of demo loop then do random dot intro
    func Blankout()
    var n, x, y;

    gfx_Set(PEN_SIZE, SOLID);
    // clear the window
    gfx_Rectangle(windowXpos, windowYpos, windowXpos+windowWidth, windowYpos+windowHeight, BLACK);

    gfx_Set(CLIPPING, ON); // turn the clipping on

    if ((loops & 63) == 0) // do waveform timeslot?
    SEED(oldseed);
    n := 0;
    while (n < SAMPLES)
    ScopeBuf[n++] := RAND()/1500; // fill scope with scaled random data
    wend
    oldseed := RAND();

    n := SAMPLES*10; // repeat the buffer 10 times
    while (n–)
    gfx_Set(OBJECT_COLOUR, LIME);
    gfx_Plot(SAMPLES, ScopeBuf, n, AUTO); // plot the waveform
    pause(40); // frame delay

    // erase the old window
    gfx_Set(PEN_SIZE, SOLID);
    gfx_Rectangle(windowXpos, windowYpos, windowXpos+windowWidth, windowYpos+windowHeight, BLACK);
    wend
    endif

    gfx_Set(PEN_SIZE, SOLID);
    gfx_Rectangle(windowXpos, windowYpos, windowXpos+windowWidth, windowYpos+windowHeight, BLACK);

    // dots
    SEED(1234);
    n := -3000;
    while (n++<3000)
    x := ABS(RAND()%windowWidth) + windowXpos;
    y := ABS(RAND()%windowHeight) + windowYpos;
    gfx_PutPixel(x , y , RAND());
    wend

    // undraw the dots
    SEED(1234);
    n := -3000;
    while (n++<3000)
    x := ABS(RAND()%windowWidth) + windowXpos;
    y := ABS(RAND()%windowHeight) + windowYpos;
    RAND();
    gfx_PutPixel(x , y , 0);
    wend

    endfunc
    //—————————————————————————————-//

    //—————————————————————————————-//
    // build a polygon with a number of sides determined by var "sides"
    // around the current origin. The distance from the origin to the
    // equidistent vertices from origin determined
    // by var "distance". var "angle" is the starting angle for the
    // first virtices. Draws the polygon in colour var "colr"
    // NB make sure the array is big enough for the required number of sides
    //—————————————————————————————-//
    func MakePolygon(var angle, var sides, var distance, var colr)
    var index, step;
    index := 0;
    step := 360/sides; // work out the step size
    while (sides < 360) // until we do a complete polygon
    gfx_Orbit(angle, distance);
    Xcoords[index] := targetX; // build a polygon in the matrix
    Ycoords[index] := targetY;
    index++;
    angle := angle + step;
    sides := sides + step;
    wend
    gfx_Polygon(index, Xcoords, Ycoords, colr);
    endfunc
    //—————————————————————————————-//

    //—————————————————————————————-//
    // update the "Frames =" field
    //—————————————————————————————-//
    func UpdateCounter(var value)
    gfx_Set(CLIPPING, OFF); // turn off the clipping
    gfx_MoveTo(88, 100); // move graphics cursor to message area
    txt_Set(TEXT_COLOUR, CYAN);
    txt_Set(TEXT_OPACITY, OPAQUE); // we want solid text so it erases old text
    to(GFX); putnum(UDEC3Z, value); // print and update the loop count
    txt_Set(TEXT_OPACITY, TRANSPARENT); // switch back to transparent text
    endfunc
    //—————————————————————————————-//

    //—————————————————————————————-//
    func main()
    var dly, angle;

    loops := 0;
    dly := 0;
    angle := 0;

    ball_colour := WHITE; // initial ball colour
    xdir := 1; ydir := 1; // initial ball direction
    ball_x := 77; ball_y := 33; // initial ball position

    txt_Set(FONT_SIZE, FONT_SMALL); // small font

    // set generic target variables for the orbit command
    gfx_OrbitInit(&targetX, &targetY);

    // clears screen, turns off clipping
    gfx_Cls();

    // preset the clipping area, activated later…
    gfx_ClipWindow(windowXpos, windowYpos, windowXpos+windowWidth, windowYpos+windowHeight);

    // draw a rectangle around the clipped area
    gfx_Set(PEN_SIZE, OUTLINE);
    gfx_Rectangle(windowXpos-1, windowYpos-1, windowXpos+windowWidth+1, windowYpos+windowHeight+1, YELLOW);

    // print all static text messages
    gfx_MoveTo(35, 100);
    to(GFX); putstr("Frames = "); // place the static message

    // draw all initial objects
    drawWalls(); // draw the Walls

    repeat
    pause(14); // there is no vsync control, pause

    gfx_Set(CLIPPING, OFF); // turn off clipping so we can draw outside the clipped area

    // remove the horizontal marker
    if(ball_x < 108) gfx_Triangle(ball_x, 10, ball_x+3, 20, ball_x+6, 10, BLACK);
    // remove the vertical marker
    if(ball_y < 88) gfx_Triangle(10, ball_y, 20, ball_y+3, 10, ball_y+6, BLACK);

    if (!(dly++ & 15)) // each 16 times through the main loop,
    if (!(++loops & 15)) // if we're about to start a new pattern
    Blankout(); // draw some pixels to introduce next screen
    ball_x := RAND()%127; ball_y := RAND()%127; // set ball position
    endif
    endif

    UpdateCounter(dly); // update the "Frames -" count

    // undraw current object
    gfx_Set(CLIPPING, ON); // now turn the clipping back on

    if ((loops & 0x30) == 0x00)
    gfx_MoveTo(ball_x, ball_y);
    txt_Set(TEXT_COLOUR, BLACK);
    to(GFX); print("4DGL"); // erase the text
    endif

    if ((loops & 0x30) == 0x10)
    gfx_Set(PEN_SIZE, SOLID);
    gfx_Circle(ERASEBALL); // erase the ball
    endif

    if ((loops & 0x30) == 0x20)
    gfx_MoveTo(ball_x, ball_y); // using the balls origin
    MakePolygon(angle, TRIANGLE, 10, BLACK); // undraw old triangle
    endif

    if ((loops & 0x30) == 0x30)
    gfx_MoveTo(ball_x, ball_y); // using the balls origin
    MakePolygon(angle, RECTANGLE, 10, BLACK); // undraw old rectangle
    endif

    //=========================================
    // move to new position
    //=========================================
    ball_x := ball_x + xdir * XSPEED; // move to new X pos
    ball_y := ball_y + ydir * YSPEED; // move to new Y pos
    collision(); // detect collision
    angle := angle + 10; // step to new angle
    //=========================================

    gfx_Set(CLIPPING, OFF); // now turn off the clipping
    // redraw the box
    if(ball_x < 108) gfx_Triangle(ball_x, 10, ball_x+3, 20, ball_x+6, 10, MAGENTA);
    // redraw the box
    if(ball_y < 88) gfx_Triangle(10, ball_y, 20, ball_y+3, 10, ball_y+6, ORANGE);
    gfx_Set(CLIPPING, ON); // now turn on the clipping

    // redraw required example
    if ((loops & 0x30) == 0x00)
    gfx_MoveTo(ball_x, ball_y);
    txt_Set(TEXT_COLOUR, ball_colour);
    to(GFX); print("4DGL"); // redraw the text
    endif

    if ((loops & 0x30) == 0x10)
    gfx_Set(PEN_SIZE, SOLID);

    Pour les commandes en version SGC

    les commandes sont une suite de valeurs hexa ( commade, plus paramètres , options ) envoyées par la liaison série depuis le µprocesseur de l’application embarquéee, vers l’afficheur :

    Voici un exemple de commande : Dessiner un cercle.

    Liste des commandes :

    2.1 General Commands

    Summary of Commands in this section:
    • AutoBaud – 55hex
    • Set new Baud-Rate – 51hex
    • Version-Device Info Request – 56hex
    • Replace Background Colour – 42hex
    • Clear Screen – 45hex
    • Display Control Functions – 59hex
    • Set Volume – 76hex
    • Sleep – 5Ahex
    • Read GPIO Pin – 61hex
    • Write GPIO Pin – 69hex
    • Read GPIO Bus – 79hex
    • Write GPIO Bus – 57hex

    2.2 Graphics Commands
    Summary of Commands in this section:
    • Add User Bitmap Character – 41hex
    • Draw User Bitmap Character – 44hex
    • Draw Circle – 43hex
    • Draw Triangle – 47hex
    • Draw Image-Icon – 49hex
    • Set Background colour – 4Bhex
    • Draw Line – 4Chex
    • Draw Polygon – 67hex
    • Draw Rectangle – 72hex
    • Draw Ellipse – 65hex
    • Draw Pixel – 50hex
    • Read Pixel – 52hex
    • Screen Copy-Paste – 63hex
    • Replace colour – 6Bhex
    • Set Pen Size – 70hex

    2.3 Text Commands
    The PICASO-SGC is shipped with 4 internal fonts. These fonts can be altered, deleted and replaced with new
    fonts. The FONT-Tool is a free software tool that can assist in the conversion of any Windows fonts into the
    bitmap format that can be used by the PICASO-SGC. The converted font set can then be exported into the
    DISP-Tool utility which can then be downloaded into the PICASO-SGC on-chip flash memory. Both the
    FONT-Tool and the DISP-Tool are available free from http://www.4dsystems.com.au
    Summary of Commands in this section:
    • Set Font – 46hex
    • Set Transparent-Opaque Text – 4Fhex
    • Draw ASCII Character (text format) – 54hex
    • Draw ASCII Character (graphics format) – 74hex
    • Draw “String” of ASCII Text (text format) – 73hex
    • Draw “String” of ASCII Text (graphics format) – 53hex
    • Draw Text Button – 62hex

    2.5 SD Memory Card Commands (Low-Level/RAW)
    The commands detailed in this section utilise the SD/microSD memory card which must be connected to
    the SPI port of the PICASO-SGC. The memory card is used as the storage medium for all multimedia objects
    such as images, icons, animations and video clips which can be accessed and displayed. The memory card
    can also be used by the host controller as a general purpose storage medium such as data logging
    applications.
    The following commands are related to Low-Level memory card operations and they are described in this
    section.
    Summary of Commands in this section:
    • Initialise Memory Card – @69hex
    • Set Address Pointer of Card (RAW) – @41hex
    • Read Byte Data from Card (RAW) – @72hex
    Write Byte Data to Card (RAW) – @77hex
    • Read Sector Block Data from Card (RAW) – @52hex
    • Write Sector Block Data to Card (RAW) – @57hex
    • Screen Copy-Save to Card (RAW) – @43hex
    Display Image-Icon from Card (RAW) – @49hex
    • Display Object from Card (RAW) – @4Fhex
    • Display Video-Animation Clip from Card (RAW) – @56hex
    Run Script (4DSL) Program from Card (RAW) – @50hex

    celles ci sont particulièrement intéressantes, puis qu’on pourra à partir du µ proc de l’appli embarquée , dérouler des scripts 4D GL enregistrés sur la Sdcard.

    Par exemple pour lui faire dessiner un « compte tours », ce sera plus rapide et l’application embarquée ne dessinnera que l’aiguille à la bonne indication.

    Idem pour animer des bargraphs. On laissera le 4DGL dessiner le fond d’écran, et le µproc enverra les cdes pour dessiner des rectangles de hauteur différentes, selon les valeurs à afficher..+

    Il existe d’autres commandes dans le manuel.

    Bien sur on pourrait tout gérer sur un panel LCD il existe à ~ 30 $ :http://shop.4dsystems.com.au/lcd-displays/243-9008.html, sans le 4DGL et le SGC avec un microproc assez puissant, mais c’est un gain de temps pour le développement des applications, pour un supplément de prix assez raisonnable.

    D’autre part on économise des E/S TOR, peu nombreuses, et très utiles dans certaines applis embarquées temps réel, avec la liaison série, contrairement à la gestion d’un panel LCD grand consommateur de GPIO.

    La mise au point en raccordant l’afficheur sur le PC en USB est aussi appréciable, ainsi que la possibilité d’enregister les routines sur SDCARD.

    Publicités
    Cet article, publié dans Modules d'affichage, est tagué , , , , , , , . Ajoutez ce permalien à vos favoris.

    Laisser un commentaire

    Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

    Logo WordPress.com

    Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

    Image Twitter

    Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

    Photo Facebook

    Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

    Photo Google+

    Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

    Connexion à %s