fb11e647
 vrobic
reseau statique a...
|
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
|
/*
* Copyright (C) 2015 Freie Universitรคt Berlin
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @ingroup tests
* @{
*
* @file
* @brief Manual test application for UART peripheral drivers
*
* @author Hauke Petersen <hauke.petersen@fu-berlin.de>
*
* @}
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "board.h"
#include "shell.h"
#include "thread.h"
#include "msg.h"
#include "ringbuffer.h"
#include "periph/uart.h"
#include "uart_stdio.h"
#define SHELL_BUFSIZE (128U)
#define UART_BUFSIZE (128U)
#define PRINTER_PRIO (THREAD_PRIORITY_MAIN - 1)
#define PRINTER_TYPE (0xabcd)
#ifndef UART_STDIO_DEV
#define UART_STDIO_DEV (UART_UNDEF)
#endif
typedef struct {
char rx_mem[UART_BUFSIZE];
ringbuffer_t rx_buf;
} uart_ctx_t;
static uart_ctx_t ctx[UART_NUMOF];
static kernel_pid_t printer_pid;
static char printer_stack[THREAD_STACKSIZE_MAIN];
static int parse_dev(char *arg)
{
unsigned dev = (unsigned)atoi(arg);
if (dev >= UART_NUMOF) {
printf("Error: Invalid UART_DEV device specified (%u).\n", dev);
return -1;
}
else if (UART_DEV(dev) == UART_STDIO_DEV) {
printf("Error: The selected UART_DEV(%u) is used for the shell!\n", dev);
return -2;
}
return dev;
}
static void rx_cb(void *arg, uint8_t data)
{
uart_t dev = (uart_t)arg;
ringbuffer_add_one(&(ctx[dev].rx_buf), data);
if (data == 0) {
msg_t msg;
msg.content.value = (uint32_t)dev;
msg_send(&msg, printer_pid);
}
}
static void *printer(void *arg)
{
(void)arg;
msg_t msg;
msg_t msg_queue[8];
msg_init_queue(msg_queue, 8);
while (1) {
msg_receive(&msg);
uart_t dev = (uart_t)msg.content.value;
char c;
printf("UART_DEV(%i) RX: ", dev);
do {
c = (int)ringbuffer_get_one(&(ctx[dev].rx_buf));
if (c == 0) {
puts("");
}
else if (c >= ' ' && c <= '~') {
printf("%c", c);
}
else {
printf("0x%02x", (unsigned char)c);
}
} while (c != 0);
}
/* this should never be reached */
return NULL;
}
static int cmd_init(int argc, char **argv)
{
int dev, res;
uint32_t baud;
if (argc < 3) {
printf("usage: %s <dev> <baudrate>\n", argv[0]);
return 1;
}
/* parse parameters */
dev = parse_dev(argv[1]);
if (dev < 0) {
return 1;
}
baud = (uint32_t)atoi(argv[2]);
/* initialize UART */
res = uart_init(UART_DEV(dev), baud, rx_cb, (void *)dev);
if (res == UART_NOBAUD) {
printf("Error: Given baudrate (%u) not possible\n", (unsigned int)baud);
return 1;
}
else if (res != UART_OK) {
puts("Error: Unable to initialize UART device\n");
return 1;
}
printf("Successfully initialized UART_DEV(%i)\n", dev);
return 0;
}
static int cmd_send(int argc, char **argv)
{
int dev;
if (argc < 3) {
printf("usage: %s <dev> <data (string)>\n", argv[0]);
return 1;
}
/* parse parameters */
dev = parse_dev(argv[1]);
if (dev < 0) {
return 1;
}
printf("UART_DEV(%i) TX: %s\n", dev, argv[2]);
uart_write(UART_DEV(dev), (uint8_t *)argv[2], strlen(argv[2]) + 1);
return 0;
}
static const shell_command_t shell_commands[] = {
{ "init", "Initialize a UART device with a given baudrate", cmd_init },
{ "send", "Send a string through given UART device", cmd_send },
{ NULL, NULL, NULL }
};
int main(void)
{
puts("\nManual UART driver test application");
puts("===================================");
puts("This application is intended for testing additional UART\n"
"interfaces, that might be defined for a board. The 'primary' UART\n"
"interface is tested implicitly, as it is running the shell...\n\n"
"When receiving data on one of the additional UART interfaces, this\n"
"data will be outputted via STDIO. So the easiest way to test an \n"
"UART interface, is to simply connect the RX with the TX pin. Then \n"
"you can send data on that interface and you should see the data \n"
"being printed to STDOUT\n");
puts("UART INFO:");
printf("Available devices: %i\n", UART_NUMOF);
printf("UART used for STDIO (the shell): UART_DEV(%i)\n\n", UART_STDIO_DEV);
/* initialize ringbuffers */
for (unsigned i = 0; i < UART_NUMOF; i++) {
ringbuffer_init(&(ctx[i].rx_buf), ctx[i].rx_mem, UART_BUFSIZE);
}
/* start the printer thread */
printer_pid = thread_create(printer_stack, sizeof(printer_stack),
PRINTER_PRIO, 0, printer, NULL, "printer");
/* run the shell */
char line_buf[SHELL_DEFAULT_BUFSIZE];
shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
return 0;
}
|