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
|
/* ISO14443A Manchester encoder for OpenPICC
* (C) 2006 by Harald Welte <hwelte@hmw-consulting.de>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/*
* Definitions for 106kBps, at sampling clock 1695kHz
*
* bit sample pattern for one bit cycle
* MSB first LSB first hex LSB first
* Sequence D 1010101000000000 0000000001010101 0x0055
* Sequence E 0000000010101010 0101010100000000 0x5500
* Sequence F 1010101010101010 0101010101010101 0x5555
*
* Logic 1 Sequence D
* Logic 0 Sequence E
* SOF Sequence D
* EOF Sequence F
*
* 212/424/848kBps: BPSK.
*
* SOF: 32 subcarrier clocks + bit '0'
*
* SOF: hex LSB first: 0x55555555 55555555 + bit '0'
*
* EOF: even parity of last byte (!)
*
*/
#define MANCHESTER_SEQ_D 0x0055
#define MANCHESTER_SEQ_E 0x5500
#define MANCHESTER_SEQ_F 0x5555
#include <errno.h>
#include <string.h>
#include "openpicc.h"
static u_int32_t manchester_sample_size(u_int8_t frame_bytelen) __attribute__((unused));
static u_int32_t manchester_sample_size(u_int8_t frame_bytelen)
{
/* 16 bits (2 bytes) per bit => 16 bytes samples per data byte,
* plus 16bit (2 bytes) parity per data byte
* plus 16bit (2 bytes) SOF plus 16bit (2 bytes) EOF */
return (frame_bytelen*18) + 2 + 2;
/* this results in a maximum samples-per-frame size of 4612 bytes
* for a 256byte frame */
}
struct manch_enc_state {
const char *data;
char *samples;
u_int16_t *samples16;
};
static void manchester_enc_byte(struct manch_enc_state *mencs, u_int8_t data) __attribute__((unused));
static void manchester_enc_byte(struct manch_enc_state *mencs, u_int8_t data)
{
int i;
u_int8_t sum_1 = 0;
/* append 8 sample blobs, one for each bit */
for (i = 0; i < 8; i++) {
if (data & (1 << i)) {
*(mencs->samples16) = MANCHESTER_SEQ_D;
sum_1++;
} else {
*(mencs->samples16) = MANCHESTER_SEQ_E;
}
mencs->samples16++;
}
/* append odd parity */
if (sum_1 & 0x01)
*(mencs->samples16) = MANCHESTER_SEQ_E;
else
*(mencs->samples16) = MANCHESTER_SEQ_D;
mencs->samples16++;
}
#if 0
/* Broken? */
int manchester_encode(char *sample_buf, u_int16_t sample_buf_len,
const char *data, u_int8_t data_len)
{
int i, enc_size;
struct manch_enc_state mencs;
enc_size = manchester_sample_size(data_len);
if (sample_buf_len < enc_size)
return -EINVAL;
/* SOF */
*(mencs.samples16++) = MANCHESTER_SEQ_D;
for (i = 0; i < data_len; i++)
manchester_enc_byte(&mencs, data[i]);
/* EOF */
*(mencs.samples16++) = MANCHESTER_SEQ_F;
return enc_size;
}
#endif
#if 0
/* Broken? */
#define BPSK_SPEED_212
static u_int32_t bpsk_sample_size(u_int8_t frame_bytelen);
int bpsk_encode(char *sample_buf, u_int16_t sample_buf_len,
const char *data, u_int8_t data_len)
{
/* burst of 32 sub carrier cycles */
memset(sample_buf, 0x55, 8);
}
#endif
|
