Julien

1 2 3 21

Dernière mise à jour le 05/05/2019

Présentation


Dans ce présent article nous allons voir comment comparer une image (.bmp) qui celle-ci sera enregistré sur la carte SD (Pour ma part je suis muni d’une carte de 16 Giga), le principe est le suivant , c’est de comparer l’image enregistré sur la Carte SD par rapport à ce que la camera OpenMV visualise en instantanée.

Fonctionnement


Au niveau des “Constantes de réglages“, voici celles qui ont été configurées:

import sensor, image, time, os
#Constantes de réglage
gainceiling = 16
constrast = -3
brightness = -3 # Luminosité
saturation = -3
sensor.set_gainceiling(gainceiling)
sensor.set_contrast(constrast)
sensor.set_brightness(brightness)
sensor.set_saturation(saturation)
sensor.set_pixformat(sensor.GRAYSCALE)# film en noir et blanc!
sensor.set_framesize(sensor.QVGA) #320x240
sensor.skip_frames(time = 2000)

Un gain de 16, pas de contrast, pas de luminosité, et pas de saturation. En ce qui concerne le réglage de la caméra, je film en noir et blanc, et avec une résolution de 320×240, nul besoin de rechercher la qualité c’est ce que nous allons voir maintenant!

Dans la programmation je fais appel à la fonction “get_histogram()” qui permet d’obtenir l’histogramme de l’image qui sont résistants à un certain nombre de transformations sur l’image. Ils sont invariants aux rotations et aux translations, et aux changements d’échelle. Les histogrammes sont en revanche sensibles aux changements d’illumination et aux conditions d’éclairage, et c’est pour cette raison que j’ai ajouté la constante “Seuil_reglage“, afin que vous puissiez modifier ce seuil en fonction de la où vous êtes situé (salle obscure, ou plutôt éclaircis pouvant modifier l’image filmé par la caméra OpenMV)


Dans la boucle “While(True)“, je fais une boucle infinie, afin de filmer l’image en temps réel.
Ensuite, pendant que la camera film, je vais ans la foulée prendre une capture de l’image filmé à l’instant “t”, que je sauvegarde dans le dossier “Image”.
Va venir tout de suite après la fonction “difference(“Image/CaptureImage.bmp”)” ou on va faire une différence absolue entre l’image filmé et celle qui a été enregistré sur la carte SD.


C’est ensuite que va intervenir la fonction “get_histogram()”, puis “get_threshold()” et “value()”, ce qui permet:
get_histogram() (Obtenir l’histogramme détaillé précédemment)
get_threshold() (obtenir le seuil et permet de calculer les valeurs de seuil optimales qui divisent l’histogramme en deux moitiés pour chaque canal de l’histogramme)
value() (retourne la valeur du seuil de l’échelle de gris de 0 à 255)


C’est donc avec ces 3 données que nous allons pouvoir faire la différence d’image.

Programmation


# Comparer image bmp – Electronique71.com
import sensor, image, time, os, pyb

Led_Red = pyb.LED(1) # Led rouge

sensor.reset()

#Constantes de réglage
gainceiling = 16
constrast = -3
brightness = -3 # Luminosité
saturation = -3

sensor.set_gainceiling(gainceiling)
sensor.set_contrast(constrast)
sensor.set_brightness(brightness)
sensor.set_saturation(saturation)

sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QVGA) #320×240
sensor.skip_frames(time = 2000)

Image_Comparer = False
Seuil_reglage = 7 # Valeur du seuil à modifier

if not "Image" in os.listdir(): # Si pas de dossier "Image" sur la carte SD
    os.mkdir("Image") # On créer le dossier "Image"

while(True):

    img = sensor.snapshot()

    if (Image_Comparer == False):   
        print("Sauvegarde Image ")        
        img.save("Image/CaptureImage.bmp")
        Image_Comparer = True


    Img_Diff = img.difference("Image/CaptureImage.bmp")
    Seuil_Valeur = Img_Diff.histogram().get_threshold().value()
    print(Seuil_Valeur)
    
    if (Seuil_Valeur > Seuil_reglage):
        Led_Red.on()  # Led rouge qui s'allume = changement d'image!!
        print('Seuil_Valeur = ' ,Seuil_Valeur)
        time.sleep(1000) # temps pour regarder
        Image_Comparer = False
        Led_Red.off() # On éteint la Led

Prototype



La première image correspond à la superposition de l’image enregistré  et celle filmé par la camera sachant que la différence absolu via la fonction “difference(“Image/CaptureImage.bmp”)” est nul (bien evidemment les 2 images sont identiques alors l’image retourné par la caméra est noir!!)


la deuxième image correspond à l’image d’origine, oui!! désolé je ne vous ai pas dis que je filmais l’écran de mon ordinateur et plus particulièrement le bloc notes!! et à cet instant en cliquant sur l’onglet “Fichier” cela à modifier la différence des 2 images (celle enregistré précédemment et celle visionné par la caméra en temps réel).
Ainsi la différence entre les 2 images n’est plus nul et c’est pour cette raison que la troisième image retourné par la caméra correspond à l’image ou j’ai cliqué…

Prototype



Une petite vidéo de quelque seconde pour voir le fonctionnement.

Historiques


07/05/19
– Ajout d’une led rouge qui s’allume dès que l’image change mais aussi d’une vidéo !
05/05/2019
– 1er mise à disposition

Présentation


Nous allons voir dans cet article la forme des signaux du protocole I²C et expliquer les 2 principes de fonctionnement, avec un mode écriture, et un mode lecture. nous verrons ensuite comment les échanges se font entre le maitre et l’esclave par intermédiaire de bit d’acquittement.

Protocole I2C



(Clique pour agrandir)

Nous avons 2 fils qui sont SDA (Serial Data ou Donnée en série) et SCL (serial clock ou horloge série qui synchronise les données).
Ces données seront cadencées par l’horloge maitre, et c’est donc le maitre qui va cadencer la vitesse de transmission (100Khz en standard) à tous les esclaves (grand maximum 128 peuvent être connectés car donné de 7 bits et le 8èmùe bit permet de savoir si lecture ou écriture).

Les 8 premier bits (ou le 1er octets) correspondent à l’adresse avec de couleur verte le 8ème bit (R/W) qui correspond soit à une lecture soit à une écriture, et le 9ème bits l’acquittement.
Si le 8ème bit est à l’état logique « 1 » il s’agit d’une lecture (R), et si celui-ci est à l’état logique « 0 » il s’agit dans ce cas d’une écriture (W).
Ainsi, lorsque l’adresse est envoyée sur le bus avec le 8ème bit significatif (soit à « 0 » soit à « 1 ») l’esclave possédant l’adresse indiqué par le maitre doit répondre par l’intermédiaire d’un bit d’acquittement qui celui-ci est représenté par la couleur bleu. A cet instant lorsque le maitre a reçu le bit d’acquittement de la part de l’esclave, le maitre va soit écrire des donnée (si et seulement si le 8ème bit est à l’état logique « 0 »), ou soit il demande à ce que l’esclave lui envoie ses données (si et seulement si le 8ème bit est à l’état logique « 1 ».
Vous allez me demander mais pourquoi le 9ème bit a 2 couleurs rouge/bleu sur le schéma précédent ?
Tout l’importance est là, si le maitre est en mode écriture, dans ce cas c’est l’esclave qui va générer les bits d’acquittement (couleur bleu). Et à l’inverse si le maitre est en mode lecture, c’est le maitre qui va générer les bits d’acquittement (couleur rouge) un petit exemple va suivre afin de bien assimiler le principe de fonctionnement en mode écriture ou en mode lecture.

Mode écriture



(Clique pour agrandir)

START + adresse

Comme vous pouvez le constater le maitre démarre par un bit de START, la ligne SDA tombe de l’état logique « 1 » à l’état logique « 0 », et ensuite le maitre envoi une adresse (ex: 0xA8h) qui correspond en hexadécimal à 10101000 en binaire.
Le 8ème bit est bien à l’état logique « 0 » ce qui veut dire que le maitre écrit sur le bus et s’adresse à l’esclave qui lui a une adresse 0xA8 (Attention l’adresse doit être unique par esclave interdiction d’avoir des adresse identiques pour chaque esclaves). A cet instant, l’esclave qui à cette adresse va se reconnaitre et donc envoyer un bit d’acquittement en signalant au maitre qu’il a bien reçu l’adresse en mode écriture.

1ère donnée

Une fois le maitre ayant reçu le bit d’acquittement (le 9ème bit pour être précis) qui émane de l’esclave, le maitre va écrire la 1er donnée soit 0x02h qu’il va transférer à l’esclave.
Cette 2ème donnée va donc être reçue par l’esclave et ce dernier va renvoyer un bit d’acquittement en signalant qu’il a bien reçu cette 1er donnée.

2ème donnée

Rebelote !! le maitre ayant reçu le bit d’acquittement qui émane de l’esclave va renvoyer une 2ème donnée 0x03h, et ainsi de suite l’esclave va renvoyer un bit d’acquittement en signalant qu’il a bien reçu cette 2ème donnée.

3ème donnée

Et pour finir le maitre va renvoyer une 3ème donnée 0x05h et ainsi de suite l’esclave va renvoyer un bit d’acquittement en signalant qu’il a bien reçu cette 3ème donnée…

STOP

Le maitre a bien reçu le bit d’acquittement de l’esclave mais il n’enverrait rien d’autre et la ligne passera à l’état logique « 1 » en envoyant un bit de STOP pour dire à l’esclave qu’il a terminé la transmission de données.
Ce qu’il faut comprendre d’une manière général c’est qu’à chaque fois qu’un bit d’acquittement est généré derrière par l’esclave, c’est le maitre qui doit envoyer les données.
J’aurais pu continuer bien entendu avec une 4ème donnée….

Mode lecture



(Clique pour agrandir)


START + adresse

En mode lecture, le principe reste le même on retrouve le bit de START ainsi que l’envoi de l’adresse en mode lecture puisque le 8ème bit est à l’état logique « 1 » (couleur verte), ce qui donne 0xA9h en hexadécimal qui correspond à 10101001. Le maitre réclame donc une lecture sur le bus à l’esclave afin que ce dernier puisse lui envoyer les données.

1ère donnée

Lorsque l’esclave à bien reçu son adresse (0xA8) avec le 8ème bit à l’état logique « 1 » ce qui donne (0xA9), il sait que c’est le maitre qui s’adresse à lui en mode lecture, et doit générer un bit d’acquittement afin de donner une réponse au maitre du type : « oui c’’est bien moi !! Je t’envoie les données comme demandé !! » . Ainsi la 1er donnée 0x07h est envoyé par l’esclave au maitre.

2ème donnée

Lorsque le maitre aura reçu la 1er donnée qui émane de l’esclave, c’est le maitre à son tour qui va répondre à l’esclave par un bit d’acquittement (couleur rouge) en signalant à l’esclave qu’il a bien reçu la 1er donnée mais maintenant qu’il attend maintenant la 2ème donnée !!
Ainsi, l’esclave va renvoyer la 2ème donnée qui est 0x02h au maitre.

3ème donnée

Lorsque le maitre aura reçu la 2er donnée qui émane de l’esclave, il va renvoyer un bit d’acquittement (couleur rouge), pour recevoir cette fois-ci la 3ème donnée, et rebelotte !! L’esclave enverra la 3ème donnée qui correspond à 0x00h cette fois-ci.

STOP

Lorsque le maitre aura reçu la 3ème donné, il n’enverra pas de bit d’acquittement, car et ce ceci est IMPORTANT, chaque fois que le maitre envoi un bit d’acquittement (couleur rouge) c’est qu’il réclame un retour de l’esclave et l’esclave doit répondre en transmettant ses données.
Afin d’arrête cette transmission, le maitre va émettre un bit de STOP pour dire à l’esclave que la transmission est terminé et qu’il n’attend plus rien de l’esclave.
C’est un peu comme nous dans la vraie vie, lorsque nous posons une question, c’est que nous attendons un retour de réponse. Et bien ici, c’est la même chose, si vous voulez faire une analogie avec ce que je viens de dire, la question correspondrais à un bit d’acquittement du maitre (le maitre pose la question) et l’esclave y répond.
Il en résulte donc que chaque fois qu’il y’a une question de posé l’esclave doit y répondre.
Prenons maintenant le problème à l’envers du genre – l’esclave peut répondre uniquement qu’à 2 questions….
Comme le maitre à déjà envoyé une première « question » qui correspond à une lecture de l’esclave (le 8ème bit est à l’état logique »1 » = lecture) cela veut bien dire que la maitre demande dès le départ à ce que l’esclave envoie une 1ère donnée (une réponse). Il ne reste donc plus qu’une seul question à poser par le maitre lorsqu’il aura reçu la 1er donnée
Ce qu’il faut comprendre d’une manière général c’est qu’à chaque fois qu’un bit d’acquittement est généré par le maitre, l’esclave doit envoyer les données.

  • Côté maitre avec 1 bit d’acquittement = 2 données à transmettre de la part de l’esclave ;
  • Côté maitre avec 2 bits d’acquittements = 3 données à transmettre de la part de l’esclave ;
  • Côté maitre avec 3 bits d’acquittements = 4 données à transmettre de la part de l’esclave ;

Dernière mise à jour le 16/03/2019

Présentation


Si vous n’avez pas fait un tour par ici je vous invite à le faire afin de bien comprendre le fonctionnement du protocole I2C. Si cas contraire j’en déduis que vous avez compris le fonctionnement du protocole I2C, dans ce cas nous allons voir comment programmer un PIC 18F4550 en tant qu’esclave qui celui-ci pourra envoyer des données directement au maitre lorsque ce dernier enverra un bit de lecture (8ème bit à l’état logique “1”)

Fonctionnement


Mode réception
En mode réception I2C le PIC 18F4550 est configuré en tant qu’esclave, ainsi en mode esclave le matériel générera toujours une interruption si et seulement il y a une correspondance d’adresse.

 

 
Prenons un exemple, le maitre envoie une trame de données qui est cadencée par l’horloge ce qui par la même occasion impose aux esclaves cette cadence. Lorsque ces données arrivent sur les broches RB0 et RB1 du PIC 18F4550, les 7 premiers bits qui correspondent à l’adresse sont comparés au bit SSPADD que vous avez renseigné dans le programme. Lorsque les 7 bits correspondent au bit SSPADD une interruption sera générée.

Ci-dessous programmation des interruptions ainsi que l’adresse de l’esclave en MikroPascal:

INTCON.GIE := 1; // On active les interruptions globales
INTCON.PEIE := 1; // On active les interruptions périphériques
PIE1.SSPIE := 1; // On active les interuptions du MSSP ( Module de port série synchrone principal I2C ou SPI)
PIR1.SSPIF := 0; // On met le drapeau à zéro pour commencer

SSPADD := 0xA8; // Configuration de l’adresse de l’esclave du PIC 18F4550

Si vous avez choisi la même adresse identifiés ci-dessus (0xA8 (hexadécimale)) et que le maitre envoie la même adresse alors votre PIC sera reconnue. Attention!! si vous avez plusieurs esclaves, chaque esclaves doivent avoir une adresse unique.

Les registres nommés SSPSR et SSBUF forme ensemble un récepteur double tampon. Lorsque le registre SSPSR reçoit un octet complet (8 bits (0 à 7) sans compter le bit d’acquittement « ACK ») et que l’adresse est validée, une impulsion Acknowledge (ACK), sera générée automatiquement par le PIC et va charger le registre SSPBUFF avec la valeur reçue actuellement située dans le registre SSPSR ce qui va produire une interruption via le bit SSPIF.
le bit SSPIF va passer à l’état logique “1” et doit donc être remis à “0” par logiciel.

PIR1.SSPIF := 0; // C’est ce bit qui passe à l’état logique “1” chaque fois que le SSBUFF est chargé


Vous trouverez plus bas la programmation du maitre ainsi que de l’esclave, je vous laisse lire le programme afin de mieux comprendre le fonctionnement.

Schéma



(Clique pour agrandir)

Logiciel du PIC


Ci-dessous les réglages dans le menu”Edit Project” (MikroPascal ou MikroC) à réaliser. je n’ai pas continué les autres captures d’écran mais tout le reste est à desactiver “Disabled”.


Programme MikroPascal du PIC 18F4550 –
MikroPascal

Programme MikroC du PIC 18F4550 – MikroC

Prototype


Une petite vidéo pour la démonstration mais vidéo rapide

Circuit(s) imprimé(s)


Aucun.

Historiques


16/03/2019
-1er mise à disposition

Dernière mise à jour le 16/03/2019

Présentation


Cet article à pour but d’expliquer comment programmer deux PIC 18F4550, l’un en mode esclave et l’autre en mode maitre. Vous pouvez vous rendre sur ce lien Protocole I2C afin de comprendre le protocole I2C en mode écriture ou en mode lecture

Fonctionnement


Lorsque le PIC18F4550 est configuré en mode Esclave, les broches SCL et SDA doivent être configurées comme des entrées. C’est pour cette raison que le registre TRISB = 0b00000011 (0x03 en hexadécimal) est initialisée comme entrée, mais aussi il faudra activer le bit SSPEN du port série synchrone principal qui se fait via le registre SSPCON1 (nous en parlerons un peu plus loin).

Une fois que le registre TRISB est configuré comme entrée, le matériel (interne) I2C générera toujours une interruption lorsqu’une adresse correspondra à celle indiqué dans le registre SSPADD.
Afin que le PIC puisse être muni d’une adresse, j’ai choisi pour « l’essais » l’adresse 0xA8, et donc intégré cette adresse dans la variable du registre SSPADD.

Niveau programmation pour l’adresse cela donne :
SSPADD :=0xA8 (en MikroPascal) et SSPADD = 0xA8 (en MikroC) tout simplement.


Nous avons donc dans un 1er temps initialisé l’entrée des broches RB0(SDA) et RB1(SCL) comme des entrées et adressé note PIC 18F4550 via le registre SSPADD qui maintenant comporte cette fameuse adresse 0xA8.


Ci-dessous programme de l’initialisation du PIC en mode esclave.

// Initialisation du PIC18F4550
procedure init();
Begin
 
 TRISB := 0x03; // On confirgure les broches du PORT B - RB0 et RB1 comme entrée
 LATB := 0x00;
 
 ADCON1 := 0xFF; //  On configure toutes les broches en numérique.
 ADCON1.VCFG0 := 0; // On active le (VDD) pour couper la référence de tension
 ADCON1.VCFG1 := 0; // On active le (VSS) pour couper la référence de tension
 
 INTCON.GIE := 1; // On active les interruptions globales
 INTCON.GIE := 1; // On active les interruptions globales
 INTCON.PEIE := 1; // On active les interruptions périphériques
 
 PIE1.SSPIE := 1; // On active les interuptions du MSSP 
 PPIR1.SSPIF := 0;  // On met le drapeau à zéro pour commencer
 
 SSPCON1.SSPEN := 1; // On active les broches RB0 et RB1 en mode SDA et SCL
 SSPCON1.SSPM0 := 0;
 SSPCON1.SSPM1 := 1;   // On active le mode 7 bits 
 SSPCON1.SSPM2 := 1;
 SSPCON1.SSPM3 := 1;
 
 SSPADD := 0xA8; // Configuration de l'adresse de l'esclave du PIC 18F4550
 SMP_bit := 1;
 SEN_bit := 0;
 CKP_bit := 1; // le bit CKP NE DOIT PAS être mis à "0" mais à "1" si SEN = 0
 
 bAdresse := False;

 bData1 := False;

 bData2 := False;

 bData3 := False;

end;

Mode I2C – Registre SSPCON1
J’ai évoqué un peu plus haut le registre SSPCON1, mais regardons cela d’un peu plus près!
Pour que le PIC fonctionne en mode esclave, et qu’il puisse communiquer avec l’extérieur dans un sens puis dans l’autre il faut configurer son mode de fonctionnement en agissant sur le registre SSPCON1.


C’est dans ce registre que nous pouvons à présent apercevoir ci-dessus, il est tout à fait possible de paramétrer le PIC en tant qu’esclave. Pour permettre cette échange avec l’extérieur nous devons activer le bit 5 qui correspond à SSPEN à l’état logique « 1 » afin que les broches SDA et SCL soient activer comme un port série.
Ensuite, il suffit de paramétrer notre PIC 18F4550 en mode Esclave en agissant sur les bits SSPM3/SSPM2/SSPM1/SSPM0 afin d’obtenir un mode esclave sur 7 bits avec les interruptions Start et Stop activé.
il en résulte que niveau programmation ça donne ceci :


(Prog MikroPascal)
SSPCON1.SSPEN := 1
SSPCON1.SSPM0 := 0 ;
SSPCON1.SSPM1 := 1;
SSPCON1.SSPM2 := 1 ;
SSPCON1.SSPM3 := 1 ;


(Prog MikroC)
SSPCON1.SSPEN = 1
SSPCON1.SSPM0 = 0 ;
SSPCON1.SSPM1 = 1;
SSPCON1.SSPM2 = 1 ;
SSPCON1.SSPM3 = 1 ;


Enfin, nous avons terminé!! Vous êtes bien sûr ??!! ah non !! j’avais oublié quelque chose d’important.
Allons faire un tour du côté du registre SSPCON2.


Le bit SEN doit être à l’état logique « 0 » afin de ne pas utiliser l’étirement de l’horloge ceci est bien explicite au niveau du DataSheet (voir encadré en rouge) – le bit CKP ne doit pas être remis à l’état logique « 0 » quand le bit SEN est à l’état logique « 0 ».


Réception des octets


Chaque fois qu’un coup est donné par l’horloge maitre sur la broche SCL les bits seront décalés les uns après les autres dans le registre SSPSR.

Comparaison octets et envoi du bit d’acquittement (ACK)


Les 8 bits (1 octets) présents dans le registre SSPSR sont comparés avec l’adresse du PIC du registre SSPADD. Si ces 2 octets sont identique, le matériel en mode esclave I2C générera toujours une interruption sur une correspondance d’adresse.


Transfert des données dans le registre SSPBUFF


Lorsque la correspondance est reçue, le matériel générera automatiquement l’acquittement (ACK) (nul besoin de le programmer) et chargera le registre SSPBUFF avec la valeur reçue actuellement dans le registre SSPSR.Nous pouvons dès à présent lire le registre SSPBUF qui comprend la valeur de l’adresse soit SSPBUF = 10101000. Un octet chargé dans le registrer SSPBUF entrainera la mise à l’état logique « 1 » du bit BF situé dans le registre SSPSTAT. Si aucun octet présent dans le registrer SSPBUF le bit BF sera bien évidemment l’état logique « 0 ».

Attention !!
Si le SSPBUF n’a pas été lu et qu’un autre transfert d’octets de SSPSR à SSPBUFF survient, l’acquittement ne sera pas envoyé, et il est de même pour un débordement qui lui est géré par le bit SSPOV du registre SSPCON1.

Schéma


Logiciel du PIC


Ci-dessous les réglages dans le menu”Edit Project” (MikroPascal ou MikroC) à réaliser. je n’ai pas continué les autres captures d’écran mais tout le reste est à desactiver “Disabled”.


Programme MikroPascal du PIC 18F4550 – MikroPascal


Programme MikroC du PIC 18F4550 – MikroC

Prototype



Non réalisé! mais testé sur Platine EasyPic7 et sur plaque d’expérimentation sans soudure.

Circuit(s) imprimé(s)


Aucun.

Historiques


16/03/2019
-1er mise à disposition

Dernière mise à jour le 16/03/2019

Présentation


Il s’agit du même montage que celui ci Communication I2C – Mode Ecriture – PIC 18F4550 (Maitre) -> PIC 18F4550 (Esclave), sauf que j’utilise non pas un PIC mais un Arduino en tant que maitre. Des précaution sont à prendre entre les échanges de donnée Arduino et PIC 18F4550 surtout lorsque l’Arduino est configuré en tant que maitre et le PIC18F4550 en tant qu’esclave!

Arduino (Maitre) – PIC 18F4550 (Esclave) – Problème d’adressage !!!


Nous allons aborder le fonctionnement entre un Arduino qui est le maitre, et le PIC 18F4550 qui sera l’esclave. Comme vous avez dû le remarquer dans le titre du paragraphe j’ai indiqué « Problème d’adressage » et oui !! il y’en à bien un !


Prenons un exemple, lorsque vous avez configuré le PIC 18F4550 avec pour adresse 0xA8 (soit 10101000b (en binaire) ou bien 168d (en décimal)) et que vous demandez a votre Arduino d’envoyer des données I2C à l’esclave qui possède l’adresse 0xA8 vous allez vous apercevoir que rien ne va fonctionner comme prévu. Étrange vous ne trouvez pas ?Hum.. que ce passe t’il encore ?


Nous avons ici ce qu’on appel un problème de compatibilité entre un Arduino et un PIC, en réalité, lorsque vous adressé 0xA8 au PIC 18F4550, l’Arduino lui devra devra envoyer l’adresse 0x54 étrange non vous ne trouvez pas?


Programme de l’esclave (PIC 18F4550) en MikroPascal:

SSPADD = 0xA8; // Configuration de l’adresse de l’esclave du PIC 18F4550 (Correspond à l’héxadécimal 0x54 pour ARDUINO en mode ecriture)


Programme du maitre (Arduino) en C:

Wire.beginTransmission(0x54); // début de la transmission au périphérique d’adresse)


Côté PIC 18F4550 – En binaire 0xA8 = 10101000b
Côté Arduino – En binaire 0x54 = 01010100b


La différence entre les 2 c’est que si vous regarder bien les nombres en binaires, il y’a eu un décalage de 1 bit vers la droite, il en résulte que si nous adressons par exemple 0x70 à un PIC ce qui donne 01110000 en binaire nous allons donner comme adresse à l’Arduino 00111000b (soit 0x38). Conclusion avec un décalage de 1 bit et pas plus par la droite!!, nous pouvons désormais communiquer entre un Arduino et un PIC.

Schéma


Logiciel du PIC et Arduino


Ci-dessous les réglages dans le menu”Edit Project” (MikroPascal ou MikroC) à réaliser. je n’ai pas continué les autres captures d’écran mais tout le reste est à desactiver “Disabled”.


Programme MikroPascal du PIC 18F4550 – MikroPascal


Programme MikroC du PIC 18F4550 – MikroC

Prototype


Oui prototype réalisé avec Platine EasyPic7 et Arduino le voici le voilà!! on remarque les 4 données via les leds qui sont:

– L’adresse pour le PORTA
– 1ère donnée pour le PORTC de la platine EasyPic7 (1 leds allumée) = 0x02h
– 2ème donnée pour le PORTD de la platine EasyPic7 (2 leds allumées)= 0x03h
– 3ème donnée pour le PORTE de la platine EasyPic7 (3 leds allumées) = 0x07h


Pour finir on remarque bien les 2 fils qui partent de l’Arduino.

Circuit(s) imprimé(s)


Aucun.

Historiques


16/03/2019
-1er mise à disposition

Dernière mise à jour le 02/02/2019

Présentation



Le montage électronique proposé ici, permet de créer un sortie numérique (tout ou rien) basé sur un MOSFET type BS170 et une diode infrarouge.
Lorsque la rayon infrarouge traverse la diode émettrice nous nous retrouvons avec un “1” logique, et lorsque le rayon infrarouge est coupé, nous nous retrouvons avec un “0” logique.
Ce montage est simple puisque nous allons utiliser que des composants standards (résistances et mosfet) tout simplement.
 
J’ai utilisé ce montage électronique pour des trains miniatures à l’échelle N. Le but était de contrôler une barrière de passage à niveau, lorsque le train passait devant la cellule celle-ci se levais et lorsqu’il passait devant le 2ème cellule infrarouge la barrière descendais.

Remarque

Je me sert d’une tension d’alimentation de 5V, car ce montage a été utilisé pour les entrées d’un PIC 16F628A. l’alimentation du PIC était sous 5V, je me suis dis pourquoi pas en faire de même sur le détecteur IR.

Schémas


Fonctionnement
Le schéma à gaucheest la partie emettrice (diode IR infrarouge émettrice), et le schéma côté droit la partie réceptrice, attention à ne pas inverser le brochage des diodes IR cas contraire le montage ne sera pas fonctionnel!!


Diode emettrice

Comme vous pouvez le constater rien de bien compliquer. Le schéma à gauche permet d’alimenter une diode emmetrice IR avec sa résistance de limitations de courant de 330 ohms.
Pour le calcul, on prend la tension d’alimentation qu’on soustrait à la chute de tension aux bornes de la diode IR, et qu’on divise par son courant nominal.


Diode réceptrice
Le schéma à droite quant à lui permet d’alimenter le diode réceptrice sous 5V. Le transistor MOSFET BS170 sera piloté par la diode qui n’est pas représentée sur le schéma (comme la diode emettrice d’ailleurs !!) à vous de faire attention au brochage avec l’anode sur la broche numéro 2 du connecteur J3, et la cathode reliée sur la broche numéro 1 du connecteur J3. En ce qui concerne la résistance R2, elle aussi est uniquement présente pour limiter le courant qui va parcourir la diode réceptrice. Le calcul est identioque au précédent à vous de bien regarde ce que consomme votre diode réceptrice niveau courant et regarde sa chute de tension aux bornes de l’anode et de la cathode.

 

 

MOSFET BS170

Son fonctionnement est basé sur la différence de tension qui est située entre G = gate et S = source. Lorsque lefaisceau IR est “braqué” sur la diode réceptrice, celle-ci se voit passant, et la chute de tension à ces bornes est autour de 0,7V. Dans cette situation le transistor mosfet se retrouve avec une tension entre Gate et la source de 0,7V et qui va le rendre bloqué (ouvert entre son drain et sa source). Il en résulte que tout le courant va se diriger sur la broche numéro 2 du connecteur J5 et la tension sur la broche numéro 2 sera à 5V (“1″ logique”).
En ce qui concerne le courant celui-ci est limiter à 5mA si la broche est relié directement à l’entrée du PIC 16F628A comme énoncé ci-dessus dans la remarque de la présentation (attention!! courant admissible en entrée du PIC16F628A 20mA max!!).
 
Que va t’il se passer lorsque le faisceau n’est plus “braquer” sur la diode émettrice? il va se produire que la diode émettrice n’est plus passante et toute la tension va se retrouvé située aux bornes de Vgs (5V). Dans cette situation le transistor mosfet va être 100% saturé donc passant et la chute de tension aux bornes du drain et de la source sera aux alentour de 0V soit un “0” logique”.
Et bien nous voila avec un signal en tout ou rien sur la broche numéro 2 du connecteur J5!!!.

Prototype


Quelques petits essais, avec la présence de la diode émettrice dans sont boitier opaque, et réceptrice dans sont boitier transparent, quelques fils de liaisons et le transistor mosfet BS170 d’ailleurs on remarque le PIC16F628A et la led RA0 allumée ou non si je positionne mon index pour couper le faisceau infrarouge.
   

   
[…..]

Circuit(s) imprimé(s)


Je vous laisse le typhon si toutefois….


Typon au format PDF

Historiques


02/02/2019
-1er mise à disposition

Présentation


Nous allons maintenant comment exploiter le processeur afin de faire une détection de couleur. Pour cela nous allons voir comment faire un réglage de seuil au niveau de l’image que nous désirons détecter, régler cette image, et ensuite demander à la caméra qu’elle encadre l’image dès que celle-ci est captée.

Création d’une image


Afin de faire cette expérience nous allons ouvrir “paint” sous Windows et dessiner un rond de fond rouge et cadrer l’image comme ceci (peu importe la grosseur):

Ensuite,une fois dessiné, nous allons enregistrer ce « dessin » sur le disque au format (.png). Pour cela débrancher et rebrancher vos Caméra, et vous devez retrouver le disque  comme cela: (pour ma part il s’agit du disque “G:\”)

Une fois enregistré, il suffit de retourner dans l’application OpenMV IDE Afin de vous rendre dans l’éditeur de seuil:

Une fois validé, vous devriez obtenir cette fenêtre:

La fenêtre indique “Tampon trame” c’est à dire l’image qui est située dans le tampon de trame (image filmé) soit “Fichier image” c’est à dire une l’image située sur votre ordinateur ou bien dans le disque de la caméra.
Puisque nous avons enregistré le fameux “rond à fond rouge” dans le disque de la caméra, nous allons donc cliquer sur “Fichier image” afin de l’ouvrir.

Déterminer le seuil des couleurs


Si tout a été respecté jusqu’à ici vous devez obtenir ceci:


Nous nous retrouvons désormais dans le seuil des couleurs qui contient 5 curseurs. le but est “simple” je dis “simple” car vous allez devoir jouer avec ces 5 curseurs pour obtenir un fond noir avec un rond de fond blanc. En effet, les pixels blanc sont les couleurs suivis par la caméra, il en résulte numériquement que l’image va être converti en un fichier binaire il va donc mettre la couleur blanche (pixel blanc) au niveau logique « 1 » et la couleur noir (pixel noir) au niveau logique « 0 ». Il en résulte que seul le niveau logique « 1 » sera pris en compte par la caméra.
Afin de retrouver l’image en noir et blanc, je procède ainsi, tout les curseurs à droite je les passent à gauche, et vice versa ce qui donne:

Programmation



(Clique pour agrandir)

Détails programmation
Niveau programmation, nous allons voir ça de plus près, n’ayez pas peur surtout!!.

– import sensor => Permet d’importer le module sensor (module de caméra pour pouvoir filmer)
– sensor.reset() => Vous l’avez devinez j’en suis sûr!!
– sensor.set_pixformat(sensor.RGB565) => ici nous allons agir sur le réglage des pixel de la caméra en l’occurrence les pixels qui seront en couleur RGB (Red/Green/Blue)=Rouge/Vert/Bleu
– sensor.set_framesize(sensor.QQVGA) => Permet de régler la résolution de la caméra en 600×480
– img = sensor.snapshot() => On capture l’image “réelle” qui sera mis dans une variable.
– for blobs in img.find_blobs([Color_Red], merge=False, margin=5): => Tout le travail est là!!


Commençon par la fonction à regarder la fonction “img.find_blobs([Color_Red], merge=False, margin=5):

« img » correspond à la variable qui récupère ce que la caméra film (déclaré en début du programme). Ensuite nous allons lui ajouter « .find.blobs » qui est une routine qui permet de trouver (find= trouver) un « objet » situé dans son environnement filmé !
Afin de pouvoir retrouver l’objet, nous allons rentrer des paramètres entres ces parenthèses et commencer par “[color_red]”, qui correspond à la couleur que nous voulons détecter via la caméra.

Attention !!! “[color_red]” est situé entre crochet ([]) et il faut impérativement respecter ce procédé, car il s’agit d’un tuple et ce tuple doit être situé entre ces deux crochets!
La valeur du tuple correspond aux réglages des seuils de couleurs que nous avons déterminés et réglés précédemment. Valeur = (34,77,82,2,57,17).
Si tous ces éléments ont été respectés la caméra détectera la couleur rouge situé sur l’écran de votre ordinateur, et encadrera cette couleur par un rectangle vert (voir capture ci-dessus à droite)

Remarque
fimg.find_blobs([Color_Red], merge=False, margin=5): peut-être remplacé par: fimg.find_blobs([(34, 77, 82, 2, 57, 17)], merge=False, margin=5):

Historiques


– 18/01/19
Première mise à disposition.

Allumer des leds pour débuter


Dans cet exemple “simple” nous allons voir comme faire clignoter la led qui est présente sur la carte OpenMV Cam M7. Celle-ci est située à cet endroit (voir entourage rouge)



il s’agit ici d’une led « intelligente » puisque celle-ci peut prendre 3 couleurs différentes qui sont :

– Rouge (Red) = 1 (numéro d’appel pour cette couleur)
– Vert (Green) = 2 (numéro d’appel pour cette couleur)
– Bleu (Blue) = 3 (numéro d’appel pour cette couleur)
– Infrarouge (2 leds IR) = 4 (non pris en compte dans l’exemple pour commencer !

En ce qui concerne le niveau programmation, nous allons faire appel au module « pyb ». ce module permet d’intégrer l’allumage des différentes leds (Rouge/vert/bleu/ et IR), mais permet aussi d’avoir accès aux modules comme :
– CAN
– DAC
– I2C
– SPI
– UART
– etc..

Programmation – 3 leds allumées en même temps!!


La programmation qui va suivre ne fait uniquement allumer les led rouge vert bleu en même temps. le module “pyb” permet d’avoir acces au terme “LED” (bien respecter les majuscules et les espaces). L’inconvénient avec python c’est que nous devons à tout pris respecter les espaces!! je vous laisse voir comment est écrit le programme ci-dessous ainsi que les espaces.

# Allumer des leds - Electronique71.com
 
import pyb  #Importer le module pyb 
 
Led_Red = pyb.LED(1)  # Variable qui correspond à la Led Rouge
Led_Green = pyb.LED(2) # Variable qui correspond à la Led Vert 
Led_Blue = pyb.LED(3) # Variable qui correspond à la Led Bleu 
 
while(True): # On réalise une boucle pour l'exécution du programme 
 
    Led_Red.on()
    Led_Green.on()# on allumes  3 leds en même temps   
    Led_Blue.on()
 

Clignotant


Nous allons voir comment maintenant faire clignoter une seule led (rouge). afin de maitriser le temps, j’ai importer un nouveau module qui est “time” celui-ci permet d’avoir accès au temps qui est exprimé en milliseconde (1sec = 1000ms) .

Ensuite plutot que d’uitliser des variables nommées “Led_Red”, “Led_Green” et “Led_Blue”, j’ai appelé directement la led rouge par “pyb.LED(1).on()”. Si je voulais appeler la LED bleu j’aurais écrit “pyb.LED(3).on()”, et pour la diode IR (que nous ne verrons pas s’allumée puisqu’il s’agit d’une led infrarouge sera “pyb.LED(4).on()”).
Pour éteindre comment faire? et bien tout simplement remplacer “on()” par “off()”

# Clignotant led rouge - Electronique71.com
 
import pyb,time  #Importer module time pour gérer le temps 
 
 
while(True): # On réalise une boucle pour l'exécution du programme, en permanence! 
 
    pyb.LED(1).on() # On allume la LED rouge
    time.sleep(1000) # On attend 1sec 
    pyb.LED(1).off() # On éteint la LED rouge
    time.sleep(1000) # On attend 1sec avant de recommencer

Historiques


– 18/01/19
Première mise à disposition.

21/09/18
– [Microcontrôleur] Mise à jour Interface UsbHid – communication PC -> PIC
– [Microcontrôleur] Mise à jour Interface UsbHid – communication PIC -> PC

07/09/18
– [Programmations Python] Mise à jour Programmations Python

– [Programmations Python] Mise à jour Mes premiers pas en lignes de commande


– [Logiciels] Mise à jour Logiciels

– [Logiciels] Mise à jour Interface UsbHid PC -> PIC
 
16/04/18
– [Microcontrôleur] Mise à jour Afficheur 7 segments – CD4094 avec PIC 12F675
 
09/04/18
– [Logiciels] Mise à jour Logiciels
 
27/03/18
– [Microcontrôleur] Mise à jour Configuration port USB – VID/PID
 
17/03/18
– [Microcontrôleur] Mise à jour Configuration port USB – VID/PID
– [Microcontrôleur] Mise à jour Interface UsbHid – communication PC -> PIC
– [Microcontrôleur] Mise à jour Interface USB – PIC32 – Sorties numériques
 
25/02/18
– [Microcontrôleur] Mise à jour Clignotant 001 avec PIC 16F88
– [Microcontrôleur] Mise à jour Chenillard 001 avec PIC 12F675
 
18/02/18
– [Microcontrôleur] Mise à jour Afficheur 002
– [Microcontrôleur] Mise à jour Afficheur 003
– [Microcontrôleur] Mise à jour Afficheur 7 segments – CD4094 avec PIC 12F675
 
14/02/18
– [Microcontrôleur] Mise à jour Afficheur 001 avec PIC16F88
 
13/02/18
– [Microcontrôleur] Mise à jour EasyPic7
– [Microcontrôleur] Mise à jour La simulation et R&D (Recherche et Développement) c’est quoi?
 
10/02/18
– [Microcontrôleur] Mise à jour Configurations entrées/sorties (I/O) => MikroC disponible
– [Microcontrôleur] Mise à jour Configurations entrées analogiques (A/N) => MikroC disponible
– [Microcontrôleur] Mise à jour Les interruptions – Timer1 => MikroC disponible
– [Microcontrôleur] Mise à jour Les interruptions – Timer2/Timer3 => MikroC disponible
– [Microcontrôleur] Mise à jour Capture d’un signal en entrée (Input Capture)  => MikroC disponible
– [Microcontrôleur] Mise à jour Présentation et réglage Mini-32 (PIC32)
 
03/02/18
– [PIC 32] Mise à jour PIC 32
– [Microcontrôleur] Mise à jour Configurations entrées/sorties (I/O)
– [Microcontrôleur] Mise à jour Configurations entrées analogiques (A/N)
– [Microcontrôleur] Mise à jour Les interruptions
– [Microcontrôleur] Mise à jour Les interruptions – Timer1
– [Microcontrôleur] Mise à jour Les interruptions – Timer2/Timer3
– [Microcontrôleur] Mise à jour Capture d’un signal en entrée (Input Capture) 
– [Microcontrôleur] Mise à jour Sortie de comparaison (Output Compare) – PWM 

Dernière mise à jour le 07/09/18

Présentation de la fenêtre de commande Python


Dans cet exemple nous allons tester des lignes de commandes via l’interface Python. L’interface python est en définitive une console de commande identique à la commande d’invitation (CMD) que vous avez dans le menu démarrer de votre ordinateur.

Hello World!


Nous allons commencer par le strict minimum, c’est-à-dire d’afficher le fameux Hello World sur l’affichage d’une console.
Pour cela, il vous suffit de taper dans la ligne de commande et de faire entrer:
print("Hello World!")

Une fois ceci réalisé il suffit de taper sur la touche entrer, et vous devez voir ceci

Vous pouvez bien entendu mettre ce que vous désirez à l’intérieur des guillemets, mais l’écriture (la chaîne de caractères) doit toujours être situés entre les guillemets.
 
Vous pouvez aussi ecrire du texte dans un variable et que cette variable soit lue ce qui donne:
Variable = "Hello World!"
print(variable)

Dans ce cas la variable na pas besoin de guillemet puisque dans cette variable “Hello World!” est déja entre guillemet

 

 
Créer un dossier sur le bureau


Nous allons voir maintenant comment créer un dossier sur le bureau avec un terminal. Pour cela il suffit de faire:
import os
path = "C:/Users/Julien/Desktop/Dossier_Python"
os.mkdir(path)
 
Ainsi, si vous retrouné sur votre bureau vous devriez voir le dossier nommé “Dossier_Python”

Supprimer un dossier sur le bureau


Nous avons vu comment créer un dossier, maintenant nous allons voir comment le supprimer. Pour cela il suffit de faire:
import os
path = "C:/Users/Julien/Desktop/Dossier_Python"
os.rmdir(path)
 
Ainsi, le dossier nommé “Dossier_Python” est supprimé de l’ordinateur

Renommer un dossier sur le bureau


Nous allons renommer le dossier qui a été crée précédemment.
import os
OldFodler = "C:/Users/Julien/Desktop/Dossier_Python"
NewFolder = "C:/Users/Julien/Desktop/Nouveau_Dossier_Python"
os.rename(OldFodler,NewFolder)
 
Ainsi, le dossier nommé “Dossier_Python” est passé en “Nouveau_Dossier_Python

Créer un bloc note dans un dossier sous le bureau


On va créer une dossier, et ensuite créer un bloc note dans ce dossier:
import os
Folder = "C:/Users/Julien/Desktop/Dossier_Python"
NewFile = "C:/Users/Julien/Desktop/Dossier_Python/Fichier_Python.txt"
os.mkdir(Folder)
File = open(NewFile,"x")
File.close()
 
Ainsi, vous trouverez dans le dossier “Dossier_Python” un bloc note nommé “Fichier_Python.txt”.

Créer un bloc note dans un dossier sous le bureau et écrire dedans


Nous allons maintenant créer un dossier, créer un bloc note, et écrire dans ce bloc note ce qui nous donne:
import os
Folder = "C:/Users/Julien/Desktop/Dossier_Python"
NewFile = "C:/Users/Julien/Desktop/Dossier_Python/Fichier_Python.txt"
os.mkdir(Folder)
File = open(NewFile,"x")
File.close()
WriteFile = open(NewFile,"w")
WriteFile.write("Ceci est une ligne\n")
WriteFile.write("Ceci est une 2eme ligne\n")
WriteFile.close()

Lire un bloc note situé dans un dossier


Nous allons lire le bloc note situé dans le dossier.
import os
NewFile = "C:/Users/Julien/Desktop/Dossier_Python/Fichier_Python.txt"
ReadFile = open(NewFile,"r")
print(ReadFile.read())

Plus d’informations


r => pour une ouverture en lecture (READ).
w => pour une ouverture en écriture (WRITE), à chaque ouverture le contenu du fichier est écrasé. Si le fichier n’existe pas python le crée.
a => pour une ouverture en mode ajout à la fin du fichier (APPEND). Si le fichier n’existe pas python le crée.
b => pour une ouverture en mode binaire.
t => pour une ouverture en mode texte.
x => crée un nouveau fichier et l’ouvre pour écriture

1 2 3 21