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
|
#include <xc.h>
#include <stdbool.h>
#include <stdint.h>
#include "system.h"
#include "types.h"
#include "spi.h"
#include "dac.h"
#include "can.h"
#include "eeprom.h"
#include "table.h"
// TODO: auto baud detection
#define CAN_TIMING CAN_TIMING_10K
// Table Control filter.
// Used for writing/reading calibration tables.
static const CanId tblCtrlFilter = {
.type = CAN_ID_EXT,
.eid = {0x00, 0x20, 0x27, 0x01}, // 12720XXh
};
// ID Control filter.
// Used for writing/reading the CAN ID associated with each parameter.
// See `doc/datafmt.ps'.
static const CanId idCtrlFilter = {
.type = CAN_ID_EXT,
.eid = {0x00, 0x21, 0x27, 0x01}, // 127210Xh
};
// Receive buffer 0 mask.
// RXB0 is used for control messages for reading/writing calibration tables
// and CAN IDs for each parameter.
// This mask is the union of the two control message filters.
static const CanId rxb0Mask = {
.type = CAN_ID_EXT,
.eid = {0x00, 0x21, 0x27, 0x01}, // 1272100h
};
// Receive buffer 1 mask.
// RXB1 is used for receiving parameter values.
// The mask is permissive: all messages are accepted and filtered in software.
static const CanId rxb1Mask = {
.type = CAN_ID_EXT,
.eid = {0u, 0u, 0u, 0u}, // accept all messages
};
// Calibration tables in EEPROM:
// Each is 2*sizeof(U32)*TAB_ROWS = 256B -- too big for an 8-bit word.
// That's why the offsets are hard-coded.
static const Table tachTbl = {{0x00, 0x00}}; // tachometer
static const Table speedTbl = {{0x01, 0x00}}; // speedometer
static const Table an1Tbl = {{0x02, 0x00}}; // analog channels...
static const Table an2Tbl = {{0x03, 0x00}};
static const Table an3Tbl = {{0x04, 0x00}};
static const Table an4Tbl = {{0x05, 0x00}};
// EEPROM address of CAN ID for each parameter.
// Each of these addresses holds a U32 CAN ID.
static const EepromAddr tachIdAddr = {0x06, 0x00}; // tachometer
static const EepromAddr speedIdAddr = {0x06, 0x04}; // speedometer
static const EepromAddr an1IdAddr = {0x06, 0x08}; // analog channels...
static const EepromAddr an2IdAddr = {0x06, 0x0C};
static const EepromAddr an3IdAddr = {0x06, 0x10};
static const EepromAddr an4IdAddr = {0x06, 0x14};
static volatile CanId tachId; // tachometer
static volatile CanId speedId; // speedometer
static volatile CanId an1Id; // analog channels...
static volatile CanId an2Id;
static volatile CanId an3Id;
static volatile CanId an4Id;
// Load parameters' CAN IDs from EEPROM
static Status
loadParamIds(void) {
U8 oldGie;
Status status;
// Disable interrupts so the volatile address pointers can be passed safely
oldGie = INTCONbits.GIE;
INTCONbits.GIE = 0;
status = eepromReadCanId(tachIdAddr, (CanId*)&tachId);
if (status != OK) {
return FAIL;
}
status = eepromReadCanId(speedIdAddr, (CanId*)&speedId);
if (status != OK) {
return FAIL;
}
status = eepromReadCanId(an1IdAddr, (CanId*)&an1Id);
if (status != OK) {
return FAIL;
}
status = eepromReadCanId(an2IdAddr, (CanId*)&an2Id);
if (status != OK) {
return FAIL;
}
status = eepromReadCanId(an3IdAddr, (CanId*)&an3Id);
if (status != OK) {
return FAIL;
}
status = eepromReadCanId(an4IdAddr, (CanId*)&an4Id);
if (status != OK) {
return FAIL;
}
// Restore previous interrupt setting
INTCONbits.GIE = oldGie;
return OK;
}
static void
reset(void) {
_delay(100000);
asm("RESET");
}
void
main(void) {
Status status;
sysInit();
spiInit();
dacInit();
canInit();
eepromInit();
// Load parameters' CAN IDs from EEPROM
status = loadParamIds();
if (status != OK) {
reset();
}
// Setup MCP2515 CAN controller
canSetBitTiming(CAN_TIMING);
canSetMask0(&rxb0Mask); // RXB0 receives control messages
canSetFilter0(&tblCtrlFilter); // Table Control Frames
canSetFilter1(&idCtrlFilter); // ID Control Frames
canSetMask1(&rxb1Mask); // RXB1 receives parameter values
// Permissive RXB1 mask; filter frames in software
// Enable interrupts
canIE(true); // enable interrupts on MCP2515's INT pin
INTCON = 0x00; // clear flags
OPTION_REGbits.INTEDG = 0; // interrupt on falling edge of INT pin
INTCONbits.INTE = 1; // enable INT pin
INTCONbits.PEIE = 1; // enable peripheral interrupts
INTCONbits.GIE = 1; // enable global interrupts
for (;;) {
}
}
// Handle a Table Control Frame.
// See `doc/datafmt.ps'
static Status
handleTblCtrlFrame(const CanFrame *frame) {
// TODO
}
// Handle an ID Control Frame.
// See `doc/datafmt.ps'
static Status
handleIdCtrlFrame(const CanFrame *frame) {
// TODO
}
// Handle a frame potentially holding a parameter value.
static Status
handleParamFrame(const CanFrame *frame) {
// TODO
}
void
__interrupt() isr(void) {
U8 rxStatus;
CanFrame frame;
if (INTCONbits.INTF) { // CAN interrupt
rxStatus = canRxStatus();
switch (rxStatus & 0x7) { // check filter hit
case 0u: // RXF0: calibration table control
canReadRxb0(&frame);
(void)handleTblCtrlFrame(&frame);
break;
case 1u: // RXF1: parameter ID control
canReadRxb0(&frame);
(void)handleIdCtrlFrame(&frame);
break;
default: // message in RXB1
canReadRxb1(&frame);
(void)handleParamFrame(&frame);
}
INTCONbits.INTF = 0; // clear flag
}
}
|