Discussion :

[Artemus24]

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-Pirate-Cable-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 ?

@+

[Vincent PETIT]

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.

[Artemus24]

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.

@+

[Vincent PETIT]

Salut

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.

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.

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)

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.

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é.

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Ω

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)

[Artemus24]

Salut 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".

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.

Prends du linéaire, les moins chers,

Pour le potentiomètre, je vais suivre ton conseil. Merci.

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€.

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-74hc595-20150.htm

Je vais devoir poser la question à Gotronic.

@+

[Artemus24]

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.
@+

[Artemus24]

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.

@+

[Artemus24]

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.

@+

[f-leb]

Salut,

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.

[Artemus24]

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).

@+

[kaitlyn]

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

[Artemus24]

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.

@+

[kaitlyn]

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.

[Artemus24]

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.

@+

[Artemus24]

Salut à tous.

J'ai fait le choix de jouer sur le temps de réponse afin de capter toutes les réceptions sans rien perdre comme information.
Selon le programme, je dois faire un ajustement de cette valeur.
D'après mes deux tests (clignotement d'une led, afficheur LCD 20x04), maintenant ça fonctionne correctement.

Je rencontre un problème dans la transmission du bus pirate vers l'afficheur LCD.
Quand je passe par le script basic, je transmets six octets et ça fonctionne correctement.
Quand je passe par mon programme 'C/C++' et que je transmet ses six octets, ça ne fonctionne plus.

Le mode d'écriture est le même (transmission de six octets) et j'ai comparé les octets afin de voir s'il existe une différence : il n'y en a pas.
Quand je transmets trois octets, ça fonctionne correctement. Du coup, je ne comprends pas cette différence.
J'ai fait deux fois le test, mais le problème persiste.

@+

[kaitlyn]

Salut,

As-tu du code pour illustrer tes propos ?

[Artemus24]

Salut kaitlyn.

Le code se trouve dans le message #10.
La partie que j'affiche ci-dessous fonctionne correctement. La voici :

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
/*=======================================*/
/*     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);
}

Je désire supprimer la fonction LCD_four_bits et introduire d'une part ce transfert dans les deux autres fonctions et d'autre part le faire sur six octets, et non trois comme actuellement.
Ce qui donnerait

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
/*=================================*/
/*     Ecriture d'une commande     */
/*=================================*/
 
void LCD_command(unsigned char _data)
{
	unsigned char _val1 =  _data       & 0xF0;
	unsigned char _val2 = (_data << 4) & 0xF0;
	unsigned char _mode = 0x00;
 
	sprintf(Tampon,"[0x4E 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X]\n",
	(_val1|_mode|LCD_BL),((_val1|LCD_E)|_mode|LCD_BL),(((_val1&~LCD_E)|_mode|LCD_BL))
	(_val2|_mode|LCD_BL),((_val2|LCD_E)|_mode|LCD_BL),(((_val2&~LCD_E)|_mode|LCD_BL)));
	COM_SendBlind(Tampon);
}
 
 
/*=================================*/
/*     Ecriture d'un caractère     */
/*=================================*/
 
void LCD_char(unsigned char _data)
{
	unsigned char _val1 =  _data       & 0xF0;
	unsigned char _val2 = (_data << 4) & 0xF0;
	unsigned char _mode = LCD_RS;
 
	sprintf(Tampon,"[0x4E 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X]\n",
	(_val1|_mode|LCD_BL),((_val1|LCD_E)|_mode|LCD_BL),(((_val1&~LCD_E)|_mode|LCD_BL))
	(_val2|_mode|LCD_BL),((_val2|LCD_E)|_mode|LCD_BL),(((_val2&~LCD_E)|_mode|LCD_BL)));
	COM_SendBlind(Tampon);
}

La syntaxe pour le transfert de trois octets est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[0x4E 0x00 0x00 0x00]\n

Si maintenant j'adapte à six octets, la syntaxe devient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[0x4E 0x00 0x00 0x00 0x00 0x00 0x00]\n

Sauf que cette syntaxe ne fonctionne pas.
Je me demande (je n'ai pas encore testé) si je ne devrais pas plutôt écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[0x4E 0x00 0x00 0x00 [0x4e 0x00 0x00 0x00]\n

S'il y a une erreur dans ce que j'ai écrit, je ne la vois pas.

@+

[kaitlyn]

Salut,

Oui, le dernier morceau de code devrait convenir, avec donc un RESTART BIT entre les commandes, mais dans ce cas, pourquoi ne pas remplir ton tampon (buffer append) et l'envoyer à la fin (send buffer <=> writefile(... buffer)).

[Artemus24]

Salut kaitlyn.

J'ai pas bien compris, tu veux que je fasse un seul envoie de ce buffer, contenant la totalité de mes commandes et caractères ?
Je me demande si la taille du buffer de mon bus pirate sera suffisante.
Il est vrai que je n'ai pas pensé à cette façon de procéder.
Du coup, l'affichage sera plus rapide, enfin je crois.

Il faut que j'essaye.

Merci pour l'information.
@+

[Artemus24]

Salut kaitlyn.

J'ai trouvé pourquoi le transfert de six octets ne fonctionnait pas. Cela n'a rien à voir avec la syntaxe.
Je devais mettre un "Sleep(10)" juste après ma commande "COM_Send()".
Tout ce passe comme si mon ordinateur était trop rapide par rapport au Bus Pirate.

@+