Applications CB210 (B)

Notes d'applications pour "CB210" (Part 2)

Afin de vous aider à vous initier et à développer encore plus rapidement avec le module CUBLOC "CB210" et pour vous donner une idée de son potentiel, vous trouverez ci-dessous une sélection complète de notes d'applications (les réalisations concernent aussi bien le domaine ludique, la robotique, la mesure, le domaine professionnel...).

APPLICATION # 13 : Transmision radio à l'aide d'un modem "CLX2-433"

Présentation:
Cette application montre comment interfacer un modem radio "CLX2-433" avec un module "CB210" afin de réaliser une télécommande radio avec accusé de réception via une communication sans fil bi-directionnelle entre le "CB210" et un compatible PC. Pour ce faire un second modem "CLX2-433" devra également être raccordé au port série du PC (avec un circuit intégré MAX3232 pour assurer la compatibilité électrique des signaux TX/RX).

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 2 modems radio (réf.: CLX2-433)
- 1 résistance de 10 Kohms
- 1 diode zener 3,3 V
- 1 étage de mise à niveau de type MAX3232

Câblage de l'application:

Montage CLX2-433

Le raccordement du modem radio "CLX2-433" au module "CB210" est très simple. Celui-ci se limite à son alimentation (via le +3.3 V) ainsi qu'au raccordement des signaux TX et RX au port série du "CB210". On utilisera une diode zener 3,3 V pour limiter la tension en sortie de la broche TX du "CB210" vers l'entrée RX du modem radio. Le schéma du second modem "CLX2-433" à raccorder au port série du PC n'est pas représenté.

Description du programme:

L'application consiste à piloter à distance l'état de la Led présente sur la platine du "CB210" à l'aide des touches (1) et (2) du clavier du PC. Pour ce faire on utilisera un terminal de saisie (type Hyperterminal par exemple à configurer avec le débit 19200 bds) afin d'envoyer à distance le code ASCII des touches (1) et (2) - via le modem relié sur le port série du PC).

Lorsque l'autre modem receptionne les codes ASCII, il les communiquera au port série du module "CB210", qui en fonction du code reçu (49) pour la touche (1) ou (50) pour la touche (2) allumera ou éteindra sa Led... De plus en fonction de l'état de sa led, le module "CB210" enverra un message ASCII en retour au PC via le modem "CLX2-433" afin d'afficher "en clair" l'état de sa Led dans le terminal de saisie. Vous disposez ainsi d'une télécommande radio avec accusé de réception.

Code source:

'###############################################################

' Pilotage d'un modem radio CLX2-433 à l'aide d'un CB210
' @Lextronic 2012 - 06/03/2013 - version Cubloc Studio 3.3.4
'
' Programme donne a titre d'exemple. A utiliser dans le cadre d'une initiation aux modules CUBLOC
' (l utilisation commerciale de ce programme est interdite). Lextronic decline toute responsabilite en
' cas de prejudice resultant de l'utilisation de cette note d'application.
'###############################################################

Const Device = CB210
Dim reception As Byte ' Variable reception port serie
Const LedCB210 = 30 ' La Led du CB210 est sur le port P30
Delay 200
Opencom 1,19200,3,30,30 ' Ouvre le port com du CB210
Low LedCB210 ' Eteind Led du CB210

Do
reception=Get(1,1) ' Lecture buffer reception serie
Select Case reception
Case 49
Out ledcb210,1 ' Allume la led du CB210
Putstr 1,"La Led du CB210 est allumee.",Cr
Case 50
Out ledcb210,0 ' Eteind la led du CB210
Putstr 1,"La Led du CB210 est eteinte.",Cr
End Select
Loop

Représentation du CB210 sous Fritzing
Remerciements à Mr Patrice pour sa contribution

CB210

APPLICATION # 12 : Célèbre jeux vidéo

Présentation:
Cette application montre comment réaliser un célèbre jeu vidéo à l'aide d'un "CB210" associé à 2 mini matrices à Leds à commande I2C™.

Ce jeu consiste à empiler judicieusement des pièces géométriques afin de former des lignes horizontales dans le but d'éviter que ces pièces ne montent jusqu'en haut de la surface de jeu (ce qui signifie alors la perte de la partie).

A chaque fois que vous arrivez à réaliser une ligne horizontale pleine, celle-ci disparait en faisant descendre les pièces vers le bas (afin de retarder la perte de la partie). La surface du jeu est composée de 2 mini matrices sur lesquelles les pièces de formes géométriques différentes évoluent. 5 entrées du CUBLOC sont mises à contribution pour gérer les déplacements des pièces sur la surface de jeu.

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 2 matrices à Leds miniature (réf.: ADA869454)
- 2 x résistances de 4,7 Kohms
- 5 x résistances de 10 Kohms
- 1 condensateur de 0,1 uF
- 1 condensateur de 10 uF
- 5 boutons-poussoirs (réf.: KRS0615)

Câblage de l'application:

Montage

Description du programme:

2 boutons sont utilisés pour déplacer la pièce horizontalement (de la droite vers la gauche et de la gauche vers la droite). 2 autres boutons sont utilisés pour effectuer une rotation à 90 ° de la pièce (dans le sens des aiguilles d'une montre, ou inversement).

Afin de ne pas allonger cette description de façon excessive, nous avons choisi de ne pas publier le code source dans cette page. Celui-ci sera envoyé sur simple demande (par émail) à tous les acquéreurs d'un module CB210".

N'hésitez pas à visualiser la vidéo de cette application.

Le dernier bouton sert à accélérer la chute de la pièce. A la mise sous tension toutes les Leds des matrices s'allument. En sollictant un bouton, les Leds s'effacent et la partie commence. A ce stade une pièce apparait en haut de la surface de jeu et celle-ci descent tout doucement vers le bas de la surface de jeu. Il existe 7 types de pièces (aux formes géométriques différentes). La sélection du modèle de pièce est aléatoire. Déplacez les pièces aux mieux pour favoriser leur emplilement afin de réaliser des lignes pleines. Le principe du programme est assez simple et repose sur l'utilisation d'une variable de type tableau reprenant l'aire de jeu. A chaque Led de la matrice correspond un emplacement dans la variable de type mémoire. En sollicistant les boutons-poussoir, le programme gère les données de la variable mémoire en effectuant des tests sur l'état des données de la variable afin de détecter la formation d'une ligne pleine, la possibilité ou non d'empiler ou de modifier la position de la forme géométrique, etc...

APPLICATION # 11: Pilotage d'une base robotique à l'aide d'un "CB210"Présentation:

Cette application montre comment piloter une base robotique "ROB-09207" à partir d'un module Cubloc "CB210" afin de lui faire réaliser plusieurs mouvement basiques.

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 1 base robotique (réf.: ROB-09207)
- Pile 9 V ou accumulateur, fils et prise DC

Câblage de l'application:

Base robotique

Il n'y a pas de câblage proprement dit à réaliser pour cette application. La platine du "CB210" venant directement s'enficher sur la base robotique. Il vous faudra juste prévoir un onnecteur DC et une pile 9 V (ou un accumulateur pour alimenter l'ensemble).

Description du programme:

Le programme est très simple. Ce dernier se contente d'activer alternativement 4 ports du CB210 (2 ports par moteur) afin que le robot réalise différents mouvements de base. Attention: il est impératif de couper l'alimentation de la platine et de la débrocher de la base robotique avant la phase de chargement de votre programme - sans quoi le port USB de votre ordinateur pourrait subir une sur-consommation lors du pilotage des moteurs.

La base robotique pourraégalement recevoir une multitude de capteurs additionnels optionnels.

N'hésitez pas à visualiser la vidéo de cette application.

Code source:

'###############################################################

' Pilotage d'une base robotique à l'aide d'un CB210
' @Lextronic 2012 - 07/07/2012 - version Cubloc Studio 3.3.4
'
' Programme donne a titre d'exemple. A utiliser dans le cadre d'une initiation aux modules CUBLOC
' (l utilisation commerciale de ce programme est interdite). Lextronic decline toute responsabilite en
' cas de prejudice resultant de l'utilisation de cette note d'application.
'###############################################################

Const Device = CB210
Low 5 ' Initialise les sorties de commande moteur
Low 3
Low 9
Low 6
Do
Gosub stop ' Stop le robot
Out 5,1 ' Roule vers l avant
Out 6,1
Gosub stop ' Stop le robot
Out 9,1 ' Roule vers l arriere
Out 3,1
Gosub stop ' Stop le robot
Out 6,1 ' Tourne a droite
Delay 1000
Out 5,1 ' Puis continue tout droit
Gosub stop ' Stop le robot
Out 5,1 ' Tourne a gauche
Delay 1000
Out 6,1 ' Puis continue tout droit
Gosub stop ' Stop le robot
Out 6,1 ' Demi-tours sur lui-meme
Out 3,1
Loop

stop:
Delay 2000
Out 5,0
Out 3,0
Out 9,0
Out 6,0
Delay 2000
Return

APPLICATION # 10 : Pilotage d'une boussole électronique"CMPS03" à commande I2C™

Présentation:

Cette application montre comment piloter une bossole électronique "CMPS03" à commande I2C™ à partir d'un module Cubloc "CB210" afin d'afficher la direction de la boussole via une aiguille fictive sur un écran LCD graphique couleur.

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 2 x résistances de 4,7 Kohms
- 1 afficheur LCD couleur miniature (réf.: UL-144G2SGC)
- 1 module bousolle (réf.: CMPS03)

Câblage de l'application:

Application avec CMPS03

Description du programme:

Le programme est très simple. Ce dernier se contente de récupérer la valeur de l'angle de la position de la boussole via le bus I2C™. Cet angle est mémorisé dans une variable de type Interger sous la forme d'un nombre compris entre 0 et 359 (soit un angle de 0 à 359 °). Le programme va ensuite afficher une aiguille "virtuelle" sur un écran LCD couleur à commande série. Le tracé de cette aiguille utilise les mêmes formules que celles utilisée pour la notre d'application N° 8 Ci-dessous.

Le programme affiche également un petit rond "plein" au bout de l'aiguille afin que l'on puisse bien distinguer sa position.

Vidéo CMPS03

On prend soin de mémoriser l'ancienne position de l'aiguille afin d'effacer son tracé avant de redessiner celle-ci sur sa nouvelle position.

N'hésitez pas à visualiser la vidéo de cette application.

Code source:

'###############################################################

' Pilotage d'une matrice miniature à Leds à commande I2C
' @Lextronic 2012 - 07/07/2012 - version Cubloc Studio 3.3.4
'
' Programme donne a titre d'exemple. A utiliser dans le cadre d'une initiation aux modules CUBLOC
' (l utilisation commerciale de ce programme est interdite). Lextronic decline toute responsabilite en
' cas de prejudice resultant de l'utilisation de cette note d'application.
'###############################################################

Const Device = CB210

Dim x As Integer    ' Registre coordonne aiguilles
Dim y As Integer    ' Registre coordonne aiguilles
Dim xm As Integer   ' Registre memoire coordonne aiguilles
Dim ym As Integer   ' Registre memoire coordonne aiguilles
Dim angle As Integer    ' Variable angle
Dim mangle As Integer   ' Variable memore angle
Dim errorcom As Byte ' Registre communication I2C

Delay 500
Opencom 1,230400,3,10,70
Delay 500
Putstr 1,"U"    ' Envoi caractere de synchronisation
Delay 500
Putstr 1,"E"    ' Efface l'ecran
Delay 100
Putstr 1,"p",&h01    ' Selection objet non plein
Delay 1
Putstr 1,"C",64,64,63,&h07,&hE0 ' Trace contour cercle boussole
Delay 100
Set I2c 8,9   ' Configure ports pour liaison I2C
Putstr 1,"p",&h00    ' Selection objet plein
Delay 500

Do

' ####### Recuperation donnee de la boussole ##############
I2cstart ' Condition Start I2C
errorcom = I2cwrite (&HC0)    ' Adresse du module CMPS03
errorcom = I2cwrite (0) ' Selectionne adresse registre a lire
I2cstart ' Condition Start I2C
errorcom = I2cwrite (&HC1)    ' Selectionne condition de lecture I2C
angle = I2cread(0)     ' Lecture N° revision module CMPS03
angle = I2cread(0)     ' lecture valeur angle (0 - 255)
angle.Byte1=I2cread(0)    ' Recupere octet poids fort angle
angle.Byte0=I2cread(0)    ' Recupere octet poids faible angle
errorcom = I2cwrite (&HC1)     ' Selectionne condition de lecture I2C
I2cstop   ' Condition Stop I2C

' ####### Dessine aiguille boussole ##############

x = 64 - Cos(((angle/10) * 3.141593) / 180.0) * 43
y = 64 - Sin(((angle/10) * 3.141593) / 180.0) * 43

If xm <> x Or ym <> y Then
Putstr 1,"C",127-xm,127-ym,4,&h00,&h00   ' efface rond
Delay 5
Putstr 1,"L",xm,ym,127-xm,127-ym,&h00,&h00 ' efface aiguille
Delay 3
Putstr 1,"L",x,y,127-x,127-y,&h0FF,&hE0    ' Affiche aiguille
Delay 3
Putstr 1,"C",127-x,127-y,4,&h0FF,&hE0
Delay 50
xm = x   ' Memorise ancienne coordonee x
ym = y    ' Memorise ancienne coordonee y
Endif
Loop

APPLICATION # 9 : Pilotage d'une mini matrice à Leds

Présentation:
Cette application montre comment piloter une mini matrice à Leds à commande I2C™.

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 1 matrice à Leds miniature (réf.: ADA869454)
- 2 x résistances de 4,7 Kohms
- 1 condensateur de 0,1 uF

Câblage de l'application:

Note: Le circuit intégré utilisé par la mini matrice à Leds a tendance à générer des parasites qui remontent via les fils d'alimentation vers la platine du "CB210" (ces pertubations sont causées par la génération des signaux PWM permettant d'allumer les Leds de la matrice). Afin d'éviter tout disfonctionnement lors des phases de téléchargement du "CB210" il sera nécesaire d'ajouter un petit condensateur de découplage entre le + et le moins de la matrice.

Description du programme:

Le programme est très simple. Ce dernier se contente d'envoyer 3 ordres consécutifs à la matrice (via le bus I2C™ - Une fonction a été crée à cet effet). Le premier ordre permet l'activation de l'oscillateur interne de la matrice, le second ordre configure le niveau de luminosité de la matrice, le 3ème ordre configure l'autorisation d'activation des Leds de la matrice.

Ensuite le programme va envoyer les données dans la mémoire RAM de la matrice afin d'afficher un petit smiley". Chaque octet envoyé à la matrice correspond à l'affichage d'une ligne de la matrice. Bit à 0 -> led éteinte et Bit à 1 -> Led allumée. Le ciruit intégré gérant la matrice passe automatiquement à l'adresse mémoire suivante lorsqu'il a reçut un octet. Sachant que le ciruit intégré de la matrice est en fait prévu pour piloter une matrice de 16 x 8 Leds (mais que la matrice ne dispose que de 8 x 8 leds, notre programme envoi les données 2 fois de suite (afin de renseigner l'état de l'autre partie de la matrice - même si elle n'est pas visible... dans le seul but de ne pas avoir de décalage en mémoire RAM).

A noter que les Leds de la matrice ne sont pas rangées dans le même ordre qu'un octet binaire. Voici la correspondance du mot binaire à transmettre avec la position des Leds.

PF8 Pf1 Pf2 Pf3 Pf4 PF1 PF2 PF3
L1   L2 L3   L4 L5 L6   L7   L8

L1 étant la led la plus à gauche de la notice et L8 la Led la plus à droite.
PF = bits de poids fort   Pf = bits de poids faibles

Ceci oblige à une petite "gymnastique" intellectuelle pour afficher le motif désiré !

Le programme se termine enfin en envoyant un odre de clignotement à 1 Hz à la matrice.


   N'hésitez pas à visualiser la vidéo de cette application.



Code source:

'###############################################################

Dim x As Byte ' Registre divers

Dim errorcom As Byte ' Registre erreur communication I2C

Set I2c 8,9 ' Configure ports pour liaison I2C

Delay 500

matrice &H21 ' Activation oscillateur interne de la matrice

matrice &HE0 ' Relage luminosite

matrice &H81 ' Display ON - pas de clignotement

I2cstart ' Condition Start I2C

errorcom = I2cwrite (&HE0) ' Adresse I2C de la matrice

errorcom = I2cwrite (&H00) ' Adresse debut RAM matrice

For x = 0 To 7 ' Affichage lignes de la matrice

errorcom = I2cwrite (DATA(x))

I2cstop

Delay 2000 ' Tempo 2 secondes

matrice &H85 ' Clignotement 1 Hz

Loop

End

Sub matrice (DATA2 As Byte)

I2cstart ' Condition Start I2C

errorcom = I2cwrite (&HE0) ' Adresse I2C de la matrice

errorcom = I2cwrite (DATA2) ' Activation oscillateur interne

I2cstop

End Sub

APPLICATION # 8: Affichage des données d'un accéléromètre sur écran graphique

Présentation:
Cette application montre comment afficher les données en provenance d'un accéléromètre 3 axes à sorties analogiques sur un mini écran graphique couleur "UL144-G2-SGC".

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 1 module accéléromètre 3 axes réf.: ACCEL3)
- 1 afficheur LCD couleur miniature (réf.: UL-144G2SGC)

Câblage de l'application:

Description du programme:

L'évolution de la tension des
axes "x", "y" et "z" est re-
présentée par l'intermé-
diaire de lignes à l'inté-
rieur de différents cercles.

En abence de mouvement,
les lignes sont à l'horizontal.

Lors du déplacement (ou de
l'inclinaison) de l'accéléro-
mètre, les lignes vont pen-
cher à doite ou à gauche
(par rapport au centre du
cercle).

Les 3 sorties analogiques du module accéléromètre sont racordées à 3 entrées de conversion "analogique/numérique" du "CB210". Le programme va (pour chacun des axes) vérifier si la tension en sortie du capteur a changé.

Si tel est le cas, la ligne est effacée puis via une
formule mathématique, sa prochaine position est
calculée, puis "tracée".

N'hésitez pas à visualiser la vidéo de cette application.

Code source:

'###############################################################
' Gestion d'un accelerometre ref: "ACCEL3"' @Lextronic 2012 - 28/06/2012 - version Cubloc Studio 3.3.4
'
' Programme donne a titre d'exemple. A utiliser dans le cadre d'une initiation aux modules CUBLOC
' (l utilisation commerciale de ce programme est interdite). Lextronic decline toute responsabilite en
' cas de prejudice resultant de l'utilisation de cette note d'application.
'###############################################################

Const    Const Device = CB210

Dim x1 As Integer                               ' Coordonnees ligne axe x
Dim y1 As Integer
Dim x2 As Integer                               ' Coordonnees ligne axe y
Dim y2 As Integer
Dim x3 As Integer                               ' Coordonnees ligne axe z
Dim y3 As Integer
Dim VX As Integer                               ' Tension axe x
Dim VY As Integer                               ' Tension axe y
Dim VZ As Integer                               ' Tension axe z

Delay 500
Opencom 1,230400,3,10,70
Delay 500
Putstr 1,"U"                                    ' Envoi caractere de synchronisation
Delay 500
Putstr 1,"E"                                    ' Efface l'ecran
Delay 100

Putstr 1,"s",&h00,&h08,&h00,&h07,&hE0,"Axe x",&h00   ' Affiche le mot Axe x
Delay 5
Putstr 1,"C",30,30,30,&h07,&hE0                      ' Affichage cercle axe x
Delay 220
Putstr 1,"s",&h10,&h08,&h00,&h03,&h1F0,"Axe y",&h00  ' Affiche le mot Axe y
Delay 5
Putstr 1,"C",97,30,30,&h00,&h1F                      ' Affichage cercle axe y
Delay 20
Putstr 1,"s",&h01,&h0F,&h00,&h0FF,&hE0,"Axe z",&h00  ' Affiche le mot Axe z
Delay 5
Putstr 1,"C",64,97,30,&hFF,&hE0                      ' Affichage cercle axe z
Delay 20

VX = Tadin (0)                                  ' Recupere tension capteur axe x
VY = Tadin (1)                                  ' Recupere tension capteur axe y
VZ = Tadin (2)                                  ' Recupere tension capteur axe z

' #############   Affichage axe x   #############
Do
   If VX <> Tadin (0) Then
    Putstr 1,"L",x1,y1,59-x1,62-y1,&h07,&hE0      ' Efface trace de la ligne
      Delay 1
      VX = Tadin (0)                                          ' Recupere tension capteur axe x
      x1 = 30 - Cos((VX * 3.141593) / 180.0) * 28
      y1 = 30 - Sin((VX * 3.141593) / 180.0) * 28
      Putstr 1,"L",x1,y1,59-x1,62-y1,&h00,&h00      ' Affiche trace de la ligne
      Delay 1
    Endif

    ' #############   Affichage axe y   #####
    If VY <> Tadin (1) Then
      Putstr 1,"L",x2,y2,194-x2,62-y2,&h00,&h1F    ' Efface trace de la ligne
     Delay 1
      VY = Tadin (1)                                          ' Recupere tension capteur axe y
      x2 = 97 - Cos((VY * 3.141593) / 180.0) * 28
      y2 = 30 - Sin((VY * 3.141593) / 180.0) * 28
      Putstr 1,"L",x2,y2,194-x2,62-y2,&h00,&h00     ' Affiche trace de la ligne
      Delay 1
    Endif

    ' #############   Affichage axe z   #####
    If VZ <> Tadin (2) Then
      Putstr 1,"L",x3,y3,130-x3,195-y3,&h0FF,&hE0   ' Efface trace de la ligne
      Delay 1
      VZ = Tadin (2)                                           ' Recupere tension capteur axe z
      x3 = 64 - Cos(((VZ-84) * 3.141593) / 180.0) * 28
      y3 = 97 - Sin(((VZ-84) * 3.141593) / 180.0) * 28
      Putstr 1,"L",x3,y3,130-x3,195-y3,&h00,&h00     ' Affiche trace de la ligne
      Delay 1
    Endif
    Loop


APPLICATION # 7:  Horloge à représentation analogique sur écran graphique

Présentation:
Cette application montre comment réaliser une horloge avec représentation analogique sur un mini écran graphique couleur.

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 1 afficheur LCD couleur miniature (réf.: UL-144G2SGC)

Câblage de l'application:

Description du programme:

Le programme utilise les timers internes du module "CB210" pour gérer l'horloge.

Le "CB210" va commencer par dessiner le cadran de l'horloge (avec le marquage des heures de repérages: 12 / 3 / 6 / 9).

A chaque "écoulement" d'une seconde, le programme va récupérer et afficher la position de l'aiguillle de la "trotteuse" (pour les secondes).

Puis il va dessiner l'aiguille des minutes et enfin l'aiguille des heures. On pourra remarquer que le programme efface l'ancienne position de ces 2 aiguilles uniquement si les minutes ou les heures on variées.

On notera enfin que de part la simplicité du programme, la rotation des aiguilles des heures et des minutes n'est pas progessive (comme sur une horloge "mécanique"). Ainsi sur une "vraie" horloge mécanique l'aiguille passe par exemple lentement de la position 1 h à la position 2 h au fur et à mesure que l'aiguille des minutes effectue un tour complet du cadran. Dans notre cas, l'aiguille des heures passera directement de la position 1 h à la position 2 h au moment ou l'aiguille des minutes aura fait un tour complet du cadran.

Nous réaliserons plus tard une nouvelle note d'application plus complète dans laquelle nous simulerons parfaitement la rotation des aiguilles d'une horloge mécanique.

N'hésitez pas à visualiser la vidéo de cette application.

Code source:

'###############################################################
' Horloge analogique
' @Lextronic 2012 - 28/06/2012 - version Cubloc Studio 3.3.4
'
' Programme donne a titre d'exemple. A utiliser dans le cadre d'une initiation aux modules CUBLOC
' (l utilisation commerciale de ce programme est interdite). Lextronic decline toute responsabilite en
' cas de prejudice resultant de l'utilisation de cette note d'application.
'###############################################################

Const Device = CB210

Dim x As Integer                                      ' Registre coordonne aiguilles
Dim y As Integer                                      ' Registre coordonne aiguilles
Dim heure As Byte                                   ' Registre memoire heures
Dim minute As Byte                                 ' Registre memoire minutes
Dim seconde As Byte                                ' Registre memoire secondes

Delay 500
Opencom 1,230400,3,10,70
Delay 500
Putstr 1,"U"                                             ' Envoi caractere de synchronisation
Delay 500
Putstr 1,"E"                                             ' Efface l'ecran
Delay 100

Timeset 10,44                                         ' Initialise les secondes a 0
Timeset 11,45                                         ' Initialise les minutes a 45
Timeset 12,11                                         ' Initialise l'heure a 11

' ####### Dessine le cadran de l'horloge ##############

Putstr 1,"p",&h01                                                  ' Selection objet non plein
Delay 1
Putstr 1,"C",64,64,63,&h00,&h1F                             ' Trace contour cercle horloge
Delay 100
Putstr 1,"s",&h0A,&h01,&h00,&h4E,&h7E,"12",&h00      ' Affiche 12
Delay 1
Putstr 1,"s",&h14,&h08,&h00,&h4E,&h7E,"3",&h00        ' Affiche 3
Delay 1
Putstr 1,"s",&h0B,&h0E,&h00,&h4E,&h7E,"6",&h00        ' Affiche 6
Delay 1
Putstr 1,"s",&h01,&h08,&h00,&h4E,&h7E,"9",&h00        ' Affiche 9
Delay 1

Do
   If Time(12)=24 Then Timeset 12,0                         ' Passage 23h59 a 00h00
   heure = Time(12)   ' Memorise heure
   minute = Time(11) ' Memorise minute
   seconde = Time(10)    ' Memorise seconde

   Do While Time(10) = seconde                                ' Attend passage d'une seconde
   Loop

' ####### Dessine aiguille des secondes ##############

   x = 64 - Cos((((seconde * 6 ) + 90) * 3.141593) / 180.0) * 43
   y = 64 - Sin((((seconde * 6 ) + 90) * 3.141593) / 180.0) * 43
   Putstr 1,"L",64,64,x,y,&h00,&h00                    ' efface ancienne position seconde
   Delay 1
   x = 64 - Cos((((Time(10) * 6 ) + 90) * 3.141593) / 180.0) * 43
   y = 64 - Sin((((Time(10) * 6 ) + 90) * 3.141593) / 180.0) * 43
   Putstr 1,"L",64,64,x,y,&h0FF,&hE0                  ' Affiche aiguille seconde
   Delay 1

' ####### Dessine aiguille des minutes ##############

   If Time(11) <> minute Then                        ' Regarde si minute a change -> Efface aiguille
     x = 64 - Cos((((minute * 6 ) + 90) * 3.141593) / 180.0) * 45
     y = 64 - Sin((((minute * 6 ) + 90) * 3.141593) / 180.0) * 45
     Putstr 1,"L",64,64,x,y,&h00,&h00
     Delay 1
   Endif
   x = 64 - Cos((((Time(11) * 6 ) + 90) * 3.141593) / 180.0) * 45
   y = 64 - Sin((((Time(11) * 6 ) + 90) * 3.141593) / 180.0) * 45
   Putstr 1,"L",64,64,x,y,&h07,&hE0                  ' Rafraichi aiguille minute
   Delay 1

  ' ####### Dessine aiguille des heures ##############

   If Time(12) <> heure Then                          ' Regarde si heure a change -> Efface aiguille
     x = 64 - Cos((((heure * 30 ) + 90) * 3.141593) / 180.0) * 35
     y = 64 - Sin((((heure * 30 ) + 90) * 3.141593) / 180.0) * 35
     Putstr 1,"L",64,64,x,y,&h00,&h00
     Delay 1
   Endif
   x = 64 - Cos((((Time(12) * 30 ) + 90) * 3.141593) / 180.0) * 35
   y = 64 - Sin((((Time(12) * 30 ) + 90) * 3.141593) / 180.0) * 35
   Putstr 1,"L",64,64,x,y,&h0F8,&h00                  ' Rafraichi aiguille heure
Loop

APPLICATION # 6 :  Jeu vidéo "CUBLOC INVADERS"

Présentation:
Cette application montre comment réaliser un jeu vidéo (type "Space Invaders") à l'aide d'un "CB210" associé à un afficheur graphique couleur de type "UOLED-160".



                         Ecran de présentation Démarrage du jeu

                  Tir d'un missille par votre base Un "Alien" a été détruit



                          Ecran de fin de partie                                                     La réalisation complète



Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 1 afficheur OLED "uOLED160-G1" (réf.: UO160G1SGC)
- 3 boutons-poussoirs (réf.: KRS0615)
- 1 buzzer sans oscillateur (réf.: TV4)
- En option: 1 plaque d'essai sans soudure (réf.: PRT-08801)

Câblage de l'application:

Description du programme:

Ce jeu vidéo vous propose d'affronter une horde d'Aliens à l'aide d'un vaisseau spacial. Les Aliens se déplacent de droite à gauche et de gauche à droite de l'écran en progressant d'un "cran" vers le bas lorsqu'ils arrivent à l'extrémité d'un bord de l'écran. Si les Aliens arrivent tout en bas de l'écran, vous perdez la partie. Vous disposez de 2 boutons-poussoirs qui vous permettent de déplacer horizontalement votre vaisseau. Un 3ème bouton-poussoir vous permet de tirer des missiles pour éliminer les Aliens. Afin de rendre la situation plus difficile, vous ne pouvez tirer qu'un seul missile à la fois. Tant que le missile n'a pas atteint le haut de l'écran ou qu'il n'a pas fait explosé un Alien, vous ne pourrez pas en tirer d'autre. Il vous faudra donc viser les Aliens avec précision en anticipant leurs déplacements. Chaque Alien tué rapporte 1 point (le programme affiche le score en haut à gauche de l'écran ainsi que le meilleur score réalisé au cours des différentes parties en haut à droite de l'écran).

Pour les besoins de cette application le module "CB210" pilote (via son port série) un afficheur graphique spécialisé (uOLED160-G1). En début de programme le "CB210" envoi des commandes à l'afficheur afin de redéfinir des caractères (matrices de 8 pixels sur 8 pixels) et de dessiner les différents types d'Aliens, vos missiles ainsi que votre vaisseau ou encore l'explosion des Aliens lorsqu'ils sont touchés par vos missiles. Le programme débute par l'affichage d'un écran de présentation (sur lequel est dessiné un "gros" Alien). Cet écran affiche également un rappel du meilleur score réalisé.

Sur sollicitation du bouton-poussoir de "feu", la première vague d'Aliens apparait à l'écran. Les 35 Aliens sont mémorisés dans une variable de type tableau à 2 dimensions. Ce tableau est ensuite affiché par rapport à une coordonnée de référence afin de pouvoir gérer le déplacement de la vague d'Aliens de façon horizontale et verticale dans l'écran. Ainsi l'arrivée sur les position extrêmes de l'écran génère le déplacement du point de référence d'affichage de la matrice vers le bas de l'écran. Le module "CB210" pilote également un buzzer sans oscillateur (en générant un signal carré de différentes fréquences) afin d'obtenir differents sons au cours de la partie (des sons basse fréquence lors des déplacements des Aliens, un son plus strident lors du tir d'un missile, des petits enchaînements de notes musicales lorsque tous les Aliens sont tués ou pour signaler la fin de le partie).

La boucle principale du programme gère le déplacement des Aliens, de votre vaisseau et de votre missile. Lors du déplacement de votre missile, le programme compare sa position avec celle des Aliens afin de vérifier si vous avez touché l'un d'eux (dans ce cas ce dernier est retiré de la variable de type tableau et une petite animation simulant une explositon est affichée à la place de l'Alien). Lorsqu'il reste moins de 11 Aliens à l'écran la vitesse de déplacement de ces derniers augmente. Il est est de même à nouveau lorsqu'il en reste moins de 6 à l'écran. Lorsque tous les Aliens sont éliminés, une petite succession de notes musicales annonce le début d'une nouvelle partie. A chaque nouvelle partie la vitesse de "base" de déplacement des Aliens est augmentée afin d'accroitre la difficulté de la partie. Si en revanche au moins un Alien arrive tout en bas de l'écran, la partie se termine (avec une petite succession de notes musicales différentes et l'affichage du message "GAME OVER"). Il s'en suit alors le retour à l'affichage de l'écran principal.

APPLICATION # 5 : Décodage de trames en provenance d'un récepteur GPS

Présentation:
Cette application montre comment utiliser un récepteur GPS "EM-406A" associé à un module "CB210" afin que ce dernier affiche les informations du GPS sur un écran LCD.

Matériel nécessaire:

- 1 module CUBLOC "CB210" (réf.: CB210) + 1 câble USB standard (réf.: CW090A)
- 1 module GPS "EM-406" (réf.: EM-406)
- En option: platine d'interface (réf.: BOB-10402)

Câblage de l'application:

Description du programme:

Cette application montre comment décoder les trames NMEA1083 en provenance d'un module GPS. Elle est en tout point identique à celle décrite dans la note d'application N° 36 disponible ici. Il vous faudra simplement modifier la première ligne pour déclarer l'utilisation du module "CB210".

Le code source de cette application peut être téléchargé ici.

Applications CB210 (B)

Notes d'applications pour "CB210" (Part 2)

Accueil