Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Raspberry Pi Discussion :

Bus Pirate (v3.6a) TOL 12942 de Sparkfun !


Sujet :

Raspberry Pi

  1. #1
    Expert éminent sénior
    Bus Pirate (v3.6a) TOL 12942 de Sparkfun !
    Salut à tous.

    J'ai fait l'acquisition du bus pirate (v3.6a) TOL 12942 de chez Sparkfun.
    --> https://www.gotronic.fr/art-module-b...2942-24664.htm

    Je désire exploiter ce bus pirate pour des raisons d'apprentissage, et aussi faire mumuse en électronique.

    Pour l'instant, j'ai fait un seul test (mode DIO), celui de faire clignoter une led.
    Comme j'avais le matériel nécessaire à ce test, cela n'a pas été trop compliqué.
    Entre autre, j'avais fait le test avec ma raspberry de créer un chenillard en utilisant un montage assez complet :
    --> un bradboard
    --> des leds rouge, jaune et verte
    --> des résistances
    --> des boutons-poussoirs
    --> un t-cobbler
    --> du fil rigide de couleurs rouge et jaune pour relier les différents composants.

    J'ai même fait le test en introduisant un mini script en BASIC.

    Je désire poursuivre mon apprentissage en utilisant les autres possibilités qu'offre le bus pirate.
    La difficulté que je rencontre est l'achat du matériel élctronique.
    pour l'instant, je me suis inspiré de deux didacticiels :
    --> https://kb99.wordpress.com/2016/11/1...du-bus-pirate/
    --> https://skyduino.wordpress.com/2011/...ute-situation/

    Mais comme je suis débutant en électronique, je rencontre des difficilutés

    1) j'ai fait l'acquisition d'un afficheur LCD 20x4 de chez Joy-It (HD44780) :
    --> https://www.gotronic.fr/art-afficheu...eres-25649.htm
    Cela m'a permis de créer un programme en 'C/C++' où j'affiche depuis ma raspberry, du texte et quelques animations.

    Sauf que je ne peux pas l'utiliser avec le bus pirate.
    Le fautif est le backpack qui se trouve à l'arrière (PCF8574) et qui fonctionne en I2C. L'afficheur doit être un HD44780.
    Je vais en acheté un autre (LCD 2x16), en espérant ne pas me tromper dans mon acquisition, sans ce backpack :
    --> https://www.gotronic.fr/art-afficheu...16sbh-2236.htm

    Oui mais, pour l'utiliser, il me faut un câble spécial (Probe kit) :
    --> https://www.seeedstudio.com/Bus-Pira...ble-p-932.html
    et un adaptateur pour piloter ce HD44780 :
    --> https://www.seeedstudio.com/Bus-Pira...-v3-p-684.html
    Et comme on peut le lire, c'est "out of stock" !

    Je ne sais pas où me procurer ces deux accessoires ???

    2) j'aimerai faire le test en mode SPI (Serial Peripheral Interface).
    Pour cela, j'ai besoin :
    --> un bradboard
    --> un 74HC595
    --> des résistances
    --> des leds
    --> un condensateur de 0.1"f (???)

    Je m'inspire du site consacré à l'arduino pour effectuer le montage :
    --> https://www.arduino.cc/en/Tutorial/ShiftOut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    +---------+---------+-------------+
    |  Broche | libellé | Désignation |
    | 74HC595 | 74HC595 |             |
    +---------+---------+-------------+
    |   15    |    Q0   |   Led N°1   |
    |    1    |    Q1   |   Led N°2   |
    |    2    |    Q2   |   Led N°3   |
    |    3    |    Q3   |   Led N°4   |
    |    4    |    Q4   |   Led N°5   |
    |    5    |    Q5   |   Led N°6   |
    |    6    |    Q6   |   Led N°7   |
    |    7    |    Q7   |   Led N°8   |
    +---------+---------+-------------+
    Chaque Led sera reliée à une résistance et à la masse (GND).

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    +---------+---------+---------------------------------------+---------------+------------+
    |  Broche | libellé |              Désignation              |    Broche     |   Broche   |
    | 74HC595 | 74HC595 |                74HC595                |    Arduino    | Bus Pirate |
    +---------+---------+---------------------------------------+---------------+------------+
    |     8   |   GND   | Ground, Vss                           |    Ground     |    GND     |
    |     9   |   Q7"   | Serial Out                            |               |            |
    |    10   |   MR    | Master Reclear, active low            |               |    +5V     |
    |    11   |  SH_CP  | Shift register clock pin              | DigitalPin 12 |    TCK     |
    |    12   |  ST_CP  | Storage register clock pin (latch pin)| DigitalPin  8 |    CS      |
    |    13   |   OE    | Output enable, active low             |               |    GND     |
    |    14   |   DS    | Serial data input                     | DigitalPin 11 |    MOSI    |
    |    16   |   Vcc   | Positive supply voltage               |      Vcc      |    +5V     |
    +---------+---------+---------------------------------------+---------------+------------+
    Sur le schéma suivant :



    je vois trois résistances identiques (marron - noir - orange - or : 10K ohms 5%).
    --> https://www.digikey.fr/fr/resources/...or-code-4-band

    N'est-ce pas trop important comme valeur (10K ohms) ?
    Avec mes "LEDS 5MM ÉCONOMIQUES", j'ai placé des résistances à 1k ohms.
    La luminosité ne m'intéresse pas. Je désire voir si la led s'allume ou pas.

    Ensuite, je vois, ce qui me semble être un condensateur "100 nk 63".
    Si j'ai bien compris, ceci est un MKT type "millefeuille" et se lit "100 nF" tolérance "10%" tension de service "63 Volts".



    Que dois-je comprendre par cette notation 0.1"f ? 0.1 micro farad ? C'est-à-dire 100 nano farad ?
    A me confirmer par ce que je ne suis pas du tout sûr de moi.

    Que pensez-vous de ce montage ?
    Manque-t-il quelque chose ? Si oui, quoi ?

    3) le mode ADC (analog to digital converter).
    Je désire me procurer un potentiomètre de 10k ohms.
    Oui, sauf que je ne sais pas du tout lequel prendre :
    --> https://www.gotronic.fr/cat-potentiometres-263.htm

    il y a ds potentiomètres :
    --> MONOS LINÉAIRES ÉCONOMIQUES
    --> MONOS LINÉAIRES (A)
    --> MONOS LOGARITHMIQUES
    --> MONOS LINÉAIRES À PISTE CERMET
    --> DOUBLES LINÉAIRES (A)
    --> DOUBLES LOGARITHMIQUES (B)
    --> MONOS LINÉAIRES À INTERRUPTEUR
    --> BOBINÉS 4W
    --> MONOS LINÉAIRES ÉTANCHES
    --> BOBINÉS 10 TOURS
    --> MOTORISÉS

    Quand on ne sait pas, la difficulté réside dans le choix que l'on doit faire.

    Il ne doit servir uniquement pour ce test mais à d'autres usages.
    Autant faire en sorte qu'il soit polyvalent.

    4) le mode I2C.
    Que prendre comme module RTC (Real Time Clock) ?
    J'aime bien celui-ci :
    --> https://www.gotronic.fr/art-module-h...3296-25536.htm

    Il peut se brancher sur n'importe quel breaboard.
    Qu'est-ce que vous en pensez ?

    5) je désire faire une prise de contrôle du bus pirate à partir de windows, sous la forme d'un script écrit en "C/C++" qui va gérer la console uart.
    Cela va me permettre de ne pas retaper systématiquement l'ensemble des commandes pour les tests sur le bus pirate.
    Avez-vous déjà fait ce genre de programme ?

    6) Et pour finir, avez-vous utilisez ce bus pirate et à quelle occasion ?
    Qu'est-ce que vous en pensez ?

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  2. #2
    Modérateur


    Plusieurs choses, en essayant de garder l'ordre des questions.

    1) Ton afficheur avec backpack devrait convenir étant donné qu'il est un convertisseur I2C/parallèle. Mais l'afficheur sans backpack te permettra le mettre en oeuvre le 2)

    2) Prends en 2 pour les cascader, tu pourras ainsi faire un port 16 bits. Les 10k sur le photo sont probablement des résistances de pulldown très probablement reliées aux broches ST_CP, SH_CP et RST/ afin de fixer les états de ces broches clés si elles seraient connectées à rien.

    --> x1 breadboard
    --> x2 74HC595
    --> x10 résistances 10k (pullup ou down un passe partout)
    --> x10 résistances 270 Ohms (pour allumer des LED c'est bien, sous 5V ça donne grosso modo un 10aine de mA. Le grosso modo dépendant de la LED)
    --> x10 résistances 1k (en jouant avec les associations parallèles/séries on arrive a recomposer d'autres valeurs, avec 3 résistances de 1k en parallèle on peut refaire une 330 Ohms)
    --> des leds
    --> plusieurs condensateurs de valeurs 100nF (MKT), 1µF (électrochimique), 10µF (électrochimique)

    Oui le condensateur jaune que tu montres est bien un condo de type film plastique (MKT = polyester métallisé auto cicatrisant, il supporte très bien les petites surtensions.), ils sont parfait pour déparasiter les circuits intégrés, on doit en toute rigueur en mettre un au plus proche de chaque circuit intégré. Les électrochimiques sont polarisés et servent plus à stabiliser/filtrer l'alimentation principale.

    3) Le mode ADC ? C'est quoi ce mode ?

    4) Je n'ai pas pu lire toute les docs mais il faut que tu t'assures de la compatibilité des tensions. Le 74HCT595 s'alimente entre 4.5V et 5.5V tandis que le 74HC595 s'alimente entre 2V et 6V. Le module RTC est parfait mais il cause en 5V pas en 3.3V. Je crois comprendre que tout est ok ici mais je n'ai pas pu tout lire.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  3. #3
    Expert éminent sénior
    Salut Vincent PETIT.

    1) en ce qui concerne mon afficheur HD44780 avec backpack, en mode I2C, je ne suis pas arrivé à le faire fonctionner avec le bus pirate, et c'est dommage.
    Le branchement est correcte car j'arrive à identifier l'adresse I2C et à l'allumer ou à l'éteindre, mais pas à afficher quoi que ce soit.

    2) Normalement, le cas 2) est indépendant des autres paragraphes.
    Le but de d'apprendre à gérer le SPI et je n'ai besoin que d'un seul 74HC595 et de 8 leds.

    Quand tu me conseilles de prendre deux 74HC595, est-ce pour l'afficheur HD44780 ?
    Si la réponse est oui, je suis intéressé de comprendre comment faire.
    A moins que le fait d'associer deux 74HC595 suffit largement à piloter l'afficheur HD44780.

    Cela va remplacer l'adaptateur v3 de chez seeedstudio qui est en rupture de stocke :
    --> https://www.seeedstudio.com/Bus-Pira...-v3-p-684.html

    3) Le mode ADC n'est pas une fonctionnalité du bus pirate, mais une broche de celui-ci.
    En fait, il s'agit du mode DIO. J'ai déjà utilisé ce mode avec le test de la led.
    Le but est d'effectuer une lecture analogique d'un potentiomètre.

    Sinon, as-tu quelques explications à me fournir en ce qui concerne l'achat du potentiomètre ?
    Pourquoi ne pas faire l'acquisition du "POTENTIOMÈTRES MONOS LINÉAIRES ÉCONOMIQUES" à 10K ohms ?

    4) je peux utiliser le bus pirate en 3,3Vcc et en 5Vcc. Mais l'acquisition du RTC n'est pas que pour le bus pirate.
    J'aimerai aussi le tester avec la raspberry, voire avec un prochain achat, le ESP32.
    A la base, ce RTC est destiné à l'arduino, d'où le 5Vcc.
    Pourquoi ce RTC ? Car il est très similaire à celui de l'exemple donné pour tester le bus pirate :
    --> https://skyduino.wordpress.com/2011/...ute-situation/
    Voici la photo en question :
    --> https://www.sparkfun.com/products/12708



    sauf que chez Kubii ou Gotronic, il n'est pas en vente.

    Sinon, il y a celui-ci, chez Gotronic, qui fonctionne en 3,3Vcc :
    --> https://www.gotronic.fr/art-module-h...013-24708.htm*
    sauf qu'il a huit broches et non cinq comme l'autre :



    En résumé, pour le premier RTC, les broches sont : GND, 5V, SDA, SCL et SQW.
    Pour le second, les broches sont : VIN, GND, SCL, SDA, BAT, 32K, SQW et RST.

    Je suppose que la broche VIN, est équivalente à la broch 5V sauf que dans ce cas, nous avons du 3,3Vcc.
    Reste les broches BAT, 32K et RST dont je ne sais à quoi elles peuvent servir.

    Ou alors celui-là :
    --> https://www.gotronic.fr/art-module-h...3295-25537.htm
    qui possède les cinq broches et fonctionne aussi bien en 3,3Vcc qu'en 5Vcc.

    5) j'ai commencé mes recherches sur le net, afin de trouver un programme qui puisse prendre le contrôle du bus pirate.
    Il s'agit de "Serial Communications in Win32" écrit en C
    Je préfère pour l'instant le faire sous windows. Pourquoi ?
    Parce que le bus pirate, je l'utilise connecté à mon ordinateur Windows 10 Pro.
    Si je devais l'utiliser depuis la raspberry, cela serait un peu plus compliqué.
    Car j'accède à la raspberry par putty depuis windows 10 Pro.
    Je pense qu'il y a un intermédiaire, la raspberry, qui n'est pas très utile pour ce que je veux faire.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  4. #4
    Modérateur

    Salut

    Citation Envoyé par Artemus24 Voir le message
    1) en ce qui concerne mon afficheur HD44780 avec backpack, en mode I2C, je ne suis pas arrivé à le faire fonctionner avec le bus pirate, et c'est dommage.
    Le branchement est correcte car j'arrive à identifier l'adresse I2C et à l'allumer ou à l'éteindre, mais pas à afficher quoi que ce soit.
    Ça c'est bizarre, si tu arrives à identifier l'I2C et allumer/éteindre l'afficheur c'est que ça fonctionne. Il faudrait creuser.


    Citation Envoyé par Artemus24 Voir le message
    Le but de d'apprendre à gérer le SPI et je n'ai besoin que d'un seul 74HC595 et de 8 leds.
    D'accord, cependant le 74HC595 n'intègre pas le SPI même si ça y ressemble beaucoup (une liaison série synchrone). Un composant SPI a permet de dialoguer par les broches Master In Slave Out et Master Out Slave In, dès fois on les nome ausso SDI SDO pour slave data in et out et possède des réglages de polarité et phase, en gros c'est toi qui définie l'état de repos de l'horloge (quand tu ne t'en sers pas) et la validation des données sur les fronts montants ou descendants de l'horloge.


    Citation Envoyé par Artemus24 Voir le message
    Quand tu me conseilles de prendre deux 74HC595, est-ce pour l'afficheur HD44780 ?
    Si la réponse est oui, je suis intéressé de comprendre comment faire.
    A moins que le fait d'associer deux 74HC595 suffit largement à piloter l'afficheur HD44780.
    Oui avec deux 74HC595 en cascade tu peux reconstituer un port de sortie 16 bits capable de piloter l'interface parallèle du HD44780. Et cette fois ci en mode 8 bits, donc plus rapidement et en facilitant l'interprétation du tableau dans la doc. Sur l'image ci dessous, au lieu de connecter des LED + résistances au 74HC595, on y connecte l'afficheur (E, R/W, RS, D0, D1, D2, D3, D4, D5, D6, D7)





    Citation Envoyé par Artemus24 Voir le message
    Cela va remplacer l'adaptateur v3 de chez seeedstudio qui est en rupture de stocke :
    --> https://www.seeedstudio.com/Bus-Pira...-v3-p-684.html
    Pour moi c'est exactement la même chose que le backpack de ton afficheur I2C. L'afficheur sera relié en mode 4 bits si j'en crois l'absence de piste sur le connecteur qui va à l'afficheur. Je n'arrive pas à lire la référence sur le composant, mais ça pourrait être un 74HC595 ça fonctionnerait. Ça pourrait être aussi un I/O expander 8 bits I2C ou SPI ? En fait n'importe quel convertisseur série/parallèle conviendrait. Exemple ci dessous d'un I/O expander 16 bits adressable en SPI ou I2C.





    Citation Envoyé par Artemus24 Voir le message
    3) Le mode ADC n'est pas une fonctionnalité du bus pirate, mais une broche de celui-ci.
    En fait, il s'agit du mode DIO. J'ai déjà utilisé ce mode avec le test de la led.
    Le but est d'effectuer une lecture analogique d'un potentiomètre.
    Je n'avais pas vu cette fonctionnalité.


    Citation Envoyé par Artemus24 Voir le message
    Sinon, as-tu quelques explications à me fournir en ce qui concerne l'achat du potentiomètre ?
    Pourquoi ne pas faire l'acquisition du "POTENTIOMÈTRES MONOS LINÉAIRES ÉCONOMIQUES" à 10K ohms ?
    Prends du linéaire, les moins chers, les bobinés c'est souvent pour faire passer de la puissance dedans, les logarithmes A et B (log ou anti log en quelque sorte) c'est pour l'audio car ça correspond à la réponse de l'oreille humaine, quant aux autres on est sur des matériaux internes de qualité pour éviter les "cracs" ou crachats en audio ou des bruits électroniques ou autre parasite. Dans un appareil qui vibre, un potentiomètre bas de gamme peut être source de problème. Pour info, on peut faire un potentiomètre pseudo logarithmique avec un potentiomètre linéaire + une résistance.

    Prends plusieurs valeurs si tu peux, parfois des valeurs basses sont utiles ; 470 Ω, 1kΩ et 10kΩ


    Citation Envoyé par Artemus24 Voir le message
    4) je peux utiliser le bus pirate en 3,3Vcc et en 5Vcc. Mais l'acquisition du RTC n'est pas que pour le bus pirate.
    J'aimerai aussi le tester avec la raspberry, voire avec un prochain achat, le ESP32.
    Ok alors c'est là qu'il faut faire attention à la suite car sur un Raspberry l'I2C c'est du 3.3V. L'ESP32 je ne pas lu la doc mais j'ai tendance à penser que c'est pareil. Il faut s'assurer que les tensions soient toutes compatibles (même pour le 74HC595.... /!\ HCT = 5V, HC = 3.3V)
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  5. #5
    Expert éminent sénior
    Salut Vincent PETIT.

    Citation Envoyé par Vincent PETIT
    Ça c'est bizarre, si tu arrives à identifier l'I2C et allumer/éteindre l'afficheur c'est que ça fonctionne. Il faudrait creuser.
    J'ai créé un programme en 'C/C++' qui pilote l'afficheur HD44780 avec son backpack PCF8574. Ca fonctionne parfaitement.
    Mais avec le bus pirate, c'est une autre histoire car tout se fait manuellement.
    Si je prends l'exemple du reset, qui est basique comme commande, cela ne fonctionne pas.
    Il est vrai que je n'ai pas trop creuser la question.

    Il existe une fonction LCD HD44780 dans le bus pirate, mais elle fonctionne avec "Bus Pirate LCD adapter v3".
    Pour faire fonctionner cette interface, rien de plus simple. Il suffit :
    --> d'initialiser l'afficheur en fonction du nombre de lignes,
    --> de positionner le curseur et
    --> de taper le texte entre guillemet.

    Il y a seize broches dans l'afficheur HD44780 : Vss(GND),Vdd(+5Vcc),Vo,Rs,R/W,E(En),DB0,DB1,DB2,DB3,DB4,DB5,DB6,DB7,A,K.
    Je vais devoir approfondir le montage de deux 74HC595 sur un breadboard.

    Le but est de piloter l'afficheur HD44780 en mode 8bits qui est bien plus complet que le mode 4bits.

    Voici un lien plus complet sur "Bus Pirate LCD adapter v3" :
    --> http://dangerousprototypes.com/docs/...ardware_design
    La réponse est un "74HCT595 shift register".

    Citation Envoyé par Vincent PETIT
    Pour moi c'est exactement la même chose que le backpack de ton afficheur I2C. L'afficheur sera relié en mode 4 bits si j'en crois l'absence de piste sur le connecteur qui va à l'afficheur.
    Tu as raison. Voici la réponse en anglais qui se trouve dans le lien ci-dessus.
    The LCD is controlled in 4bit mode, using 4 pins of the 74HCT595's output for the D7-D4 LCD pins. Another 3 pins are used for LCD's control signals. The LED (LED1) is driven by the 8th pin of the '595.
    Citation Envoyé par Vincent PETIT
    Prends du linéaire, les moins chers,
    Pour le potentiomètre, je vais suivre ton conseil. Merci.

    Citation Envoyé par Vincent PETIT
    Prends plusieurs valeurs si tu peux, parfois des valeurs basses sont utiles ; 470 ?, 1k? et 10k?
    Ceux là :
    --> https://www.gotronic.fr/art-potentio...8486-11104.htm
    --> https://www.gotronic.fr/art-potentio...8486-11105.htm
    --> https://www.gotronic.fr/art-potentio...-937-11108.htm
    l'unité est au prix de 0,80€.

    Citation Envoyé par Vincent PETIT
    Il faut s'assurer que les tensions soient toutes compatibles (même pour le 74HC595.... /!\ HCT = 5V, HC = 3.3V)
    Comme celui-ci que je peux installer sur un bradboard :
    --> https://www.gotronic.fr/art-74hc595-10102.htm
    ou bien celui-là :
    --> https://www.gotronic.fr/art-module-a...c595-20150.htm

    Je vais devoir poser la question à Gotronic.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  6. ###raw>post.musername###
    Expert éminent sénior
    Salut à tous.

    J'ai fait une prise de contrôle de mon Bus Pirate, à partir de Windows, par un programme C / Win32.
    Celui-ci envoie une commande et attend la réception.

    Le test est fort simple. Il s'agit de faire clignoter une LED.

    J'ai créé une DDL de nom "libcom". Voici les fonctions que j'utilise :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    #include <windows.h>
    #include <stdlib.h>
    #include <stdio.h>
     
    #include "libcom.h"
     
    /*********************************************************/
    /*                                                       */
    /*     Les fonctions de communications en mode série     */
    /*                                                       */
    /*=======================================================*/
     
    HANDLE hComm = NULL;
     
    /*========================================*/
    /*     Réception Chaîne de caractères     */
    /*========================================*/
     
    BOOL ReadCOM(LPVOID buffer, DWORD nBytesToRead, LPDWORD pBytesRead)
    {
    	return ReadFile(hComm, buffer, nBytesToRead, pBytesRead, NULL);
    }
     
     
    /*====================================*/
    /*     Envoi chaîne de caractères     */
    /*====================================*/
     
    BOOL WriteCOM(LPVOID buffer, DWORD nBytesToWrite, LPDWORD pBytesWritten)
    {
    	return WriteFile(hComm, buffer, nBytesToWrite, pBytesWritten, NULL);
    }
     
     
    /*==============================================*/
    /*     Affectation du masque des évènements     */
    /*==============================================*/
     
    BOOL SetEvtMask(DWORD evtMask)
    {
    	return SetCommMask(hComm, evtMask);
    }
     
     
    /*===============================================*/
    /*     Récupération du masque des évènements     */
    /*===============================================*/
     
    BOOL GetEvtMask(LPDWORD evtMask)
    {
    	return GetCommMask(hComm, evtMask);
    }
     
     
    /*========================================*/
    /*     Mise en Attente d'un évènement     */
    /*========================================*/
     
    BOOL WaitEvent(LPDWORD evtMask, LPOVERLAPPED overlapped)
    {
    	return WaitCommEvent(hComm, evtMask, overlapped);
    }
     
     
    /*=======================================*/
    /*     Envoi d'une commande spéciale     */
    /*=======================================*/
     
    BOOL EscapeFunction(DWORD func)
    {
    	return EscapeCommFunction(hComm, func);
    }
     
     
    /*===========================*/
    /*     Purge des tampons     */
    /*===========================*/
     
    BOOL Purge(DWORD flags)
    {
    	return PurgeComm(hComm, flags);
    }
     
     
    /*===============================*/
    /*     Configuration TimeOut     */
    /*===============================*/
     
    BOOL TimeOuts(COMMTIMEOUTS ctoParams)
    {
    	return SetCommTimeouts(hComm, &ctoParams);
    }
     
     
    /*===========================*/
    /*     Configuration DCB     */
    /*===========================*/
     
    BOOL State(DCB dcbParams)
    {
    	return SetCommState(hComm, &dcbParams);
    }
     
     
    /*===========================*/
    /*     Ouverture du Port     */
    /*===========================*/
     
    BOOL OpenCOM(COMMTIMEOUTS ctoParams, DCB dcbParams)
    {
    	hComm = CreateFile("\\\\.\\COM5",
    						GENERIC_READ|GENERIC_WRITE,
    						0,
    						NULL,
    						OPEN_EXISTING,
    						FILE_ATTRIBUTE_SYSTEM,
    						NULL);
     
    	if (hComm == INVALID_HANDLE_VALUE)
    	{
    		printf("Erreur lors de l'ouverture du port COM5\n");
    		return FALSE;
    	}
     
    /* FILE_FLAG_OVERLAPPED */
     
    	/*-------------------------------------------------------*/
    	/*     Tailles des tampons d'émission et de récption     */
    	/*-------------------------------------------------------*/
     
    	SetupComm(hComm, 4096, 4096);
     
    	/*-------------------------------------*/
    	/*     Configuration du port série     */
    	/*-------------------------------------*/
     
    	if (!TimeOuts(ctoParams) || !State(dcbParams))
    	{
    		printf("Erreur lors de la configuration du port COM5\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return FALSE;
    	}
     
    	/*------------------------------*/
    	/*     On purge les tampons     */
    	/*------------------------------*/
     
    	Purge(PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
     
    	EscapeFunction(SETDTR);
     
    	/*----------------------------------------------*/
    	/*     Configuration du masque de réception     */
    	/*----------------------------------------------*/
     
    	if (SetEvtMask(EV_RXCHAR) == FALSE)
    	{
    			printf("Erreur de configuration masque de réception\n");
    			return FALSE;
    	}
    	else	return TRUE;
    }
     
     
    /*===========================*/
    /*     Fermeture du Port     */
    /*===========================*/
     
    BOOL CloseCOM(void)
    {
    	/*------------------------------*/
    	/*     On purge les tampons     */
    	/*------------------------------*/
     
    	EscapeFunction(CLRDTR);
     
    	Purge(PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
     
    	/*-------------------*/
    	/*     Fermeture     */
    	/*-------------------*/
     
    	CloseHandle(hComm);
    	hComm = NULL;
    	return TRUE;
    }

    Et voici les déclaratives (libcom.h) de ses fonctions :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    /*=======================================================*/
    /*                                                       */
    /*     Les fonctions de communications en mode série     */
    /*                                                       */
    /*=======================================================*/
     
    #ifndef _LIBCOM_
    #define _LIBCOM_
     
    BOOL ReadCOM(LPVOID buffer, DWORD nBytesToRead, LPDWORD pBytesRead);
    BOOL WriteCOM(LPVOID buffer, DWORD nBytesToWrite, LPDWORD pBytesWritten);
    BOOL SetEvtMask(DWORD evtMask);
    BOOL GetEvtMask(LPDWORD evtMask);
    BOOL WaitEvent(LPDWORD evtMask, LPOVERLAPPED overlapped);
    BOOL EscapeFunction(DWORD func);
    BOOL Purge(DWORD flags);
    BOOL TimeOuts(COMMTIMEOUTS ctoParams);
    BOOL State(DCB dcbParams);
    BOOL OpenCOM(COMMTIMEOUTS ctoParams, DCB dcbParams);
    BOOL CloseCOM(void);
     
    #endif

    Les déclaratives du port série de mon Bus Pirate :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    /********************************************/
    /*                                          */
    /*     Délais d'attente sur le port COM     */
    /*                                          */
    /********************************************/
     
    COMMTIMEOUTS ctoParams =
    {							/*=============================*/
    	50,						/* ReadIntervalTimeOut         */
    	10,						/* ReadTotalTimeOutMultiplier  */
    	50,						/* ReadTotalTimeOutConstant    */
    	0,						/* WriteTotalTimeOutMultiplier */
    	0						/* WriteTotalTimeOutConstant   */
    };							/*=============================*/
     
    /*************************************/
    /*                                   */
    /*     Configuration du port COM     */
    /*                                   */
    /*************************************/
     
    DCB dcbParams =
    {							/*===================*/
    	sizeof(DCB),			/* DCBlength         */
    	115200,					/* BaudRate          */
    	TRUE,					/* fBinary           */
    	FALSE,					/* fParity           */
    	FALSE,					/* fOutxCtsFlow      */
    	FALSE,					/* fOutxDsrFlow      */
    	DTR_CONTROL_ENABLE,		/* fDtrControl       */
    	FALSE,					/* fDsrSensitivity   */
    	FALSE,					/* fTXContinueOnXoff */
    	FALSE,					/* fOutX             */
    	FALSE,					/* fInX              */
    	FALSE,					/* fErrorChar        */
    	FALSE,					/* fNull             */
    	RTS_CONTROL_ENABLE,		/* fRtsControl       */
    	FALSE,					/* fAbortOnError     */
    	0,						/* fDummy2           */
    	0,						/* wReserved         */
    	0x100,					/* XonLim            */
    	0x100,					/* XoffLim           */
    	8,						/* ByteSize          */
    	NOPARITY,				/* Parity            */
    	ONESTOPBIT,				/* StopBits          */
    	0x11,					/* XonChar           */
    	0x13,					/* XoffChar          */
    	'?',					/* ErrorChar         */
    	0x1A,					/* EofChar           */
    	0x10					/* EvtChar           */
    };							/*===================*/

    Et enfin le programme qui me permet de piloter mon Bus Pirate :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    /*******************************************/
    /*                                         */
    /*     Prise de Controle du Bus Pirate     */
    /*                                         */
    /*******************************************/
     
    #include <windows.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <conio.h>
    #include <unistd.h>
     
    #include <libcom.h>
    #include "params.h"
     
    /*=======================*/
    /*                       */
    /*     Mes Fonctions     */
    /*                       */
    /*=======================*/
     
    void init(void)
    {
    	printf("+-----------------------------------------+\n");
    	printf("|     Serial Transmission (Win32 APi)     |\n");
    	printf("+-----------------------------------------+\n\n");
     
    	printf("    Port : COM5\n");
    	printf("BaudRate : %d\n", dcbParams.BaudRate);
    	printf("ByteSize : %d\n", dcbParams.ByteSize);
    	printf(" StopBit : %d\n", dcbParams.StopBits);
    	printf("  Parity : %d\n", dcbParams.Parity);
    }
     
     
    void envoi(char *Buffer)
    {
    	int		i,j;
    	DWORD	EventMask, NoBytesRead,NoBytesWritten;
    	char	Carac, Tampon[4096];
     
    	/*------------------------------------------------*/
    	/*     Envoi de la commande vers le Bus Pirate    */
    	/*------------------------------------------------*/
     
    	WriteCOM(Buffer, strlen(Buffer), &NoBytesWritten);
     
    	/*-----------------------------------------*/
    	/*     Mise en attente de la réception     */
    	/*-----------------------------------------*/
     
    	if (WaitEvent(&EventMask, NULL) == FALSE)
    	{
    		printf("Erreur dans la configuration de la mise en attente de la réception\n");
    		return;
    	}
     
    	/*-------------------*/
    	/*     Réception     */
    	/*-------------------*/
     
    	i=0;
     
    	do
    	{
    		ReadCOM(&Carac, sizeof(Carac), &NoBytesRead);
    		Tampon[i++] = Carac;
    	}
    	while (NoBytesRead> 0);
     
    	/*-----------------------------------*/
    	/*     Affichage de la réception     */
    	/*-----------------------------------*/
     
    	for (j=0; j<i; j++)
    		printf("%c" , Tampon[j]);
    }
     
    /*==============================*/
    /*                              */
    /*     Procédure Principale     */
    /*                              */
    /*==============================*/
     
    int main(void)
    {
    	if (!OpenCOM(ctoParams, dcbParams))
    		exit(-1);
     
    	init();
     
    	envoi("\n");
    	envoi("#\n");
    	envoi("m\n");
    	envoi("9\n");
     
    	envoi("s\n");
     
    	envoi("10 PRINT \"Hello World !\"\n");
    	envoi("20 AUX 0\n");
    	envoi("30 FOR B=1 TO 20\n");
    	envoi("40 LET A=AUX\n");
    	envoi("50 PRINT \"Led: \";A\n");
    	envoi("60 IF A=0 THEN AUX 1 ELSE AUX 0\n");
    	envoi("70 DELAY 100\n");
    	envoi("80 NEXT B\n");
    	envoi("90 END\n");
     
    	envoi("list\n");
     
    	ctoParams.ReadTotalTimeoutConstant = 2000;
    	TimeOuts(ctoParams);
     
    	envoi("run\n");
     
    	ctoParams.ReadTotalTimeoutConstant = 50;
    	TimeOuts(ctoParams);
     
    	envoi("exit\n");
    	envoi("#\n");
     
    	CloseCOM();
    	exit(0);
    }

    Et enfin, le compte-rendu de son exécution :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    +-----------------------------------------+
    |     Serial Transmission (Win32 APi)     |
    +-----------------------------------------+
    
        Port : COM5
    BaudRate : 115200
    ByteSize : 8
     StopBit : 0
      Parity : 0
    
    HiZ>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>m
    1. HiZ
    2. 1-WIRE
    3. UART
    4. I2C
    5. SPI
    6. 2WIRE
    7. 3WIRE
    8. LCD
    9. DIO
    x. exit(without change)
    
    (1)>>9
    Ready
    DIO>>s
    DIO(BASIC)>>10 PRINT "Hello World !"
    0x880x000x000x000x000x000x000x000x000x000x000x000x000x000x000x000x00Ready
    DIO(BASIC)>>20 AUX 0
    0x9D0x000x00Ready
    DIO(BASIC)>>30 FOR B=1 TO 20
    0x8A0x000x000x000x8B0x000x000x00Ready
    DIO(BASIC)>>40 LET A=AUX
    0x800x000x000x9D0x00Ready
    DIO(BASIC)>>50 PRINT "Led: ";A
    0x880x000x000x000x000x000x000x000x000x000x00Ready
    DIO(BASIC)>>60 IF A=0 THEN AUX 1 ELSE AUX 0
    0x810x000x000x000x820x9D0x000x830x9D0x000x00Ready
    DIO(BASIC)>>70 DELAY 100
    0x9C0x000x000x000x00Ready
    DIO(BASIC)>>80 NEXT B
    0x8C0x000x00Ready
    DIO(BASIC)>>90 END
    0xA10x00Ready
    DIO(BASIC)>>list
    
    10  PRINT "HELLO WORLD !"
    20  AUX 0
    30  FOR B=1 TO 20
    40  LET A= AUX
    50  PRINT "LED: ";A
    60  IF A=0 THEN  AUX 1 ELSE  AUX 0
    70  DELAY 100
    80  NEXT B
    90  END
    65535  END
    86 bytes.
    Ready
    DIO(BASIC)>>run
    HELLO WORLD !
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    
    Ready
    DIO(BASIC)>>exit
    Ready
    DIO>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>
    Appuyez sur une touche pour continuer...
    Il y a sûrement des points à améliorer.
    Comme la commande BASIC "run" dure bien plus longtemps (2000 ms) que l'envoi des commandes (50 ms), j'ai dû modifier le temps d'attente de la réception des données.

    Si vous avez des suggestions à me communiquer, je suis preneur.
    Merci.
    @+
      0  0

  7. ###raw>post.musername###
    Expert éminent sénior
    Salut à tous.

    J'ai amélioré mon programme C / Win32.
    Voici le "libcom.c" :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    #include <windows.h>
    #include <stdlib.h>
    #include <stdio.h>
     
    #include "libcom.h"
     
    /********************************************/
    /*                                          */
    /*     Délais d'attente sur le port COM     */
    /*                                          */
    /********************************************/
     
    COMMTIMEOUTS ctoParams =
    {							/*=============================*/
    	50,						/* ReadIntervalTimeout         */
    	10,						/* ReadTotalTimeoutMultiplier  */
    	50,						/* ReadTotalTimeoutConstant    */
    	0,						/* WriteTotalTimeoutMultiplier */
    	0						/* WriteTotalTimeoutConstant   */
    };							/*=============================*/
     
     
    /*************************************/
    /*                                   */
    /*     Configuration du port COM     */
    /*                                   */
    /*************************************/
     
    DCB dcbParams =
    {							/*===================*/
    	sizeof(DCB),			/* DCBlength         */
    	115200,					/* BaudRate          */
    	TRUE,					/* fBinary           */
    	FALSE,					/* fParity           */
    	FALSE,					/* fOutxCtsFlow      */
    	FALSE,					/* fOutxDsrFlow      */
    	DTR_CONTROL_ENABLE,		/* fDtrControl       */
    	FALSE,					/* fDsrSensitivity   */
    	FALSE,					/* fTXContinueOnXoff */
    	FALSE,					/* fOutX             */
    	FALSE,					/* fInX              */
    	FALSE,					/* fErrorChar        */
    	FALSE,					/* fNull             */
    	RTS_CONTROL_ENABLE,		/* fRtsControl       */
    	FALSE,					/* fAbortOnError     */
    	0,						/* fDummy2           */
    	0,						/* wReserved         */
    	0x100,					/* XonLim            */
    	0x100,					/* XoffLim           */
    	8,						/* ByteSize          */
    	NOPARITY,				/* Parity            */
    	ONESTOPBIT,				/* StopBits          */
    	0x11,					/* XonChar           */
    	0x13,					/* XoffChar          */
    	'?',					/* ErrorChar         */
    	0x1A,					/* EofChar           */
    	0x10					/* EvtChar           */
    };							/*===================*/
     
     
    /*****************************************************/
    /*                                                   */
    /*     Fonctions de communications en mode série     */
    /*                                                   */
    /*===================================================*/
     
    HANDLE	hComm=NULL;
    DWORD	EventMask,NoBytesRead,NoBytesWritten;
    char	Carac;
     
     
    /*===========================*/
    /*     Ouverture du Port     */
    /*===========================*/
     
    BOOL OpenCOM(void)
    {
    	hComm = CreateFile("\\\\.\\COM5",
    						GENERIC_READ|GENERIC_WRITE,
    						0,
    						NULL,
    						OPEN_EXISTING,
    						FILE_ATTRIBUTE_SYSTEM,
    						NULL);
     
    	if (hComm == INVALID_HANDLE_VALUE)
    	{
    		printf("Erreur lors de l'ouverture du port COM5\n");
    		return FALSE;
    	}
     
    /* FILE_FLAG_OVERLAPPED */
     
    	/*-------------------------------------------------------------------------*/
    	/*     Configuration des Tailles des tampons d'émission et de récption     */
    	/*-------------------------------------------------------------------------*/
     
    	SetupComm(hComm, 4096, 4096);
     
    	/*-----------------------------------------*/
    	/*     Configuration du "COMMTIMEOUTS"     */
    	/*-----------------------------------------*/
     
    	if (!SetCommTimeouts(hComm, &ctoParams))
    	{
    		printf("Erreur dans la configuration du 'COMMTIMEOUTS' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return FALSE;
    	}
     
    	/*--------------------------------*/
    	/*     Configuration du "DCB"     */
    	/*--------------------------------*/
     
    	if (!SetCommState(hComm, &dcbParams))
    	{
    		printf("Erreur dans la configuration du 'DCB' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return FALSE;
    	}
     
    	/*----------------------------------*/
    	/*     Affichage du paramétrage     */
    	/*----------------------------------*/
     
    	printf("\t\t+=============================+\n");
    	printf("\t\t|     Serial Transmission     |\n");
    	printf("\t\t|         (Win32 APi)         |\n");
    	printf("\t\t+-----------------------------+\n");
    	printf("\t\t|          Port :   COM5      |\n");
    	printf("\t\t|      BaudRate : %6d      |\n", dcbParams.BaudRate);
    	printf("\t\t|      ByteSize : %6d      |\n", dcbParams.ByteSize);
    	printf("\t\t|       StopBit : %6d      |\n", dcbParams.StopBits);
    	printf("\t\t|        Parity : %6d      |\n", dcbParams.Parity);
    	printf("\t\t+=============================+\n");
     
    	/*------------------------------*/
    	/*     On purge les tampons     */
    	/*------------------------------*/
     
    	PurgeComm(hComm, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
    	EscapeCommFunction(hComm, SETDTR);
     
    	/*----------------------------------------------*/
    	/*     Configuration du masque de réception     */
    	/*----------------------------------------------*/
     
    	if (SetCommMask(hComm, EV_RXCHAR) == FALSE)
    	{
    		printf("Erreur configuration du masque de réception\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return FALSE;
    	}
     
    	return TRUE;
    }
     
     
    /*===========================*/
    /*     Fermeture du Port     */
    /*===========================*/
     
    void CloseCOM(void)
    {
    	/*------------------------------*/
    	/*     On purge les tampons     */
    	/*------------------------------*/
     
    	EscapeCommFunction(hComm, CLRDTR);
     
    	PurgeComm(hComm, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
     
    	/*-------------------*/
    	/*     Fermeture     */
    	/*-------------------*/
     
    	CloseHandle(hComm);
    	hComm = NULL;
    }
     
     
    /*========================================*/
    /*     Envoie commande sans réception     */
    /*========================================*/
     
    void SendBlindCOM(LPVOID Buffer)
    {
    	/*------------------------------------------------*/
    	/*     Envoi de la commande vers le Bus Pirate    */
    	/*------------------------------------------------*/
     
    	WriteFile(hComm, Buffer, strlen(Buffer), &NoBytesWritten, NULL);
     
    	/*-----------------------------------------*/
    	/*     Mise en attente de la réception     */
    	/*-----------------------------------------*/
     
    	if (WaitCommEvent(hComm, &EventMask, NULL) == FALSE)
    	{
    		printf("Erreur dans la configuration de la mise en attente de la réception\n");
    		exit(1);
    		return;
    	}
     
    	/*----------------------------------*/
    	/*     Réception sans Affichage     */
    	/*----------------------------------*/
     
    	do
    	{
    		ReadFile(hComm, &Carac, sizeof(Carac), &NoBytesRead, NULL);
    	} while (NoBytesRead> 0);
    }
     
     
    /*========================================*/
    /*     Envoie commande avec réception     */
    /*========================================*/
     
    void SendCOM(LPVOID Buffer)
    {
    	/*------------------------------------------------*/
    	/*     Envoi de la commande vers le Bus Pirate    */
    	/*------------------------------------------------*/
     
    	WriteFile(hComm, Buffer, strlen(Buffer), &NoBytesWritten, NULL);
     
    	/*-----------------------------------------*/
    	/*     Mise en attente de la réception     */
    	/*-----------------------------------------*/
     
    	if (WaitCommEvent(hComm, &EventMask, NULL) == FALSE)
    	{
    		printf("Erreur dans la configuration de la mise en attente de la réception\n");
    		exit(1);
    		return;
    	}
     
    	/*----------------------------------*/
    	/*     Réception avec Affichage     */
    	/*----------------------------------*/
     
    	do
    	{
    		ReadFile(hComm, &Carac, sizeof(Carac), &NoBytesRead, NULL);
    		printf("%c", Carac);
    	} while (NoBytesRead> 0);
    }
     
     
    /*================================================================*/
    /*     Modification de la variable 'ReadTotalTimeoutConstant'     */
    /*================================================================*/
     
    void SetTimeOutsCOM(int timeout)
    {
    	ctoParams.ReadTotalTimeoutConstant = timeout;
     
    	if (!SetCommTimeouts(hComm, &ctoParams))
    	{
    		printf("Erreur dans la configuration du 'COMMTIMEOUTS' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		exit(-1);
    	}
    }
     
     
    /*======================================================================*/
    /*     Remise à l'origine de la variable 'ReadTotalTimeoutConstant'     */
    /*======================================================================*/
     
    void ResetTimeOutsCOM(void)
    {
    	ctoParams.ReadTotalTimeoutConstant = 50;
     
    	if (!SetCommTimeouts(hComm, &ctoParams))
    	{
    		printf("Erreur dans la configuration du 'COMMTIMEOUTS' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		exit(-1);
    	}
    }

    Les fonctions sont :
    --> ouverture du port COM
    --> fermeture du port COM
    --> envoie avec réception
    --> envoie sans réception
    --> modification de la valeur de la variable 'ReadTotalTimeoutConstant'
    --> remise à l'origine de la variable 'ReadTotalTimeoutConstant'.

    Pour l'instant, je n'ai besoin que de ceux-ci.

    Voici le "libcom.h" :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /*=======================================================*/
    /*                                                       */
    /*     Les fonctions de communications en mode série     */
    /*                                                       */
    /*=======================================================*/
     
    #ifndef _LIBCOM_
    #define _LIBCOM_
     
    BOOL OpenCOM(void);
    void CloseCOM(void);
    void SendBlindCOM(LPVOID Buffer);
    void SendCOM(LPVOID Buffer);
    void SetTimeOutsCOM(int timeout);
    void ResetTimeOutsCOM(void);
     
    #endif

    Mon programme C / Win32 :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    /*******************************************/
    /*                                         */
    /*     Prise de Controle du Bus Pirate     */
    /*                                         */
    /*******************************************/
     
    #include <windows.h>
    #include <unistd.h>
    #include <libcom.h>
     
    /*==============================*/
    /*                              */
    /*     Procédure Principale     */
    /*                              */
    /*==============================*/
     
    int main(void)
    {
    	if (!OpenCOM())
    		exit(-1);
     
    	SendCOM("\n");
    	SendCOM("#\n");
    	SendCOM("m\n");
    	SendCOM("9\n");
     
    	SendCOM("s\n");
    	SendCOM("new\n");
     
    	SendBlindCOM("10 PRINT \"+-------------+\"\n");
    	SendBlindCOM("15 PRINT \"| Hello World |\"\n");
    	SendBlindCOM("20 PRINT \"+-------------+\"\n");
    	SendBlindCOM("25 AUX 1\n");
    	SendBlindCOM("30 FOR B=1 TO 20\n");
    	SendBlindCOM("35 LET A=AUX\n");
    	SendBlindCOM("40 PRINT \"Led: \";A\n");
    	SendBlindCOM("45 IF A=0 THEN AUX 1 ELSE AUX 0\n");
    	SendBlindCOM("50 DELAY 100\n");
    	SendBlindCOM("55 NEXT B\n");
    	SendBlindCOM("60 AUX 0\n");
    	SendBlindCOM("65 PRINT \"+--------+\"\n");
    	SendBlindCOM("70 PRINT \"| Finish |\"\n");
    	SendBlindCOM("75 PRINT \"+--------+\"\n");
    	SendBlindCOM("80 END\n");
     
    	SendCOM("list\n");
     
    	SetTimeOutsCOM(1000);
    	SendCOM("run\n");
    	ResetTimeOutsCOM();
     
    	SendCOM("exit\n");
    	SendCOM("#\n");
     
    	CloseCOM();
    	exit(0);
    }

    L'introduction de la fonction "SendBlindCOM()" permet de ne pas afficher en retour l'introduction du programme BASIC.
    Cela fait plus propre au niveau du compte-rendu.

    Et voici l'exécution :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
                    +=============================+
                    |     Serial Transmission     |
                    |         (Win32 APi)         |
                    +-----------------------------+
                    |          Port :   COM5      |
                    |      BaudRate : 115200      |
                    |      ByteSize :      8      |
                    |       StopBit :      0      |
                    |        Parity :      0      |
                    +=============================+
    
    HiZ>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>m
    1. HiZ
    2. 1-WIRE
    3. UART
    4. I2C
    5. SPI
    6. 2WIRE
    7. 3WIRE
    8. LCD
    9. DIO
    x. exit(without change)
    
    (1)>>9
    Ready
    DIO>>s
    DIO(BASIC)>>new
    Ready
    DIO(BASIC)>>list
    
    10  PRINT "+-------------+"
    15  PRINT "| HELLO WORLD |"
    20  PRINT "+-------------+"
    25  AUX 1
    30  FOR B=1 TO 20
    35  LET A= AUX
    40  PRINT "LED: ";A
    45  IF A=0 THEN  AUX 1 ELSE  AUX 0
    50  DELAY 100
    55  NEXT B
    60  AUX 0
    65  PRINT "+--------+"
    70  PRINT "| FINISH |"
    75  PRINT "+--------+"
    80  END
    65535  END
    183 bytes.
    Ready
    DIO(BASIC)>>run
    +-------------+
    | HELLO WORLD |
    +-------------+
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    LED: 1
    LED: 0
    +--------+
    | FINISH |
    +--------+
    
    Ready
    DIO(BASIC)>>exit
    Ready
    DIO>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>
    Appuyez sur une touche pour continuer...
    Et en plus, la led clignote, ce qui est le but de ce programme.

    J'ai maintenant un programme C qui m permet de piloter mon Bus Pirate.
    Cela me permet de conserver la séquence de manipulation que je dois faire, et que je ne serai pas obligé de refaire à chaque fois que j'aurai besoin de la tester.

    Ce programme peut servir à manipuler n'importe quel port Série dont vous aurez, comme moi, besoin de prendre le contrôle.

    @+
      1  0

  8. #8
    Expert éminent sénior
    Salut à tous.

    J'ai décidé de reprendre le test de l'afficheur LCD 20X04 de chez Joy-It, en mode I2C.
    Dans un premier temps, j'ai essayé de taper dans la console une suite de séquence à envoyer vers l'afficheur LCD, mais sans résultat.
    Le problème est que la séquence est compliquée, et la retaper à chaque fois est source d'erreur.
    Avec mon programme C / Win32 de prise de contrôle du Bus Pirate, je ne fais plus de saisie, car tout est stocké dedans.
    Du coup, cela me simplifie grandement les tests.

    Ne sachant pas trop comment m'y prendre pour cette séquence, j'ai repris mon programme C, celui que j'ai écrit et testé sous la raspberry Pi 3B.
    Ce programme C fonctionne correctement et affiche ce que je veux sur l'afficheur LCD 20x04 de chez Joy-It en mode I2C.
    Je lui ai demandé de m'afficher le traditionnel "Hello World!" sur la deuxième ligne, en commençant à la cinquième colonne.

    Pour ce faire, j'ai inséré un "printf()" sur la fonction "i2c_write()" (du programme C Raspberry Pi).
    Cette fonction est celle qui me permet d'envoyer la donnée sous la forme de quatre bits vers l'afficheur en mode I2C.
    Chaque octet est représenté par un triplet que j'ai conservé dans le tableau des chaînes de caractères, dans le programme 'C' (voir ci-après).
    Cela me donne une séquence de 46 octets qui va réaliser l'affichage du texte sur mon afficheur LCD 20x04 Joy-It.

    Cette séquence est assez compliquée, c'est pourquoi, j'ai préféré l'obtenir par mon programme C de la Raspberry Pi 3B.
    En fait, j'ai triché pour ma démonstration, mais au moins, cela a le mérite de fonctionner.

    Pour le branchement, j'ai repris l'exemple de "dangerousprototypes.com".
    A titre indicatif, voici le branchement :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    +------------+-------------+---------+
    | Bus Pirate | LCD adapter | PCF8574 |
    +------------+-------------+---------+
    |    GND     |     GND     |   GND   |
    |   5volts   |     +5V     |   VCC   |
    |   Vpullup  |     +5V     |   VCC   |
    |    MOSI    |     SDA     |   SDA   |
    |    CLK     |     SCL     |   SCL   |
    +------------+-------------+---------+
    Attention, il faut relier la broche VPU à la broche 5 volts du bus pirate, qui sont reliées à la broche VCC du PCF8574.

    Voici mon programme C / Win32 pour tester l'afficheur LCD 20X04 de chez Joy-It en mode I2C, à partir du Bus Pirate :
    Code C :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    /*******************************************/
    /*                                         */
    /*     Prise de Controle du Bus Pirate     */
    /*                                         */
    /*******************************************/
     
    #include <windows.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <libcom.h>
     
    /*==============================*/
    /*                              */
    /*     Procédure Principale     */
    /*                              */
    /*==============================*/
     
    int main(void)
    {
    	int		i;
    	char	tampon[256];
     
    	char	*tab[46][3] = {{"08","0C","08"},{"C8","CC","C8"},{"38","3C","38"},{"88","8C","88"},{"38","3C","38"},{"88","8C","88"},{"38","3C","38"},
    						   {"88","8C","88"},{"08","0C","08"},{"28","2C","28"},{"28","2C","28"},{"88","8C","88"},{"08","0C","08"},{"C8","CC","C8"},
    						   {"08","0C","08"},{"18","1C","18"},{"08","0C","08"},{"68","6C","68"},{"08","0C","08"},{"28","2C","28"},{"C8","CC","C8"},
    						   {"48","4C","48"},{"49","4D","49"},{"89","8D","89"},{"69","6D","69"},{"59","5D","59"},{"69","6D","69"},{"C9","CD","C9"},
    						   {"69","6D","69"},{"C9","CD","C9"},{"69","6D","69"},{"F9","FD","F9"},{"29","2D","29"},{"09","0D","09"},{"59","5D","59"},
    						   {"79","7D","79"},{"69","6D","69"},{"F9","FD","F9"},{"79","7D","79"},{"29","2D","29"},{"69","6D","69"},{"C9","CD","C9"},
    						   {"69","6D","69"},{"49","4D","49"},{"29","2D","29"},{"19","1D","19"}};
     
    	if (!OpenCOM())
    		exit(-1);
     
    	SendCOM("\n");
    	SendCOM("#\n");
    	SendCOM("m\n");
    	SendCOM("4\n");
    	SendCOM("3\n");
    	SendCOM("W\n");
    	SendCOM("P\n");
    	SendCOM("v\n");
    	SendCOM("(0)\n");
    	SendCOM("(1)\n");
     
    	for (i=0; i<46; i++)
    	{
    		sprintf(tampon,"[0x4E 0x%s 0x%s 0x%s]\n", tab[i][0], tab[i][1], tab[i][2]);
    		SendBlindCOM(tampon);
    		}
     
    Sleep(10000);
     
    	SendCOM("#\n");
     
    	CloseCOM();
    	exit(0);
    }

    J'ai préféré ne pas afficher la séquence qui est envoyé dans le compte-rendu ci-après, car elle est un peu trop longue.
    Normalement, pour chaque code hexadécimal qui sera envoyé, vous devez avoir un "NAK".

    Et voici le résultat à l'exécution :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
                    +=============================+
                    |     Serial Transmission     |
                    |         (Win32 APi)         |
                    +-----------------------------+
                    |          Port :   COM5      |
                    |      BaudRate : 115200      |
                    |      ByteSize :      8      |
                    |       StopBit :      0      |
                    |        Parity :      0      |
                    +=============================+
    
    HiZ>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>m
    1. HiZ
    2. 1-WIRE
    3. UART
    4. I2C
    5. SPI
    6. 2WIRE
    7. 3WIRE
    8. LCD
    9. DIO
    x. exit(without change)
    
    (1)>>4
    Set speed:
     1. ~5KHz
     2. ~50KHz
     3. ~100KHz
     4. ~400KHz
    
    (1)>>3
    Ready
    I2C>>W
    Power supplies ON
    I2C>>P
    Pull-up resistors ON
    I2C>>v
    Pinstates:
    1.(BR)  2.(RD)  3.(OR)  4.(YW)  5.(GN)  6.(BL)  7.(PU)  8.(GR)  9.(WT)  0.(Blk)
    GND     3.3V    5.0V    ADC     VPU     AUX     SCL     SDA     -       -
    P       P       P       I       I       I       I       I       I       I
    GND     3.28V   4.96V   0.00V   4.93V   L       H       H       H       H
    I2C>>(0)
     0.Macro menu
     1.7bit address search
     2.I2C sniffer
    I2C>>(1)
    Searching I2C address space. Found devices at:
    0x4E(0x27 W) 0x4F(0x27 R)
    
    I2C>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>
    Appuyez sur une touche pour continuer...
    Pour ce qui est de l'afficheur LCD, vous devrez me croire sur parole : ça fonctionne !

    Comme l'envoi des données est assez lente, vis-à-vis de la Raspberry Pi 3B, je remarque que le curseur se balade à l'écran.
    Si quelqu'un peut refaire le test chez lui, je lui en serait gré. Vous pouvez me donner votre avis sur ce que l'on peut améliorer dans ce programme C / Win32.

    Ce que je ne comprends pas trop, l'adresse I2C de l'afficheur LCD n'est pas la même.
    Avec le programme C, donc avec la Raspberry Pi 3B, l'adresse est 0x27.
    Tandis qu'avec le Bus Pirate, l'adresse est 0x4E.
    Si quelqu'un a une explication à ce sujet, je suis preneur.

    Autre remarque, je n'ai pas trouvé sur le net un exemple comparable à ce que je viens de vous communiqué ici.
    Le seul test que j'ai trouvé est celui par l'adaptateur V3 que l'on ne trouve plus à la vente.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  9. #9
    Responsable Arduino et Systèmes Embarqués

    Salut,

    Citation Envoyé par Artemus24 Voir le message
    Ce que je ne comprends pas trop, l'adresse I2C de l'afficheur LCD n'est pas la même.
    Avec le programme C, donc avec la Raspberry Pi 3B, l'adresse est 0x27.
    Tandis qu'avec le Bus Pirate, l'adresse est 0x4E.
    Si quelqu'un a une explication à ce sujet, je suis preneur.
    0x4E, c'est 0x27 avec un décalage d'un bit vers la gauche.

    L'adresse I2C est codée sur 7 bits, mais une trame I2C commence par un octet avec l'adresse sur 7 bits + 1 bit R/W pour indiquer une opération de lecture ou d'écriture.

    Certaines librairies demandent ce décalage d'un bit vers la gauche de l'adresse pour y insérer le bit de poids faible R/W, d'autres non, mais l'adresse est bien la même.

  10. ###raw>post.musername###
    Expert éminent sénior
    Salut à tous.

    @ F-leb : Merci pour l'information. Donc, c'est la même adresse.

    @ tous : Jusqu'à présent, j'ai fait un test pour démontrer la prise de contrôle de l'afficheur HD44780, en mode I2C, par le bus pirate.
    Mais cela ne peut pas convenir si nous avons besoin de toute la souplesse requise pour afficher des chaînes de caractères.

    J'ai ajouté dans ma DDL, les fonctions que j'ai utilisé dans le programme C de la Raspberry Pi 3B+.
    Comme nous sommes obligés de passer par le backpack PCF8574 pour le mode I2C, le transfert des données se fait en mode 4 bits.

    Voici le contenu de ma DDL (boîte à outils) qui va servir à manipuler le Bus Pirate (libcom.c) :
    Code c :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    #include <windows.h>
    #include <stdlib.h>
    #include <stdio.h>
     
    #include "libcom.h"
     
    /********************************************/
    /*                                          */
    /*     Délais d'attente sur le port COM     */
    /*                                          */
    /********************************************/
     
    COMMTIMEOUTS ctoParams =
    {							/*=============================*/
    	50,						/* ReadIntervalTimeout         */
    	10,						/* ReadTotalTimeoutMultiplier  */
    	50,						/* ReadTotalTimeoutConstant    */
    	0,						/* WriteTotalTimeoutMultiplier */
    	0						/* WriteTotalTimeoutConstant   */
    };							/*=============================*/
     
     
    /*************************************/
    /*                                   */
    /*     Configuration du port COM     */
    /*                                   */
    /*************************************/
     
    DCB dcbParams =
    {							/*===================*/
    	sizeof(DCB),			/* DCBlength         */
    	115200,					/* BaudRate          */
    	TRUE,					/* fBinary           */
    	FALSE,					/* fParity           */
    	FALSE,					/* fOutxCtsFlow      */
    	FALSE,					/* fOutxDsrFlow      */
    	DTR_CONTROL_ENABLE,		/* fDtrControl       */
    	FALSE,					/* fDsrSensitivity   */
    	FALSE,					/* fTXContinueOnXoff */
    	FALSE,					/* fOutX             */
    	FALSE,					/* fInX              */
    	FALSE,					/* fErrorChar        */
    	FALSE,					/* fNull             */
    	RTS_CONTROL_ENABLE,		/* fRtsControl       */
    	FALSE,					/* fAbortOnError     */
    	0,						/* fDummy2           */
    	0,						/* wReserved         */
    	0x100,					/* XonLim            */
    	0x100,					/* XoffLim           */
    	8,						/* ByteSize          */
    	NOPARITY,				/* Parity            */
    	ONESTOPBIT,				/* StopBits          */
    	0x11,					/* XonChar           */
    	0x13,					/* XoffChar          */
    	'?',					/* ErrorChar         */
    	0x1A,					/* EofChar           */
    	0x10					/* EvtChar           */
    };							/*===================*/
     
     
    /*****************************************************/
    /*                                                   */
    /*     Fonctions de communications en mode série     */
    /*                                                   */
    /*===================================================*/
     
    HANDLE	hComm=NULL;
    DWORD	EventMask,NoBytesRead,NoBytesWritten;
    char	Carac;
    char	Tampon[256];
     
    /*===========================*/
    /*     Ouverture du Port     */
    /*===========================*/
     
    int COM_Open(void)
    {
    	hComm = CreateFile("\\\\.\\COM5",
    						GENERIC_READ|GENERIC_WRITE,
    						0,
    						NULL,
    						OPEN_EXISTING,
    						FILE_ATTRIBUTE_SYSTEM,
    						NULL);
     
    	if (hComm == INVALID_HANDLE_VALUE)
    	{
    		printf("Erreur lors de l'ouverture du port COM5\n");
    		return FALSE;
    	}
     
    /* FILE_FLAG_OVERLAPPED */
     
    	/*-------------------------------------------------------------------------*/
    	/*     Configuration des Tailles des tampons d'émission et de récption     */
    	/*-------------------------------------------------------------------------*/
     
    	SetupComm(hComm, 4096, 4096);
     
    	/*-----------------------------------------*/
    	/*     Configuration du "COMMTIMEOUTS"     */
    	/*-----------------------------------------*/
     
    	if (!SetCommTimeouts(hComm, &ctoParams))
    	{
    		printf("Erreur dans la configuration du 'COMMTIMEOUTS' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return FALSE;
    	}
     
    	/*--------------------------------*/
    	/*     Configuration du "DCB"     */
    	/*--------------------------------*/
     
    	if (!SetCommState(hComm, &dcbParams))
    	{
    		printf("Erreur dans la configuration du 'DCB' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return FALSE;
    	}
     
    	/*----------------------------------*/
    	/*     Affichage du paramétrage     */
    	/*----------------------------------*/
     
    	printf("\t\t+=============================+\n");
    	printf("\t\t|     Serial Transmission     |\n");
    	printf("\t\t|         (Win32 APi)         |\n");
    	printf("\t\t+-----------------------------+\n");
    	printf("\t\t|          Port :   COM5      |\n");
    	printf("\t\t|      BaudRate : %6d      |\n", dcbParams.BaudRate);
    	printf("\t\t|      ByteSize : %6d      |\n", dcbParams.ByteSize);
    	printf("\t\t|       StopBit : %6d      |\n", dcbParams.StopBits);
    	printf("\t\t|        Parity : %6d      |\n", dcbParams.Parity);
    	printf("\t\t+=============================+\n");
     
    	/*------------------------------*/
    	/*     On purge les tampons     */
    	/*------------------------------*/
     
    	PurgeComm(hComm, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
    	EscapeCommFunction(hComm, SETDTR);
     
    	/*----------------------------------------------*/
    	/*     Configuration du masque de réception     */
    	/*----------------------------------------------*/
     
    	if (SetCommMask(hComm, EV_RXCHAR) == FALSE)
    	{
    		printf("Erreur configuration du masque de réception\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return FALSE;
    	}
     
    	return TRUE;
    }
     
     
    /*===========================*/
    /*     Fermeture du Port     */
    /*===========================*/
     
    void COM_Close(void)
    {
    	/*------------------------------*/
    	/*     On purge les tampons     */
    	/*------------------------------*/
     
    	EscapeCommFunction(hComm, CLRDTR);
     
    	PurgeComm(hComm, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
     
    	/*-------------------*/
    	/*     Fermeture     */
    	/*-------------------*/
     
    	CloseHandle(hComm);
    	hComm = NULL;
    }
     
     
    /*========================================*/
    /*     Envoie commande sans réception     */
    /*========================================*/
     
    void COM_SendBlind(char *Buffer)
    {
    	/*------------------------------------------------*/
    	/*     Envoi de la commande vers le Bus Pirate    */
    	/*------------------------------------------------*/
     
    	WriteFile(hComm, Buffer, strlen(Buffer), &NoBytesWritten, NULL);
     
    		/*-----------------------------------------*/
    	/*     Mise en attente de la réception     */
    	/*-----------------------------------------*/
     
    	if (WaitCommEvent(hComm, &EventMask, NULL) == FALSE)
    	{
    		printf("Erreur dans la configuration de la mise en attente de la réception\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return;
    	}
     
    /*----------------------------------*/
    	/*     Réception sans Affichage     */
    	/*----------------------------------*/
     
    	do
    	{
    		ReadFile(hComm, &Carac, sizeof(Carac), &NoBytesRead, NULL);
    	} while (NoBytesRead> 0);
    }
     
     
    /*========================================*/
    /*     Envoie commande avec réception     */
    /*========================================*/
     
    void COM_Send(char *Buffer)
    {
    	/*------------------------------------------------*/
    	/*     Envoi de la commande vers le Bus Pirate    */
    	/*------------------------------------------------*/
     
    	WriteFile(hComm, Buffer, strlen(Buffer), &NoBytesWritten, NULL);
     
    	/*-----------------------------------------*/
    	/*     Mise en attente de la réception     */
    	/*-----------------------------------------*/
     
    	if (WaitCommEvent(hComm, &EventMask, NULL) == FALSE)
    	{
    		printf("Erreur dans la configuration de la mise en attente de la réception\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		return;
    	}
     
    	/*----------------------------------*/
    	/*     Réception avec Affichage     */
    	/*----------------------------------*/
     
    	do
    	{
    		ReadFile(hComm, &Carac, sizeof(Carac), &NoBytesRead, NULL);
    		printf("%c", Carac);
    	} while (NoBytesRead> 0);
    }
     
     
    /*================================================================*/
    /*     Modification de la variable 'ReadTotalTimeoutConstant'     */
    /*================================================================*/
     
    void COM_SetTimeOuts(int timeout)
    {
    	ctoParams.ReadTotalTimeoutConstant = timeout;
     
    	if (!SetCommTimeouts(hComm, &ctoParams))
    	{
    		printf("Erreur dans la configuration du 'COMMTIMEOUTS' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		exit(-1);
    	}
    }
     
     
    /*======================================================================*/
    /*     Remise à l'origine de la variable 'ReadTotalTimeoutConstant'     */
    /*======================================================================*/
     
    void COM_ResetTimeOuts(void)
    {
    	ctoParams.ReadTotalTimeoutConstant = 50;
     
    	if (!SetCommTimeouts(hComm, &ctoParams))
    	{
    		printf("Erreur dans la configuration du 'COMMTIMEOUTS' !\n");
    		CloseHandle(hComm);
    		hComm = NULL;
    		exit(-1);
    	}
    }
     
     
    /*=================================*/
    /*     Envoie vers le mode I2C     */
    /*=================================*/
     
    void COM_I2C_write(unsigned char _data)
    {
    	char tampon[256];
     
    	sprintf(tampon,"[0x4E 0x%02X]\n", _data);
    	COM_SendBlind(tampon);
    }
     
     
    /****************************************/
    /*                                      */
    /*     lcd : Liquid Crystal Display     */
    /*                                      */
    /****************************************/
     
    /*=============================*/
    /*     Liste des Commandes     */
    /*=============================*/
     
    #define LCD_RESET					0x00
    #define LCD_CLEAR_DISPLAY			0x01
    #define LCD_RETURN_HOME				0x02
    #define LCD_ENTRY_MODE_SET			0x04
    #define LCD_DISPLAY_CONTROL			0x08
    #define LCD_CURSOR_OR_DISPLAY_SHIFT	0x10
    #define LCD_FUNCTION_SET			0x20
    #define LCD_SET_CG_RAM_ADDR			0x40
    #define LCD_SET_DD_RAM_ADDR			0x80
     
     
    /*----------------------------*/
    /* Flags for "entry mode set" */
    /*----------------------------*/
     
    #define LCD_ENTRY_INCREMENT			0x02
    #define LCD_ENTRY_DECREMENT			0x00
     
    #define LCD_ENTRY_SHIFT				0x01
    #define LCD_ENTRY_NO_SHIFT			0x00
     
     
    /*------------------------------------*/
    /* Flags for "display on/off control" */
    /*------------------------------------*/
     
    #define LCD_DISPLAY_ON				0x04
    #define LCD_DISPLAY_OFF				0x00
     
    #define LCD_CURSOR_ON				0x02
    #define LCD_CURSOR_OFF				0x00
     
    #define LCD_BLINK_ON				0x01
    #define LCD_BLINK_OFF				0x00
     
     
    /*------------------------------------*/
    /* Flags for "cursor or display shift */
    /*------------------------------------*/
     
    #define LCD_DISPLAY_SHIFT			0x08
    #define LCD_CURSOR_MOVE				0x00
     
    #define LCD_SHIFT_TO_RIGHT			0x04
    #define LCD_SHIFT_TO_LEFT			0x00
     
     
    /*--------------------------*/
    /* Flags for "function set" */
    /*--------------------------*/
     
    #define LCD_EIGHT_BITS				0x10
    #define LCD_FOUR_BITS				0x00
     
    #define LCD_2LINES					0x08
    #define LCD_1LINE					0x00
     
    #define LCD_5x10DOTS				0x04
    #define LCD_5x8DOTS					0x00
     
     
    /*----------------------*/
    /*     Others Flags     */
    /*----------------------*/
     
    #define LCD_BL				0x08		/* Backlight       bit */
    #define LCD_E				0x04		/* Enable          bit */
    #define LCD_RW				0x02		/* Read/Write      bit */
    #define LCD_RS				0x01		/* Register Select bit */
     
     
    /*=======================================*/
    /*     Ecriture en mode quatre bits      */
    /*=======================================*/
     
    void LCD_four_bits(unsigned char _data, unsigned char _mode)
    {
    	sprintf(Tampon,"[0x4E 0x%02X 0x%02X 0x%02X]\n",(_data|_mode|LCD_BL),((_data|LCD_E)|_mode|LCD_BL),(((_data&~LCD_E)|_mode|LCD_BL)));
    	COM_SendBlind(Tampon);
    }
     
     
    /*=================================*/
    /*     Ecriture d'une commande     */
    /*=================================*/
     
    void LCD_command(unsigned char _data)
    {
    	LCD_four_bits( (_data       & 0xF0), 0x00);
    	LCD_four_bits(((_data << 4) & 0xF0), 0x00);
    }
     
     
    /*=================================*/
    /*     Ecriture d'un caractère     */
    /*=================================*/
     
    void LCD_char(unsigned char _data)
    {
    	LCD_four_bits( (_data       & 0xF0), LCD_RS);
    	LCD_four_bits(((_data << 4) & 0xF0), LCD_RS);
    }
     
     
    /*=========================*/
    /*      Initialisation     */
    /*=========================*/
     
    void LCD_init(void)
    {
    	LCD_command(LCD_FUNCTION_SET    | LCD_EIGHT_BITS      | LCD_2LINES           | LCD_5x8DOTS);
    	LCD_command(LCD_FUNCTION_SET    | LCD_EIGHT_BITS      | LCD_2LINES           | LCD_5x8DOTS);
    	LCD_command(LCD_FUNCTION_SET    | LCD_EIGHT_BITS      | LCD_2LINES           | LCD_5x8DOTS);
     
    	LCD_command(0x02);	/* Four Bits Mode */
     
    	LCD_command(LCD_FUNCTION_SET    | LCD_FOUR_BITS       | LCD_2LINES           | LCD_5x8DOTS);
    	LCD_command(LCD_DISPLAY_CONTROL | LCD_DISPLAY_ON      | LCD_CURSOR_OFF       | LCD_BLINK_OFF);
    	LCD_command(LCD_CLEAR_DISPLAY);
    	LCD_command(LCD_ENTRY_MODE_SET  | LCD_ENTRY_INCREMENT | LCD_ENTRY_NO_SHIFT);
    	LCD_command(LCD_RETURN_HOME);
    }
     
     
    /*===============================*/
    /*      Nettoyage de l'écran     */
    /*===============================*/
     
    void LCD_clear(void)
    {
    	LCD_command(LCD_CLEAR_DISPLAY);
    	LCD_command(LCD_RETURN_HOME);
    }
     
     
    /*===================================*/
    /*     Positionnement du curseur     */
    /*===================================*/
     
    void LCD_setcursor(int _row, int _col)
    {
    	unsigned int pos[04] = {0x00,0x40,0x14,0x54};
     
    	if (_row<=1)	_row=1;
    	if (_row>=4)	_row=4;
    	if (_col>=19)	_col=19;
     
    	LCD_command(LCD_SET_DD_RAM_ADDR | (pos[_row-1] + _col));
    }
     
     
    /*==============================================*/
    /*     Affichage d'une chaîne de caractères     */
    /*==============================================*/
     
    void LCD_string(char *_array, int _qte)
    {
    	while (_qte-- > 0)
    		LCD_char(*_array++);
    }
     
     
    /*==========================================*/
    /*     Allumage de l'afficheur (on/off)     */
    /*==========================================*/
     
    void LCD_display(char *_state)
    {
    	if (strcmp(_state,"on") == 0)
    			LCD_command(LCD_DISPLAY_CONTROL | LCD_DISPLAY_ON  | LCD_CURSOR_OFF | LCD_BLINK_OFF);
    	else	LCD_command(LCD_DISPLAY_CONTROL | LCD_DISPLAY_OFF | LCD_CURSOR_OFF | LCD_BLINK_OFF);
    }

    Et voici libcom.h :
    Code c :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    /*=======================================================*/
    /*                                                       */
    /*     Les fonctions de communications en mode série     */
    /*                                                       */
    /*=======================================================*/
     
    #ifndef _LIBCOM_
    #define _LIBCOM_
     
    int  COM_Open(void);
    void COM_Close(void);
    void COM_SendBlind(char *Buffer);
    void COM_Send(char *Buffer);
    void COM_SetTimeOuts(int timeout);
    void COM_ResetTimeOuts(void);
     
    void LCD_command(unsigned char _data);
    void LCD_char(unsigned char _data);
    void LCD_init(void);
    void LCD_clear(void);
    void LCD_setcursor(int _row, int _col);
    void LCD_string(char *_array, int _qte);
    void LCD_display(char *_state);
     
    #endif

    J'ai un problème que je n'arrive pas à résoudre.
    Dans la fonction "COM_Send()", j'envoie des données et j'attends la réception, que j'affiche à la console.
    J'ai une autre fonction "COM_SendBlind()", qui envoie des données, mais j'aimerai ne rien recevoir en retour afin de gagner du temps à l'exécution.
    Sauf que je n'ai pas trouvé le moyen d'annuler les effets de la commande "WaitCommEvent()".
    Je suis obligé de lire la réception et de ne pas l'afficher.
    J'aimerai savoir comment annuler cette commande "WaitCommEvent()".

    J'ai pu augmenter la rapidité à l'affichage en modifiant la variable 'ReadTotalTimeoutConstant' puisque j'ai mis 0 (COM_SetTimeOuts(0)).
    Mais selon moi, cette astuce n'est pas très propre.

    Voici le programme de test :
    Code c :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    /*******************************************/
    /*                                         */
    /*     Prise de Controle du Bus Pirate     */
    /*                                         */
    /*******************************************/
     
    #include <windows.h>
     
    #include <conio.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <libcom.h>
     
    /*==============================*/
    /*                              */
    /*     Procédure Principale     */
    /*                              */
    /*==============================*/
     
    int main(void)
    {
    	if (!COM_Open())
    		exit(-1);
     
    	COM_Send("\n");
    	COM_Send("#\n");
    	COM_Send("m\n");
    	COM_Send("4\n");
    	COM_Send("3\n");
    	COM_Send("W\n");
    	COM_Send("P\n");
    	COM_Send("v\n");
    	COM_Send("(0)\n");
    	COM_Send("(1)\n");
     
    	COM_SetTimeOuts(0);
     
    	LCD_init();
     
    	LCD_setcursor(1,2);
    	LCD_string("HD44780 LCD demo",16);
     
    	LCD_setcursor(2,3);
    	LCD_string("Bus Pirate V3b",14);
     
    	LCD_setcursor(3,3);
    	LCD_string("Firmware v5.10",14);
     
    	LCD_setcursor(4,1);
    	LCD_string("By Artemus Gordon",17);
     
    	getch();  /* Pour marquer une pause durant l'affichage */
     
    	COM_ResetTimeOuts();
    	COM_Send("#\n");
     
    	COM_Close();
    	exit(0);
    }


    Et voici son exécution :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
                    +=============================+
                    |     Serial Transmission     |
                    |         (Win32 APi)         |
                    +-----------------------------+
                    |          Port :   COM5      |
                    |      BaudRate : 115200      |
                    |      ByteSize :      8      |
                    |       StopBit :      0      |
                    |        Parity :      0      |
                    +=============================+
    
    HiZ>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>m
    1. HiZ
    2. 1-WIRE
    3. UART
    4. I2C
    5. SPI
    6. 2WIRE
    7. 3WIRE
    8. LCD
    9. DIO
    x. exit(without change)
    
    (1)>>4
    Set speed:
     1. ~5KHz
     2. ~50KHz
     3. ~100KHz
     4. ~400KHz
    
    (1)>>3
    Ready
    I2C>>W
    Power supplies ON
    I2C>>P
    Pull-up resistors ON
    I2C>>v
    Pinstates:
    1.(BR)  2.(RD)  3.(OR)  4.(YW)  5.(GN)  6.(BL)  7.(PU)  8.(GR)  9.(WT)  0.(Blk)
    GND     3.3V    5.0V    ADC     VPU     AUX     SCL     SDA     -       -
    P       P       P       I       I       I       I       I       I       I
    GND     3.28V   4.96V   0.00V   4.94V   L       H       H       H       H
    I2C>>(0)
     0.Macro menu
     1.7bit address search
     2.I2C sniffer
    I2C>>(1)
    Searching I2C address space. Found devices at:
    0x4E(0x27 W) 0x4F(0x27 R)
    
    I2C>>#
    RESET
    
    Bus Pirate v3b
    Firmware v5.10 (r559)  Bootloader v4.4
    DEVID:0x0447 REVID:0x3046 (24FJ64GA002 B8)
    http://dangerousprototypes.com
    HiZ>>
    Appuyez sur une touche pour continuer...
    Sur l'afficheur, nous voyons apparaître :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
      HD44780 LCD demo
       Bus Pirate V3b
       Firmware v5.10
     By Artemus Gordon
    Pour l'instant, je n'ai plus rien à proposer pour les tests du Bus Pirate.
    Dans une prochaine commande, j'aurai du matériel que je pourrai tester et donc enrichir ma DDL (Boîte à outils).

    @+
      0  0

  11. #11
    Membre régulier
    Citation Envoyé par Artemus24 Voir le message
    Dans la fonction "COM_Send()", j'envoie des données et j'attends la réception, que j'affiche à la console.
    J'ai une autre fonction "COM_SendBlind()", qui envoie des données, mais j'aimerai ne rien recevoir en retour afin de gagner du temps à l'exécution.
    Sauf que je n'ai pas trouvé le moyen d'annuler les effets de la commande "WaitCommEvent()".
    Je suis obligé de lire la réception et de ne pas l'afficher.
    J'aimerai savoir comment annuler cette commande "WaitCommEvent()".
    Bonsoir,

    Tu peux factoriser ces deux fonctions, elles sont quasi-identiques.
    Et pour ton problème, vois si les apis FlushFileBuffers() et PurgeComm() répondent à ton besoin.
    https://docs.microsoft.com/en-us/win...ushfilebuffers
    https://docs.microsoft.com/en-us/win...base-purgecomm

  12. #12
    Expert éminent sénior
    Salut kaitlyn.

    Ces deux fonctions ne répondent pas à mes attentes.
    Pour "FlushFileBuffers()", je ne manipule aucun fichier.
    Pour "PurgeComm()", j'ai déjà testé et à part purger la communication, cela ne supprime pas la réception.

    A l'initialisation, j'utilise la fonction "SetCommMask()" pour Configurer le masque de réception.
    Quand j'appelle ma fonction "COM_Send()", je me mets à l'écoute de la communication en faisant un "WaitCommEvent()".
    Or dans la gestion de la communication série, j'utilise en premier la fonction "COM_Send()" (voir mes deux exemples).
    L'appel de la fonction "COM_SendBlind()" se fait juste après. Et comme dit précédemment, je ne sais pas annuler la réception des données.
    Inversement, si je n'utilise pas "SetCommMask()" et "WaitCommEvent()", je n'ai aucune réception et l'envoi est beaucoup plus rapide.

    J'ai vaguement compris que pour annuler son effet, je devais mettre NULL dans la fonction "SetCommMask()", sauf que cela provoque une erreur.
    Je n'ai trouvé aucun exemple où l'on gère les deux cas, transmettre avec et sans réception.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  13. #13
    Membre régulier
    Salut,

    Dans "Table 3. Hardware Flow-control Lines", il est écrit qu'en mettant les lignes RTS et / ou DTS à bas, l'équipement en bout de ligne suspend ses réponses. Pour ce faire, je vois pour l'instant deux fonctions: SetCommState() et EscapeCommFunction().

    Essaye de mettre un EscapeCommFunction(ton_handle, CLRRTS) et / ou EscapeCommFunction(ton_handle, CLRDTR) avant une transmission et voir si effectivement il n'y a rien à lire en retour.

  14. #14
    Expert éminent sénior
    Salut kaitlyn.

    Merci de t'intéresser à mon problème.

    En fait, j'ai plusieurs problèmes qui sont tous liés d'une part à l'affichage et d'autre part à une méconnaissance du fonctionnement des ports séries.

    a) Dans mon premier programme (faire clignoter une LED), j'utilise un script basic où j'affiche l'état de la LED après un delai de 100ms.
    100ms, c'est le temps du clignotement de la LED. Plus petit me semble un peu trop rapide.

    Je dois initialiser les variables "ReadIntervalTimeout" et "ReadTotalTimeoutConstant" dans la structure "COMMTIMEOUTS".
    L'usage de ces variables est de définir le temps d'attente d'une réponse (Read). Pour le Write, j'ai mis à zéro.
    Si la réponse met plus de temps que la valeur de l'initialisation, cela me provoque des problèmes dans le programme.
    Par exemple, blocage de l'affichage, les commandes suivantes ne sont pas prises en compte, voire sortie prématurée du programme ...

    Inversement, si je mets à l'initialisation une valeur plus grande que le délai (du script basic), par exemple 150ms, tout ce passe bien.
    J'y vais au pifomètre pour juger le résultat de l'affichage.
    J'ai même augmenté le nombre d'itérations de la boucle. Le programme est stable et se comporte comme je l'attends.

    La fonction "COM_Send(...)" utilise la valeur d'initialisation et attend la réponse afin de l'afficher.
    La fonction "COM_SendBlind(...)" utilise la valeur zéro, mais sans affichage.
    Les deux fonctions sont similaires, sauf en ce qui concerne l'affichage.

    En gros, je n'ai pas tout compris dans la façon de gérer le délai d'attente de la réponse.

    b) avec l'afficheur LCD, je constate que l'affichage est lent si j'envoie une chaîne de caractères depuis mon ordinateur Windows.
    Si je passe par le script basic, l'affichage est immédiat.
    Pour augmenter la rapidité, j'ai modifié la vitesse de transfert (commande "b" pour baudRate et j'ai mis 115200).
    C'est un peu plus rapide, mais c'est pas encore l'idéal. Ca reste plus lent que par le script basic.

    Sur ce point, je ne crois pas que je puisse faire mieux que la vitesse de transfert de 115200 bauds.

    c) Pourquoi j'utilise la fonction "COM_SendBlind(...)" ?
    Je l'utilise dans le cas de la saisie du script basic où chaque ligne validée est transcrite en valeur hexadécimale.
    Comme c'est pas beau à l'affiche et inutile, j'ai décidé de court circuiter cette partie.
    Tout ce dont j'ai besoin est de faire "list", "run" et pour sortir du mode script basic "exit".

    Donc oui, je n'ai pas besoin d'une réponse en retour à l'envoi de la saisie du script basic.

    d) j'ai regardé la documentation sur le paramétrage du port série windows.
    J'ai repris tes remarques qui au final ne mon par servi.
    C'est bien l'initialisation de la COMMTIMEOUTS qui est en cause, c'est-à-dire les délais d'attente.

    Ou si tu préfères, je ne maîtrise pas les points suivants (pour l'instant) :

    --> j'ignore la volumétrie de ce que je vais recevoir et donc le temps pour obtenir la totalité de la réponse.
    Si je mets une valeur trop petite, je risque de perdre des informations à l'affichage.
    Si je mets une valeur trop grande, je vais passer mon temps à attendre.
    Je ne peux pas mettre la même valeur pour tous mes programmes de prise de contrôles du bus pirate.
    Je dois ajuster selon ce que je désire faire comme test.

    --> la vitesse de transfert de windows vers le bus pirate est très lent à mon gout.
    Je ne pourrai pas obtenir satisfaction comme dans le cas du transfert des chaînes de caractères depiis windows vers l'afficheur LCD.
    Une solution serait de le faire avec le script basic, mais cela serait trop lourd à mettre en oeuvre.
    Je dois me satisfaire de cette lenteur. Le but de ces programmes n'est pas de faire une application, mais juste des tests.
    Par test, je veux dire apprendre à manipuler des concepts d'électronique que je ne connais pas.

    --> je suis limité par la volumétrie de ce que je peux saisir en tant que script basic. Je ne peux faire aucune sauvegarde !
    D'où l'intérêt d'un programme c / Win32 de prise de contrôle depuis windows du bus pirate dans un test particulier.
    Cela me permet de figer mon test et de revenir dessus si j'ai besoin de le perfectionner.
    Je ne maîtrise pas trop encore le port série, mais je m'y emploi.

    --> Je découvre petit à petit ce que le bus pirate permet de faire.
    C'est didactique, surtout avec une breadboard pour tester un composant électronique.
    Pourquoi ne pas faire la même chose avec le Raspberry ? Je trouve que cela demande beaucoup plus de connaissance comme dans le cas de l'I2C.
    Je découvre et cela me permet de comprendre un peu plus facilement comment fonctionne certaines communications.

    Pour les prochain test, je vais étudier :

    *) Real Time Clock. C'est encore de l'I2C mais bien plus simple à gérer.
    *) capteur de température : 1-wire.
    *) deux registres à décalage 74HC595 avec 16 leds : spi.
    *) potentiomètre 10K ohms : DIO avec lecture de la valeur.
    *) pression et humidité.

    Si vous avez des idées sur d'autres tests à faire, je suis preneur.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr