Revision 6ca98a3f
Eradicated use of signed chars in serial d'oh
toolbox/main.c | ||
---|---|---|
18 | 18 |
}; |
19 | 19 |
|
20 | 20 |
static enum toolstate_t toolstate = TS_INIT; |
21 |
static char coils;
|
|
22 |
static char current_user[RFID_SERNO_SIZE];
|
|
21 |
static uint8_t coils;
|
|
22 |
static uint8_t current_user[RFID_SERNO_SIZE];
|
|
23 | 23 |
|
24 | 24 |
static inline void set_coil(char coil, char bit) { |
25 |
coils |= (bit << coil);
|
|
25 |
coils = (coils & ~(1 << coil)) | (bit << coil);
|
|
26 | 26 |
} |
27 | 27 |
static inline char get_coil(char coil) { |
28 | 28 |
return (coils >> coil) & 1; |
... | ... | |
170 | 170 |
switch (addr) { |
171 | 171 |
|
172 | 172 |
case MB_INP_SERNOL: |
173 |
// TODO check that these (and the ones in SERNOH) are in the right order |
|
174 | 173 |
*reg_buf++ = current_user[0]; |
175 | 174 |
*reg_buf++ = current_user[1]; |
176 | 175 |
n_regs--; |
... | ... | |
224 | 223 |
rfid_start_read(); |
225 | 224 |
while (1) { |
226 | 225 |
if (rfid_poll()) { |
226 |
rfid_get_serno(current_user); |
|
227 | 227 |
rfid_start_read(); |
228 | 228 |
} |
229 |
rfid_get_serno(current_user); |
|
230 | 229 |
//tool_main(); |
231 | 230 |
eMBPoll(); |
232 | 231 |
_delay_ms(50); |
toolbox/rfid.c | ||
---|---|---|
1 | 1 |
#include <string.h> |
2 |
#include <stdint.h> |
|
2 | 3 |
#include <util/delay.h> |
3 | 4 |
#include "rfid.h" |
4 | 5 |
#include "serial.h" |
5 | 6 |
|
6 |
static char read_cmd[] = {'!', 'R', 'W', 1, 32};
|
|
7 |
static uint8_t read_cmd[] = {'!', 'R', 'W', 1, 32};
|
|
7 | 8 |
|
8 | 9 |
static int serno_idx; |
9 |
static char serno[RFID_SERNO_SIZE];
|
|
10 |
static uint8_t serno[RFID_SERNO_SIZE];
|
|
10 | 11 |
|
11 | 12 |
static void zero_serno() { |
12 | 13 |
int i; |
... | ... | |
72 | 73 |
char rfid_poll() { |
73 | 74 |
int c; |
74 | 75 |
|
75 |
c = serial_read(); |
|
76 |
while (c >= 0) { |
|
76 |
while ((c = serial_read()) >= 0) { |
|
77 | 77 |
|
78 | 78 |
if (serno_idx < 0) { |
79 | 79 |
if (c != RFID_OK) { |
... | ... | |
89 | 89 |
return 1; |
90 | 90 |
} |
91 | 91 |
|
92 |
c = serial_read(); |
|
93 | 92 |
} |
94 | 93 |
|
95 | 94 |
return 0; |
96 | 95 |
} |
97 | 96 |
|
98 |
void rfid_get_serno(char *buf) {
|
|
97 |
void rfid_get_serno(uint8_t *buf) {
|
|
99 | 98 |
memcpy(buf, serno, sizeof(serno)); |
100 | 99 |
} |
101 | 100 |
|
102 |
char rfid_check_serno(char *buf) {
|
|
101 |
char rfid_check_serno(uint8_t *buf) {
|
|
103 | 102 |
return memcmp(buf, serno, sizeof(serno)) == 0; |
104 | 103 |
} |
105 | 104 |
|
toolbox/serial.c | ||
---|---|---|
1 |
#include "serial.h"
|
|
1 |
#include <stdint.h>
|
|
2 | 2 |
#include <avr/io.h> |
3 | 3 |
#include <avr/interrupt.h> |
4 |
#include "serial.h" |
|
4 | 5 |
|
5 | 6 |
static int rx_start = 0, rx_end = 0; |
6 |
static char rx_buffer[RX_BUFFER_SIZE];
|
|
7 |
static uint8_t rx_buffer[RX_BUFFER_SIZE];
|
|
7 | 8 |
|
8 | 9 |
ISR(USART1_RX_vect) { |
9 |
char data = UDR1;
|
|
10 |
uint8_t data = UDR1;
|
|
10 | 11 |
int new_end = rx_end+1; |
11 | 12 |
if (new_end == RX_BUFFER_SIZE) { |
12 | 13 |
new_end = 0; |
... | ... | |
43 | 44 |
} else { |
44 | 45 |
ret = rx_buffer[rx_start]; |
45 | 46 |
rx_start++; |
46 |
if (rx_start == RX_BUFFER_SIZE) |
|
47 |
if (rx_start == RX_BUFFER_SIZE) {
|
|
47 | 48 |
rx_start = 0; |
49 |
} |
|
48 | 50 |
} |
49 | 51 |
sei(); |
50 | 52 |
return ret; |
... | ... | |
57 | 59 |
sei(); |
58 | 60 |
} |
59 | 61 |
|
60 |
char serial_read_blocking() {
|
|
62 |
uint8_t serial_read_blocking() {
|
|
61 | 63 |
int c; |
62 | 64 |
do { |
63 | 65 |
c = serial_read(); |
... | ... | |
65 | 67 |
return c; |
66 | 68 |
} |
67 | 69 |
|
68 |
void serial_write(char* data, int length) {
|
|
70 |
void serial_write(uint8_t* data, int length) {
|
|
69 | 71 |
int i; |
70 | 72 |
for (i = 0; i < length; i++) { |
71 | 73 |
while (!(UCSR1A & _BV(UDRE1))); |
toolbox/serial.h | ||
---|---|---|
3 | 3 |
|
4 | 4 |
#define BAUD_RATE 9600 |
5 | 5 |
|
6 |
#define RX_BUFFER_SIZE 256
|
|
6 |
#define RX_BUFFER_SIZE 64
|
|
7 | 7 |
|
8 | 8 |
void serial_init(); |
9 | 9 |
int serial_read(); |
Also available in: Unified diff