Pimoroni / Unicorn Hat HD / PIM273 / 256 LEDs !

**Artemus24** · 05/04/2020, 23h50

Salut à tous.

Pour ceux qui ne connaissent pas ce HAT, voici le lien ci-après, dont j'ai fait l'acquisition chez GoTronic :
--> https://www.gotronic.fr/art-module-u...m273-28807.htm

Il s'agit d'une matrice 16x16 (soit 256 LEDs) que l'on peut utiliser pour afficher une image, ou faire de l'animation.
J'ai téléchargé dans ma raspberry Pi 3B, le programme Python qui permet de manipuler ce Hat :
--> https://github.com/pimoroni/unicorn-hat-hd

J'ai testé les exemples qui sont à ma disposition et je trouve cela fort intéressant.
Je désire faire un développment en 'C/C++' afin de manipuler ce module hat, à partir du mode SPI de la Raspberry Pi.
Le but est de passer par la fonction "ioctl()" pour manipuler ce module hat.

J'ai résussi à faire le pilotage sur un exemple plutôt simpliste :

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
/************************************************/
/*                                              */
/*     Pimoroni - Unicorn Hat HD - 256 LEDs     */
/*                                              */
/************************************************/
 
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
 
#include <linux/types.h>
#include <linux/spi/spidev.h>
 
#include <sys/ioctl.h>
 
/*************************************/
/*                                   */
/*     Déclaration des Variables     */
/*                                   */
/*************************************/
 
int		_fd;
double		_brightness;
 
struct {
	unsigned char sof;
 
	struct {
		unsigned char red;
		unsigned char green;
		unsigned char blue;
	} color[256];
} _buffer;
 
 
/********************************/
/*                              */
/*     Pimoroni - Fonctions     */
/*                              */
/********************************/
 
void Pimoroni_Brightness(double _val)
{
	_brightness = _val;
 
	if (_val > 1.0)
		_brightness = 1.0;
 
	if (_val < 0.0)
		_brightness = 0.0;
}
 
 
void Pimoroni_Init(void)
{
	int	i;
 
	_buffer.sof = 0x72;
 
	for (i=0; i<256; i++)
	{
		_buffer.color[i].red   = 0x00;
		_buffer.color[i].green = 0x00;
		_buffer.color[i].blue  = 0x00;
	}
}
 
 
void Pimoroni_Write(void)
{
	if (!write(_fd, &_buffer, sizeof(_buffer)))
	{
		printf("Erreur écriture\n");
		exit(EXIT_FAILURE);
	}
 
	/*---------------*/
	/*     Pause     */
	/*---------------*/
 
	usleep((int)(1000000/120));
}
 
 
void Pimoroni_Send(int index)
{
	Pimoroni_Init();
 
	_buffer.color[index].red   = 255-index;	// Red
	_buffer.color[index].green =     index;	// Green
	_buffer.color[index].blue  =         0;	// Blue
 
	Pimoroni_Write();
}
 
 
 
void Pimoroni_Clear(void)
{
	Pimoroni_Init();
	Pimoroni_Write();
}
 
 
void Pimoroni_Pixel(int _x, int _y, int _red, int _green, int _blue)
{
	int _pos = _x * 16 + _y;
 
	_buffer.color[_pos].red   = (int) (_red   * _brightness);
	_buffer.color[_pos].green = (int) (_green * _brightness);
	_buffer.color[_pos].blue  = (int) (_blue  * _brightness);
}
 
 
void Pimoroni_Start(void)
{
	char	_device[256];
	int	_mode, _speed, _nbBits;
 
	/*-------------------*/
	/*     Ouverture     */
	/*-------------------*/
 
	sprintf(_device, "/dev/spidev0.0");
 
	if ((_fd = open(_device, O_RDWR)) < 0)
	{
		printf("Erreur ouverture mode SPI\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t+=========================+\n");
	printf("\t\t| Device : %14s |\n", _device);
 
	/*--------------*/
	/*     Mode     */
	/*--------------*/
 
	_mode = SPI_MODE_0;
 
	if (ioctl(_fd, SPI_IOC_WR_MODE32, &_mode) != 0)
	{
		printf("Erreur Mode SPI\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t|   Mode : %14d |\n", _mode);
 
	/*------------------------------*/
	/*     Vitesse du transfert     */
	/*------------------------------*/
 
	_speed = 9000000;
 
	if (ioctl(_fd, SPI_IOC_WR_MAX_SPEED_HZ, &_speed) != 0)
	{
		printf("Erreur vitesse\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t|  Speed : %14d |\n", _speed);
 
	/*--------------------------------*/
	/*     Nombre de bits par Mot     */
	/*--------------------------------*/
 
	_nbBits = 8;
 
	if (ioctl(_fd, SPI_IOC_WR_BITS_PER_WORD, &_nbBits) != 0)
	{
		printf("Erreur Nombre de Bits\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t|   Bits : %14d |\n", _nbBits);
	printf("\t\t+=========================+\n");
}
 
 
void Pimoroni_Finish(void)
{
	/*----------------------------------------------*/
	/*     Remise à zéro du Buffer et Affichage     */
	/*----------------------------------------------*/
 
	Pimoroni_Init();
	Pimoroni_Write();
 
	/*-------------------*/
	/*     Fermeture     */
	/*-------------------*/
 
	if (close(_fd) < 0)
	{
		printf("Erreur Fermeture mode SPI\n");
		exit(EXIT_FAILURE);
	}
}
 
 
/********************************/
/*                              */
/*     Procédure Principale     */
/*                              */
/********************************/
 
int main(void)
{
	int	i, j;
 
	system("clear;");
 
	Pimoroni_Start();
	Pimoroni_Init();
 
	/*===============================*/
	/*                               */
	/*===============================*/
 
	for (i=0; i<2; i++)
		for (j=0; j<256; j++)
			Pimoroni_Send(j);
 
	/*===============================*/
	/*                               */
	/*===============================*/
 
	Pimoroni_Brightness(0.1);
	Pimoroni_Init();
 
		for (i=0; i<8; i++)
		{
			for (j=i; j<=15-i; j++)
				Pimoroni_Pixel(   i,    j, 255,   0,   0);
 
			Pimoroni_Write();
 
			for (j=i; j<=15-i; j++)
				Pimoroni_Pixel(   j,    i,   0,   0, 255);
 
			Pimoroni_Write();
 
			for (j=i; j<=15-i; j++)
				Pimoroni_Pixel(15-i, 15-j,   0, 255,   0);
 
			Pimoroni_Write();
 
			for (j=i; j<15-i; j++)
				Pimoroni_Pixel(15-j, 15-i, 255, 255,   0);
 
			Pimoroni_Write();
		}
 
	usleep((int)(2000000));
 
	Pimoroni_Finish();
	exit(0);
}

Ce programme n'est pas terminé mais il fonctionne.

Voici mes questions :

1) je n'ai pas compris le rôle joué par le "SOF" (structure du buffer) ?
Que signifie ce signe SOF ? Pourquoi dois-je le mettre au début du transfert du buffer ?

2) je n'ai pas compris la signification du mode (Pimoroni_Start()) dans l'initialisation du mode SPI ? Ni sa signification.

3) j'aimerai avoir la documentation de ce module hat de Pimoroni, sauf que je ne l'ai rien trouvé ?
Est-ce qu'elle se résume au lien suivant :
--> https://github.com/pimoroni/unicorn-hat-hd

4) avez-vous de la documentation sur le mode SPI ? Ou bien, un lien assez détaillé ?

5) peut-on améliorer ce programme, dans les aspect du mode SPI ?

@+

**f-leb** · 06/04/2020, 16h34

Salut,

Envoyé par Artemus24

2) je n'ai pas compris la signification du mode (Pimoroni_Start()) dans l'initialisation du mode SPI ? Ni sa signification.

Avec cette ligne-là ?

Code :

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

_mode = SPI_MODE_0;

Je suppose que c'est lié à la configuration de la communication SPI, voir Polarité et phase de l'horloge.
Le mode 0 correspond à CPOL=0 et CPHA=0, un mode par défaut, j'en parle un peu ici.

Nom : 100000000000025A000000E274D2432ACB925602.png
Affichages : 107
Taille : 36,4 Ko

Nom : 100000000000025A000000E274D2432ACB925602.png
Affichages : 107
Taille : 36,4 Ko

Mode 0 : l'horloge est à l'état bas au repos. Chaque bit aligné sur les lignes MOSI et MISO est échantillonné sur front montant de l'horloge. Sur front descendant, les bits sont mis à jour.

Pour le reste, si je trouve un peu de doc, sinon...

**f-leb** · 06/04/2020, 16h38

SOF = Start Of Frame ? L'octet qui marque le début de la trame SPI.

**Artemus24** · 06/04/2020, 19h33

Salut à tous.

J'ai terminé mon programme 'C/C++'.

Voici le fichier "libpim.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
/************************************************/
/*                                              */
/*     Pimoroni - Unicorn Hat HD - 256 LEDs     */
/*                                              */
/************************************************/
 
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
 
#include <linux/types.h>
#include <linux/spi/spidev.h>
 
#include <sys/ioctl.h>
 
#include "libpim.h"
 
/*********************************/
/*                               */
/*     Déclaration des Types     */
/*                               */
/*********************************/
 
typedef struct
{
	unsigned char	red;
	unsigned char	green;
	unsigned char	blue;
} T_COLOR;
 
 
typedef struct
{
	unsigned char	sof;
	T_COLOR		color[256];
 
} T_BUFFER;
 
/*************************************/
/*                                   */
/*     Déclaration des Variables     */
/*                                   */
/*************************************/
 
int		_fd;
double		_brightness;
int		_rotation;
T_BUFFER	_buf_work, _buf_disp;
 
/********************************/
/*                              */
/*     Pimoroni - Fonctions     */
/*                              */
/********************************/
 
void PIM_Brightness(double _lux)
{
	_brightness = _lux;
 
	if (_lux > 1.0)
		_brightness = 1.0;
 
	if (_lux < 0.0)
		_brightness = 0.0;
}
 
 
void PIM_Rotation(int _shift)
{
	if ((_shift != 0) && (_shift != 1) && (_shift != 2) && (_shift != 3))
	{
		printf("Erreur dans la Rotation : %d\n", _shift);
		exit(EXIT_FAILURE);
	}
 
	_rotation = _shift;
}
 
 
void PIM_Delay(int _val)
{
	usleep(_val);
}
 
 
void PIM_Init(void)
{
	int	i;
 
	_buf_work.sof = 0x72;
	_buf_disp.sof = 0x72;
 
	for (i=0; i<256; i++)
	{
		_buf_work.color[i].red   = 0x00;
		_buf_work.color[i].green = 0x00;
		_buf_work.color[i].blue  = 0x00;
 
		_buf_disp.color[i].red   = 0x00;
		_buf_disp.color[i].green = 0x00;
		_buf_disp.color[i].blue  = 0x00;
	}
}
 
 
void PIM_Write(void)
{
	int	i, j;
 
	/*------------------*/
	/*     Rotation     */
	/*------------------*/
 
	for (i=0; i<16; i++)
	{
		for (j=0; j<16; j++)
		{
			switch(_rotation)
			{
				case 1: /*  90 degrée */
					_buf_disp.color[    j *16+(15-i)] = _buf_work.color[i*16+j];
					break;
 
				case 2: /* 180 degrée ok */
					_buf_disp.color[(15-i)*16+(15-j)] = _buf_work.color[i*16+j];
					break;
 
				case 3: /* 270 degrée */
					_buf_disp.color[(15-j)*16+    i ] = _buf_work.color[i*16+j];
					break;
 
				default: /*   0 degrée ok */
					_buf_disp.color[    i *16+    j]  = _buf_work.color[i*16+j];
					break;
			}
		}
	}
 
	/*-------------------*/
	/*     Affichage     */
	/*-------------------*/
 
	if (!write(_fd, &_buf_disp, sizeof(_buf_disp)))
	{
		printf("Erreur écriture vers module Pimoroni !\n");
		exit(EXIT_FAILURE);
	}
}
 
 
void PIM_Pixel(int _row, int _col, int _red, int _green, int _blue)
{
	int _pos = _row * 16 + _col;
 
	_buf_work.color[_pos].red   = (int) (_red   * _brightness);
	_buf_work.color[_pos].green = (int) (_green * _brightness);
	_buf_work.color[_pos].blue  = (int) (_blue  * _brightness);
}
 
 
void PIM_Start(void)
{
	char	_device[256];
	int	_mode, _speed, _nbBits;
 
	/*-------------------*/
	/*     Ouverture     */
	/*-------------------*/
 
	sprintf(_device, "/dev/spidev0.0");
 
	if ((_fd = open(_device, O_RDWR)) < 0)
	{
		printf("Erreur ouverture mode SPI\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t+=========================+\n");
	printf("\t\t| Device : %14s |\n", _device);
 
	/*--------------*/
	/*     Mode     */
	/*--------------*/
 
	_mode = SPI_MODE_0;
 
	if (ioctl(_fd, SPI_IOC_WR_MODE32, &_mode) != 0)
	{
		printf("Erreur Mode SPI\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t|   Mode : %14d |\n", _mode);
 
	/*------------------------------*/
	/*     Vitesse du transfert     */
	/*------------------------------*/
 
	_speed = 9000000;
 
	if (ioctl(_fd, SPI_IOC_WR_MAX_SPEED_HZ, &_speed) != 0)
	{
		printf("Erreur vitesse\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t|  Speed : %14d |\n", _speed);
 
	/*--------------------------------*/
	/*     Nombre de bits par Mot     */
	/*--------------------------------*/
 
	_nbBits = 8;
 
	if (ioctl(_fd, SPI_IOC_WR_BITS_PER_WORD, &_nbBits) != 0)
	{
		printf("Erreur Nombre de Bits\n");
		exit(EXIT_FAILURE);
	}
 
	printf("\t\t|   Bits : %14d |\n", _nbBits);
	printf("\t\t+=========================+\n");
}
 
 
void PIM_Finish(void)
{
	/*----------------------------------------------*/
	/*     Remise à zéro du Buffer et Affichage     */
	/*----------------------------------------------*/
 
	PIM_Init();
	PIM_Write();
 
	/*-------------------*/
	/*     Fermeture     */
	/*-------------------*/
 
	if (close(_fd) < 0)
	{
		printf("Erreur Fermeture mode SPI\n");
		exit(EXIT_FAILURE);
	}
}

Voici le fichier "libpim.h" :

Code c :

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

1
2
3
4
5
6
7
8
void PIM_Brightness(double _lux);
void PIM_Rotation(int _shift);
void PIM_Delay(int _val);
void PIM_Init(void);
void PIM_Write(void);
void PIM_Pixel(int _row, int _col, int _red, int _green, int _blue);
void PIM_Start(void);
void PIM_Finish(void);

Je vous donne aussi le fichier "MAKEFILE" dont je me suis servi :

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
# ------------------------------- #
#   Déclaration des Executables   #
# ------------------------------- #

RM	= @rm -f
CC	= @gcc
EX	= @chmod +x
AR	= @ar rc
RL	= @ranlib

# -------------------------- #
#   Déclaration des Objets   #
# -------------------------- #

SRC	= main.c
OBJ	= libpim.o
BIN	= libpim.a

# ---------------------------- #
#   Déclaration des Includes   #
# ---------------------------- #

INC1	= -I"."

INCS	= $(INC1)

# ------------------------------ #
#   Déclaration des Paramètres   #
# ------------------------------ #

FLAG1	= -O -Wall -Wextra -Wpedantic

FLAG	= $(FLAG1)

# ------------------------------------ #
#   Compilation et Edition des liens   #
# ------------------------------------ #

all: before $(BIN) after

before:
	clear
	$(RM) $(OBJ)
	$(RM) $(BIN)

$(BIN): $(OBJ)
	$(AR) $(BIN) $(OBJ)
	$(RL) $(BIN)

$(OBJ): $(SRC)
	$(CC) -c $(SRC) -o $(OBJ) $(INCS) $(FLAG)

after:
	$(RM) $(OBJ)

Voici le programme principal qui utilise cette DDL STATIC :

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
/************************************************/
/*                                              */
/*     Pimoroni - Unicorn Hat HD - 256 LEDs     */
/*                                              */
/************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include "libpim.h"
 
 
/********************************/
/*                              */
/*     Procédure Principale     */
/*                              */
/********************************/
 
int main(void)
{
	int	loop,row,col;
 
	system("clear;");
 
	/*========================*/
	/*     Initialisation     */
	/*========================*/
 
	PIM_Brightness(1);
	PIM_Rotation(0);
 
	PIM_Start();
 
	/*===============================*/
	/*                               */
	/*===============================*/
 
	for (loop=0; loop<2; loop++)
		for (row=0; row<16; row++)
			for (col=0; col<16; col++)
			{
				PIM_Init();
				PIM_Pixel(row,col,255-(row*16+col),(row*16+col),0);
				PIM_Write();
				PIM_Delay(5000);
			}
 
	/*===============================*/
	/*                               */
	/*===============================*/
 
	PIM_Brightness(0.1);
	PIM_Init();
 
	for (row=0; row<8; row++)
	{
		for (col=row; col<16-row; col++)
			PIM_Pixel(   row,   col,255,  0,  0);	// Ligne Rouge
 
		PIM_Write();
		PIM_Delay(50000);
 
		for (col=row; col<16-row; col++)
			PIM_Pixel(   col,   row,  0,  0,255);	// Ligne Bleue
 
		PIM_Write();
		PIM_Delay(50000);
 
		for (col=row; col<16-row; col++)
			PIM_Pixel(15-row,15-col,  0,255,  0);	// Ligne Verte
 
		PIM_Write();
		PIM_Delay(50000);
 
		for (col=row; col<15-row; col++)
			PIM_Pixel(15-col,15-row,255,255,  0);	// Ligne Jaune
 
		PIM_Write();
		PIM_Delay(50000);
	}
 
	getchar();
 
	/*=================================*/
	/*     Rotation de  90 Degrée      */
	/*=================================*/
 
	PIM_Rotation(1);
	PIM_Write();
	getchar();
 
	/*=================================*/
	/*     Rotation de 180 Degrée      */
	/*=================================*/
 
	PIM_Rotation(2);
	PIM_Write();
	getchar();
 
	/*=================================*/
	/*     Rotation de 270 Degrée      */
	/*=================================*/
 
	PIM_Rotation(3);
	PIM_Write();
	getchar();
 
	/*===========================*/
	/*     Fin du Traitement     */
	/*===========================*/
 
	PIM_Finish();
	exit(0);
}

Ainsi que le fichier MAKEFILE :

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
# ------------------------------- #
#   Déclaration des Executables   #
# ------------------------------- #

RM	= @rm -f
CC	= @gcc
EX	= @chmod +x

# -------------------------- #
#   Déclaration des Objets   #
# -------------------------- #

SRC	= main.c
OBJ	= main.o
BIN	= pimoroni 

# ---------------------------- #
#   Déclaration des Includes   #
# ---------------------------- #

INC1	= -I"."
INC2	= -I"../include/"

INCS	= $(INC1) $(INC2)

# --------------------------------- #
#   Déclaration des Bibliothèques   #
# --------------------------------- #

LIBS	= -L"../include/"

ADD	= "../include/libpim.a"

# ------------------------------ #
#   Déclaration des Paramètres   #
# ------------------------------ #

FLAG1	= -O -Wall -Wextra -Wpedantic

FLAG	= $(FLAG1)

# ------------------------------------ #
#   Compilation et Edition des liens   #
# ------------------------------------ #

all: before $(BIN) after

before:
	clear
	$(RM) $(OBJ)
	$(RM) $(BIN)

$(BIN): $(OBJ)
	$(CC)    $(OBJ) $(INCS) $(ADD) -o $(BIN) $(LIBS)

$(OBJ): $(SRC)
	$(CC) -c $(SRC) $(INCS)        -o $(OBJ) $(FLAG)

after:
	$(RM) $(OBJ)
	$(EX) $(BIN)
	@./$(BIN)

Dans la console Raspberry, voici ce que j'obtiens :

Code :

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

1
2
3
4
5
6
                +=========================+
                | Device : /dev/spidev0.0 |
                |   Mode :              0 |
                |  Speed :        9000000 |
                |   Bits :              8 |
                +=========================+

Pour l'affichage sur le module unicorn hat hd, le mieux est de le tester par vous même.

@+

**Artemus24** · 06/04/2020, 19h45

Salut f-leb.

Envoyé par f-leb

Avec cette ligne-là ?

Code :

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

_mode = SPI_MODE_0;

Oui, il s'agit bien de cette ligne. Comme j'ai repris un exemple, j'ai mis la même chose sans connaitre le pourquoi du comment.

Je cherche à savoir si l'initialisation du mode SPI est correcte, s'il ne manque pas quelque chose.
Je n'ai pas traité la lecture, car je n'ai pas besoin de lire quoi que ce soit avec le module unicorn hat hd (256 leds).

Envoyé par f-leb

SOF = Start Of Frame ? L'octet qui marque le début de la trame SPI.

Il est bien de connaitre la signification des abréviations.

Pour l'instant, j'ai trouvé que le mode SPI est plus facile à mettre au point que le mode I2C.
A l'exécution, c'est plutôt rapide, à l'inverse du mode I2C.

Bidouiller sur des exemples d'électroniques simple me plait beaucoup !

Maintenant, il faut trouver d'autres HAT pour continuer mes bidouilles en 'C/C++'.

Il serait intéressant que je puisse jeter un coup d’œil dans la DDL WiringPi ou dans la DDL "bcm2835".
Sais-tu où se trouve le source de ces deux DDL ?

@+

**f-leb** · 06/04/2020, 23h29

Apparemment tu t'amuses bien avec ces jouets

On voit que ce HAT comprend en amont un microcontrôleur ARM et des drivers de LED. Finalement il n'y a qu'à préparer un buffer 16x16x3 + l'octet de début de trame (0x72) et à le transférer au microcontrôleur ARM via la liaison SPI qui se charge du reste.
On trouve des infos sur le site de Pimoroni

C example for Unicorn hat HD avec des exemples en utilisant les bibliothèques bcm2835 ou wiringpi.

Le SPI est en général plus rapide que l'I2C. Tu peux peut-être encore augmenter la fréquence (10MhZ voire plus).

**Artemus24** · 07/04/2020, 16h04

Salut f-leb.

Envoyé par f-leb

Apparemment tu t'amuses bien avec ces jouets

Avec le confinement, les journées sont bien longues. Je m'occupe comme je peux et c'est vrai, je m'amuse bien.

Sauf que je n'ai plus de jouets à tester maintenant.

Envoyé par f-leb

On trouve des infos sur le site de Pimoroni C example for Unicorn hat HD avec des exemples en utilisant les bibliothèques bcm2835 ou wiringpi.

Je connaissais ce sujet du forum Pimoroni.

J'ai d'abord testé avec la DDL WiringPi, puis j'ai cherché à le faire par moi-même, sans trop de difficulté d'ailleurs.

Envoyé par f-leb

Le SPI est en général plus rapide que l'I2C.

C'est ce que j'ai constaté aussi.

Envoyé par f-leb

Tu peux peut-être encore augmenter la fréquence (10MhZ voire plus).

J'ai repris la valeur que j'ai trouvé dans l'application Python : 9 000 000.
J'ai testé à 50 000 000, ça ne passe pas, tandis qu'à 40 000 000 ça passe correctement.
Du coup, j'ai mis un peu moins, soit 20 000 000.

Comme j'utilise un délai entre chaque affichage, augmenter la vitesse de transfert ne m'apporte rien de plus.

Il n'y a pas trop d'activités sur le forum et c'est dommage.
J'ai testé le mode GPIO, I2C et SPI, y-a-t-il un autre mode de transfert dans la Raspberry Pi ?

J'attends que tout revienne dans l'ordre pour passer ma prochaine commande chez GoTronic et chez Kubii.
Je vais me procurer d'autres composants que je vais tester avec la Raspberry Pi, mon Bus Pirate et mon prochain achat, le module NodeMCU ESP32.

@+

**f-leb** · 07/04/2020, 18h46

Envoyé par Artemus24

Sauf que je n'ai plus de jouets à tester maintenant.

C'est embêtant, mais je suis sûr que tu vas te trouver une occupation avec le matériel dont tu disposes déjà

Envoyé par Artemus24

J'ai testé le mode GPIO, I2C et SPI, y-a-t-il un autre mode de transfert dans la Raspberry Pi ?

Le mode GPIO, qu'est-ce donc ?? Il reste évidemment la liaison série UART Rx/Tx classique si ce n'est déjà fait.

**Artemus24** · 07/04/2020, 23h49

Salut f-leb.

Envoyé par f-leb

Le mode GPIO, qu'est-ce donc ??

C'est un abus de langage de ma part.

Comment nommes-tu le fait de mettre un GPIO à "IN" ou à "OUT" ? Je nomme cela un MODE de fonctionnement, non ?
Je vais revenir sur ce mode car je suis passé par la DDL BCM2835 pour gérer mes leds.
Je ne sais même pas par où commencer pour piloter un GPIO.

Envoyé par f-leb

Il reste évidemment la liaison série UART Rx/Tx classique si ce n'est déjà fait.

C'est déjà fait. J'ai traité deux cas :
--> Gadget serial (câble USB A mâle / micro USB mâle) via la raspberry pi zéro w.
--> l'UART avec un câble debug serial USB-TTL vers la raspberry pi 3B+.

J'ai aussi traité ce que l'on nomme "gadget ethernet" avec un câble USB A mâle / micro USB mâle.
(Driver sous windows : USB Ethernet / RNDIS Gadget).

Sous windows, j'ai géré une communication série vers mon bus pirate par un programme 'C/C++'.
Si je passe par le câble debug serial USB-TTL vers la raspberry, j'obtiendrai le même genre de traitement.
Donc oui, l'UART a déjà été testé.

@+

**f-leb** · 08/04/2020, 00h29

Envoyé par Artemus24

C'est un abus de langage de ma part.

Comment nommes-tu le fait de mettre un GPIO à "IN" ou à "OUT" ? Je nomme cela un MODE de fonctionnement, non ?
Je vais revenir sur ce mode car je suis passé par la DDL BCM2835 pour gérer mes leds.
Je ne sais même pas par où commencer pour piloter un GPIO.

Ah ok, je cherchais un autre protocole de communication série (comme UART, I2C et SPI). Tu voulais parler du pilotage des entrées-sorties numériques du port GPIO.

Il y a aussi les protocoles de communication série sur un seul fil à voir : le 1-wire du DS18B20 par exemple, ou celui du capteur de température et humidité DHT11/22. Ces protocoles ne sont pas très compliqués et tu peux créer ta propre bibliothèque pour communiquer avec ces capteurs (bit banging).

**Artemus24** · 08/04/2020, 16h43

Salut f-leb.

Envoyé par f-leb

Tu voulais parler du pilotage des entrées-sorties numériques du port GPIO.

Oui, je parlais bien de cela.

Envoyé par f-leb

Il y a aussi les protocoles de communication série sur un seul fil à voir : le 1-wire du DS18B20 par exemple

J'ai vu aussi dans le menu du bus pirate : 1-wire, 2-wire, 3-wire. Je suppose que cela existe dans la Raspberry Pi.

Envoyé par f-leb

ou celui du capteur de température et humidité DHT11/22.

Pour les composants électroniques, il me faut tester la lecture et l'écriture (enfin la transmission et la réception).
Comme j'ai testé la transmission en mode SPI, il me faudrait un composant où je puisse faire une réception. Idem avec le mode I2C.

Envoyé par f-leb

Ces protocoles ne sont pas très compliqués et tu peux créer ta propre bibliothèque pour communiquer avec ces capteurs (bit banging).

Le but est de me constituer une bibliothèque de fonctionnalité que j'utiliserai dans mes programmes.

Ce ne sont que des tests que je fais, histoire de comprendre comment ces modes de communications fonctionnent.

@+

**f-leb** · 08/04/2020, 17h48

Salut,

Sur le Pi, l'UART/SPI/I2C sont implémentés en hardware avec des broches dédiées. Par exemple pour l'UART.

Pour le 1-wire ce n'est pas le cas, et les signaux du protocole doivent être produits ou récupérés de façon logicielle sur une broche GPIO configurée en sortie ou en entréee.

Envoyé par Artemus24

Pour les composants électroniques, il me faut tester la lecture et l'écriture (enfin la transmission et la réception).
Comme j'ai testé la transmission en mode SPI, il me faudrait un composant où je puisse faire une réception. Idem avec le mode I2C.

La réception ne devrait pas poser plus de problème que la transmission, un write suivi d'un read le plus souvent... La difficulté provient de la lecture de la datasheet du composant pour comprendre ce qu'il retourne et comment traiter l'information.

Pimoroni / Unicorn Hat HD / PIM273 / 256 LEDs !

Raspberry Pi

Discussions similaires

Partager

Partager