-
Notifications
You must be signed in to change notification settings - Fork 113
/
Manchester.h
194 lines (151 loc) · 7.09 KB
/
Manchester.h
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
/*
https://github.com/mchr3k/arduino-libs-manchester
This code is based on the Atmel Corporation Manchester
Coding Basics Application Note.
http://www.atmel.com/dyn/resources/prod_documents/doc9164.pdf
Quotes from the application note:
"Manchester coding states that there will always be a transition of the message signal
at the mid-point of the data bit frame.
What occurs at the bit edges depends on the state of the previous bit frame and
does not always produce a transition. A logical '1' is defined as a mid-point transition
from low to high and a '0' is a mid-point transition from high to low.
We use Timing Based Manchester Decode.
In this approach we will capture the time between each transition coming from the demodulation
circuit."
Timer 2 is used with a ATMega328. Timer 1 is used for a ATtiny85 and ATtiny84
This code gives a basic data rate as 1200 bauds. In manchester encoding we send 1 0 for a data bit 0.
We send 0 1 for a data bit 1. This ensures an average over time of a fixed DC level in the TX/RX.
This is required by the ASK RF link system to ensure its correct operation.
The data rate is then 600 bits/s. Higher and lower rates are also supported.
*/
#ifndef MANCHESTER_h
#define MANCHESTER_h
//timer scaling factors for different transmission speeds
#define MAN_300 0
#define MAN_600 1
#define MAN_1200 2
#define MAN_2400 3
#define MAN_4800 4
#define MAN_9600 5
#define MAN_19200 6
#define MAN_38400 7
/*
Timer 2 in the ATMega328 and Timer 1 in a ATtiny85 is used to find the time between
each transition coming from the demodulation circuit.
Their setup is for sampling the input in regular intervals.
For practical reasons we use power of 2 timer prescaller for sampling,
for best timing we use pulse lenght as integer multiple of sampling speed.
We chose to sample every 8 ticks, and pulse lenght of 48 ticks
thats 6 samples per pulse, lower sampling rate (3) will not work well for
innacurate clocks (like internal oscilator) higher sampling rate (12) will
cause too much overhead and will not work at higher transmission speeds.
This gives us 16000000Hz/48/256 = 1302 pulses per second (so it's not really 1200)
At different transmission speeds or on different microcontroller frequencies, clock prescaller is adjusted
to be compatible with those values. We allow about 50% clock speed difference both ways
allowing us to transmit even with up to 100% in clock speed difference
*/
// added by caoxp@github
//
// the sync pulse amount for transmitting and receiving.
// a pulse means : HI,LO or LO,HI
// usually SYNC_PULSE_MAX >= SYNC_PULSE_DEF + 2
// SYNC_PULSE_MIN <= SYNC_PULSE_DEF + 2
// consider the pulses rising when starting transmitting.
// SYNC_PULSE_MIN should be much less than SYNC_PULSE_DEF
// all maximum of 255
#define SYNC_PULSE_MIN 1
#define SYNC_PULSE_DEF 3
#define SYNC_PULSE_MAX 5
//#define SYNC_PULSE_MIN 10
//#define SYNC_PULSE_DEF 14
//#define SYNC_PULSE_MAX 16
//define to use 1 or 0 to sync
// when using 1 to sync, sending SYNC_PULSE_DEF 1's , and send a 0 to start data.
// and end the transimitting by three 1's
// when using 0 to sync, sending SYNC_PULSE_DEF 0's , and send a 1 to start data.
// and end the transimitting by three 0's
#define SYNC_BIT_VALUE 0
//decoding not finished.
//#define SYNC_BIT_VALUE 0
/*
Signal timing, we take sample every 8 clock ticks
ticks: [0]-[8]--[16]-[24]-[32]-[40]-[48]-[56]-[64]-[72]-[80]-[88]-[96][104][112][120][128][136]
samples: |----|----|----|----|----|----|----|----|----|----|----|----|----|----|----|----|----|
single: | [--------|----------]
double: | [-----------------|--------------------]
signal: |_____________________________ ______________________
| |_____________________________|
*/
//setup timing for receiver
#define MinCount 33 //pulse lower count limit on capture
#define MaxCount 65 //pulse higher count limit on capture
#define MinLongCount 66 //pulse lower count on double pulse
#define MaxLongCount 129 //pulse higher count on double pulse
//setup timing for transmitter
#define HALF_BIT_INTERVAL 3072 //(=48 * 1024 * 1000000 / 16000000Hz) microseconds for speed factor 0 (300baud)
//it's common to zero terminate a string or to transmit small numbers involving a lot of zeroes
//those zeroes may be mistaken for training pattern, confusing the receiver and resulting high packet lost,
//therefore we xor the data with random decoupling mask
#define DECOUPLING_MASK 0b11001010
#define RX_MODE_PRE 0
#define RX_MODE_SYNC 1
#define RX_MODE_DATA 2
#define RX_MODE_MSG 3
#define RX_MODE_IDLE 4
#define TimeOutDefault -1 //the timeout in msec default blocks
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#include <pins_arduino.h>
#endif
class Manchester
{
public:
Manchester(); //the constructor
void setTxPin(uint8_t pin); //set the arduino digital pin for transmit.
void setRxPin(uint8_t pin); //set the arduino digital pin for receive.
void workAround1MhzTinyCore(uint8_t a = 1); //apply workaround for defect in tiny Core library for 1Mhz
void setupTransmit(uint8_t pin, uint8_t SF = MAN_1200); //set up transmission
void setupReceive(uint8_t pin, uint8_t SF = MAN_1200); //set up receiver
void setup(uint8_t Tpin, uint8_t Rpin, uint8_t SF = MAN_1200); //set up receiver
void transmit(uint8_t data); //transmit 16 bits of data
void transmitArray(uint8_t numBytes, uint8_t *data); // transmit array of bytes
uint8_t decodeMessage(uint16_t m, uint8_t &id, uint8_t &data); //decode 8 bit payload and 4 bit ID from the message, return 1 of checksum is correct, otherwise 0
uint16_t encodeMessage(uint8_t id, uint8_t data); //encode 8 bit payload, 4 bit ID and 4 bit checksum into 16 bit
//wrappers for global functions
void beginReceive(void);
void beginReceiveArray(uint8_t maxBytes, uint8_t *data);
uint8_t receiveComplete(void);
uint8_t getMessage(void);
void stopReceive(void);
uint8_t speedFactor;
uint16_t delay1;
uint16_t delay2;
private:
void sendZero(void);
void sendOne(void);
uint8_t TxPin;
uint8_t applyWorkAround1Mhz;
};//end of class Manchester
// Cant really do this as a real C++ class, since we need to have
// an ISR
extern "C"
{
//set the arduino digital pin for receive. default 4.
extern void MANRX_SetRxPin(uint8_t pin);
//begin the timer used to receive data
extern void MANRX_SetupReceive(uint8_t speedFactor = MAN_1200);
// begin receiving 16 bits
extern void MANRX_BeginReceive(void);
// begin receiving a byte array
extern void MANRX_BeginReceiveBytes(uint8_t maxBytes, uint8_t *data);
// true if a complete message is ready
extern uint8_t MANRX_ReceiveComplete(void);
// fetch the received message
extern uint8_t MANRX_GetMessage(void);
// stop receiving data
extern void MANRX_StopReceive(void);
}
extern Manchester man;
#endif