forked from reprappro/RepRapFirmware
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Platform.h
402 lines (286 loc) · 11.9 KB
/
Platform.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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
/****************************************************************************************************
RepRapFirmware - Platform: RepRapPro Mendel with Prototype Arduino Due controller
Platform contains all the code and definitons to deal with machine-dependent things such as control
pins, bed area, number of extruders, tolerable accelerations and speeds and so on.
No definitions that are system-independent should go in here. Put them in Configuration.h. Note that
the lengths of arrays such as DRIVES (see below) are defined here, so any array initialiser that depends on those
lengths, for example:
#define DRIVES 4
.
.
.
#define DRIVE_RELATIVE_MODES {false, false, false, true}
also needs to go here.
-----------------------------------------------------------------------------------------------------
Version 0.1
18 November 2012
Adrian Bowyer
RepRap Professional Ltd
http://reprappro.com
Licence: GPL
****************************************************************************************************/
#ifndef PLATFORM_H
#define PLATFORM_H
// Language-specific includes
#include <stdio.h>
#include <ctype.h>
// Platform-specific includes
#include <Arduino.h>
/**************************************************************************************************/
// The physical capabilities of the machine
#define DRIVES 4 // The number of drives in the machine, including X, Y, and Z plus extruder drives
#define AXES 3 // The number of movement axes in the machine, usually just X, Y and Z. <= DRIVES
#define HEATERS 2 // The number of heaters in the machine, including the heated bed if any.
// The numbers of entries in each array must correspond with the values of DRIVES,
// AXES, or HEATERS. Set values to -1 to flag unavailability.
// DRIVES
#define STEP_PINS {54, 60, 46, 26}
#define DIRECTION_PINS {55, 61, 48, 28}
#define FORWARDS 1 // What to send to go...
#define BACKWARDS 0 // ...in each direction
#define ENABLE_PINS {38, -1, 62, -1}
#define ENABLE 0 // What to send to enable...
#define DISABLE 1 // ...and disable a drive
#define DISABLE_DRIVES {false, false, true, false} // Set true to disable a drive when it becomes idle
#define MAX_FEEDRATES {300, 300, 3, 45} // mm/sec
#define MAX_ACCELERATIONS {800, 800, 30, 250} // mm/sec^2?? Maximum start speed for accelerated moves.
#define DRIVE_STEPS_PER_UNIT {91.4286, 91.4286, 4000, 929}
#define JERKS {15.0, 15.0, 0.4, 15.0} // (mm/sec)
#define DRIVE_RELATIVE_MODES {false, false, false, true} // false for default absolute movement, true for relative to last position
// AXES
#define LOW_STOP_PINS {3, 14, 17}
#define HIGH_STOP_PINS {-1, -1, -1}
#define ENDSTOP_HIT 1 // when a stop == this it is hit
#define AXIS_LENGTHS {210, 210, 120} // mm
#define FAST_HOME_FEEDRATES {50*60, 50*60, 1*60} // mm/min
#define X_AXIS 0 // The index of the X axis
#define Y_AXIS 1 // The index of the Y axis
#define Z_AXIS 2 // The index of the Z axis
// HEATERS - Bed is assumed to be the first
#define TEMP_SENSE_PINS {10, 9} // Analogue pin numbers
#define HEAT_ON_PINS {8, 9}
#define THERMISTOR_BETAS {3480.0, 3960.0} // Bed thermistor: RS 484-0149; EPCOS B57550G103J; Extruder thermistor: RS 198-961
#define THERMISTOR_SERIES_RS {4700, 4700} // Ohms in series with the thermistors
#define THERMISTOR_25_RS {10000.0, 100000.0} // Thermistor ohms at 25 C = 298.15 K
#define USE_PID {false, true} // PID or bang-bang for this heater?
#define PID_KIS {-1, 100} // PID constants...
#define PID_KDS {-1, 100}
#define PID_KPS {-1, 100}
#define PID_I_LIMITS {-1, 100} // ... to here
#define TEMP_INTERVAL 0.5 // secs - check and control temperatures this often
#define AD_RANGE 1023.0//16383 // The A->D converter that measures temperatures gives an int this big as its max value
#define HOT_BED 0 // The index of the heated bed; set to -1 if there is no heated bed
/****************************************************************************************************/
// File handling
#define MAX_FILES 7
#define FILE_BUF_LEN 256
#define SD_SPI 4 //Pin
#define WEB_DIR "www/" // Place to find web files on the server
#define GCODE_DIR "gcodes/" // Ditto - g-codes
#define SYS_DIR "sys/" // Ditto - system files
#define TEMP_DIR "tmp/" // Ditto - temporary files
#define FILE_LIST_SEPARATOR ','
#define FILE_LIST_BRACKET '"'
#define FILE_LIST_LENGTH 1000 // Maximum lenght of file list
/****************************************************************************************************/
// Networking
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
#define MAC { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
#define MAC_BYTES 6
#define IP0 192
#define IP1 168
#define IP2 1
#define IP3 14
#define ETH_B_PIN 10
// port 80 is default for HTTP
#define HTTP_PORT 80
// Connection statuses - ORed
#define CLIENT 1
#define CONNECTED 2
#define AVAILABLE 4
/****************************************************************************************************/
// Miscellaneous...
#define LED_PIN 13 // Indicator LED
#define BAUD_RATE 115200 // Communication speed of the USB if needed.
#define GCODE_LENGTH 100 // Maximum lenght of internally-generated G Code string
/****************************************************************************************************/
class RepRap;
class Platform
{
public:
Platform(RepRap* r);
RepRap* GetRepRap();
//-------------------------------------------------------------------------------------------------------------
// These are the functions that form the interface between Platform and the rest of the firmware.
void Init(); // Set the machine up after a restart. If called subsequently this should set the machine up as if
// it has just been restarted; it can do this by executing an actual restart if you like, but beware the
// loop of death...
void Spin(); // This gets called in the main loop and should do any housekeeping needed
void Exit(); // Shut down tidily. Calling Init after calling this should reset to the beginning
// Timing
unsigned long Time(); // Returns elapsed microseconds since some arbitrary time
void SetInterrupt(long t); // Set a regular interrupt going every t microseconds; if t is -ve turn interrupt off
void Interrupt(); // The function that the interrupt calls
// Communications and data storage; opening something unsupported returns -1.
char* FileList(char* directory); // Returns a ;-separated list of all the files in the named directory (for example on an SD card).
int OpenFile(char* fileName, boolean write); // Open a local file (for example on an SD card).
void GoToEnd(int file); // Position the file at the end (so you can write on the end).
boolean Read(int file, unsigned char& b); // Read a single byte from a file into b,
// returned value is false for EoF, true otherwise
void WriteString(int file, char* s); // Write the string to a file.
void Write(int file, char b); // Write the byte b to a file.
char* GetWebDir(); // Where the php/htm etc files are
char* GetGcodeDir(); // Where the gcodes are
char* GetSysDir(); // Where the system files are
char* GetTempDir(); // Where temporary files are
void Close(int file); // Close a file or device, writing any unwritten buffer contents first.
boolean DeleteFile(char* fileName); // Delete a file
char* PrependRoot(char* root, char* fileName);
unsigned char ClientRead(); // Read a byte from the client
void SendToClient(char* message); // Send string to the host
void SendToClient(unsigned char b); // Send byte to the host
int ClientStatus(); // Check client's status
void DisconnectClient(); //Disconnect the client
void Message(char type, char* message); // Send a message. Messages may simply flash an LED, or,
// say, display the messages on an LCD. This may also transmit the messages to the host.
// Movement
void SetDirection(byte drive, bool direction);
void Step(byte drive);
void Disable(byte drive); // There is no drive enable; drives get enabled automatically the first time they are used.
void Home(byte axis);
float ZProbe(); // Return the height above the bed. Returned value is negative if probing isn't implemented
void ZProbe(float h); // Move to height h above the bed using the probe (if there is one). h should be non-negative.
// Heat and temperature
float GetTemperature(byte heater); // Result is in degrees celsius
void SetHeater(byte heater, const float& power); // power is a fraction in [0,1]
//-------------------------------------------------------------------------------------------------------
private:
unsigned long lastTime;
boolean active;
// Load settings from local storage
bool LoadFromStore();
int GetRawTemperature(byte heater);
RepRap* reprap;
// DRIVES
char stepPins[DRIVES];
char directionPins[DRIVES];
char enablePins[DRIVES];
boolean disableDrives[DRIVES];
float maxFeedrates[DRIVES];
float maxAccelerations[DRIVES];
float driveStepsPerUnit[DRIVES];
float jerks[DRIVES];
boolean driveRelativeModes[DRIVES];
// AXES
char lowStopPins[AXES];
char highStopPins[AXES];
float axisLengths[AXES];
float fastHomeFeedrates[AXES];
// HEATERS - Bed is assumed to be the first
char tempSensePins[HEATERS];
char heatOnPins[HEATERS];
float thermistorBetas[HEATERS];
float thermistorSeriesRs[HEATERS];
float thermistorInfRs[HEATERS];
boolean usePid[HEATERS];
float pidKis[HEATERS];
float pidKds[HEATERS];
float pidKps[HEATERS];
float pidILimits[HEATERS];
// Files
File* files;
boolean* inUse;
char* webDir;
char* gcodeDir;
char* sysDir;
char* tempDir;
byte* buf[MAX_FILES];
int bPointer[MAX_FILES];
char fileList[FILE_LIST_LENGTH];
char scratchString[STRING_LENGTH];
// Network connection
void ClientMonitor();
byte mac[MAC_BYTES];
EthernetServer* server;
EthernetClient client;
int clientStatus;
};
inline unsigned long Platform::Time()
{
return micros();
}
//***************************************************************************************
// Network connection
inline int Platform::ClientStatus()
{
return clientStatus;
}
inline void Platform::SendToClient(unsigned char b)
{
if(client)
{
client.write(b);
//Serial.write(b);
} else
Message(HOST_MESSAGE, "Attempt to send byte to disconnected client.");
}
inline unsigned char Platform::ClientRead()
{
if(client)
return client.read();
Message(HOST_MESSAGE, "Attempt to read from disconnected client.");
return '\n'; // good idea??
}
inline void Platform::ClientMonitor()
{
clientStatus = 0;
if(!client)
{
client = server->available();
if(!client)
return;
//else
//Serial.println("new client");
}
clientStatus |= CLIENT;
if(!client.connected())
return;
clientStatus |= CONNECTED;
if (!client.available())
return;
clientStatus |= AVAILABLE;
}
inline void Platform::DisconnectClient()
{
if (client)
{
client.stop();
//Serial.println("client disconnected");
} else
Message(HOST_MESSAGE, "Attempt to disconnect non-existent client.");
}
//*****************************************************************************************************************
// Interrupts
inline void Platform::SetInterrupt(long t)
{
}
inline void Platform::Interrupt()
{
reprap->Interrupt(); // Put nothing else in this function
}
//*****************************************************************************************************************
// Drive the RepRap machine
inline void Platform::SetDirection(byte drive, bool direction)
{
digitalWrite(directionPins[drive], direction);
}
inline void Platform::Step(byte drive)
{
digitalWrite(stepPins[drive], !digitalRead(stepPins[drive]));
}
inline int Platform::GetRawTemperature(byte heater)
{
return analogRead(tempSensePins[heater]);
}
#endif