-
-
Notifications
You must be signed in to change notification settings - Fork 7k
/
wiring.c
executable file
·297 lines (239 loc) · 7.05 KB
/
wiring.c
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
/*
wiring.c - Wiring API Partial Implementation
Part of Arduino / Wiring Lite
Copyright (c) 2005 David A. Mellis
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General
Public License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA
$Id: wiring.c,v 1.7 2005/05/28 21:04:15 mellis Exp $
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/delay.h>
#include <stdio.h>
#include <stdarg.h>
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
// from Pascal's avrlib
#include "global.h"
//#include "a2d.h"
#include "timer.h"
#include "uart.h"
// timer.h #defines delay to be delay_us, we need to undefine
// it so our delay can be in milliseconds.
#undef delay
#include "BConstants.h"
#include "wiring.h"
// Get the hardware port of the given virtual pin number. This comes from
// the pins_*.c file for the active board configuration.
int digitalPinToPort(int pin)
{
return digital_pin_to_port[pin].port;
}
// Get the bit location within the hardware port of the given virtual pin.
// This comes from the pins_*.c file for the active board configuration.
int digitalPinToBit(int pin)
{
return digital_pin_to_port[pin].bit;
}
int analogOutPinToPort(int pin)
{
return analog_out_pin_to_port[pin].port;
}
int analogOutPinToBit(int pin)
{
return analog_out_pin_to_port[pin].bit;
}
int analogInPinToBit(int pin)
{
return analog_in_pin_to_port[pin].bit;
}
void pinMode(int pin, int mode)
{
if (digitalPinToPort(pin) != NOT_A_PIN) {
if (mode == INPUT)
cbi(_SFR_IO8(port_to_mode[digitalPinToPort(pin)]), digitalPinToBit(pin));
else
sbi(_SFR_IO8(port_to_mode[digitalPinToPort(pin)]), digitalPinToBit(pin));
}
}
void digitalWrite(int pin, int val)
{
if (digitalPinToPort(pin) != NOT_A_PIN) {
// If the pin that support PWM output, we need to turn it off
// before doing a digital write.
if (analogOutPinToBit(pin) == 1)
timer1PWMAOff();
if (analogOutPinToBit(pin) == 2)
timer1PWMBOff();
if (val == LOW)
cbi(_SFR_IO8(port_to_output[digitalPinToPort(pin)]), digitalPinToBit(pin));
else
sbi(_SFR_IO8(port_to_output[digitalPinToPort(pin)]), digitalPinToBit(pin));
}
}
int digitalRead(int pin)
{
if (digitalPinToPort(pin) != NOT_A_PIN) {
// If the pin that support PWM output, we need to turn it off
// before getting a digital reading.
if (analogOutPinToBit(pin) == 1)
timer1PWMAOff();
if (analogOutPinToBit(pin) == 2)
timer1PWMBOff();
return (_SFR_IO8(port_to_input[digitalPinToPort(pin)]) >> digitalPinToBit(pin)) & 0x01;
}
return LOW;
}
/*
int analogRead(int pin)
{
unsigned long start_time = millis();
int ch = analogInPinToBit(pin);
volatile unsigned int low, high;
//return a2dConvert10bit(ch);
a2dSetChannel(ch);
a2dStartConvert();
// wait until the conversion is complete or we
// time out. without the timeout, this sometimes
// becomes an infinite loop. page 245 of the atmega8
// datasheet says the conversion should take at most
// 260 microseconds, so if two milliseconds have ticked
// by, something's wrong.
//while (!a2dIsComplete() && millis() - start_time < 50);
while (!a2dIsComplete());
// a2Convert10bit sometimes read ADCL and ADCH in the
// wrong order (?) causing it to sometimes miss reading,
// especially if called multiple times in rapid succession.
//return a2dConvert10bit(ch);
//return ADCW;
low = ADCL;
high = ADCH;
return (high << 8) | low;
}
*/
int analogRead(int pin)
{
unsigned int low, high, ch = analogInPinToBit(pin);
// the low 4 bits of ADMUX select the ADC channel
ADMUX = (ADMUX & (unsigned int) 0xf0) | (ch & (unsigned int) 0x0f);
// without a delay, we seem to read from the wrong channel
delay(1);
// start the conversion
sbi(ADCSRA, ADSC);
// ADSC is cleared when the conversion finishes
while (bit_is_set(ADCSRA, ADSC));
// we have to read ADCL first; doing so locks both ADCL
// and ADCH until ADCH is read. reading ADCL second would
// cause the results of each conversion to be discarded,
// as ADCL and ADCH would be locked when it completed.
low = ADCL;
high = ADCH;
// combine the two bytes
return (high << 8) | low;
}
// Right now, PWM output only works on the pins with
// hardware support. These are defined in the appropriate
// pins_*.c file. For the rest of the pins, we default
// to digital output.
void analogWrite(int pin, int val)
{
// We need to make sure the PWM output is enabled for those pins
// that support it, as we turn it off when digitally reading or
// writing with them. Also, make sure the pin is in output mode
// for consistenty with Wiring, which doesn't require a pinMode
// call for the analog output pins.
if (analogOutPinToBit(pin) == 1) {
pinMode(pin, OUTPUT);
timer1PWMAOn();
timer1PWMASet(val);
} else if (analogOutPinToBit(pin) == 2) {
pinMode(pin, OUTPUT);
timer1PWMBOn();
timer1PWMBSet(val);
} else if (val < 128)
digitalWrite(pin, LOW);
else
digitalWrite(pin, HIGH);
}
void beginSerial(int baud)
{
uartInit();
uartSetBaudRate(baud);
}
void serialWrite(unsigned char c)
{
uartSendByte(c);
}
void printMode(int mode)
{
// do nothing, we only support serial printing, not lcd.
}
void uartSendString(unsigned char *str)
{
while (*str)
uartSendByte(*str++);
}
void print(const char *format, ...)
{
char buf[256];
va_list ap;
va_start(ap, format);
vsnprintf(buf, 256, format, ap);
va_end(ap);
uartSendString(buf);
}
unsigned long millis()
{
// timer 0 increments every timer0GetPrescaler() cycles, and
// overflows when it reaches 256. we calculate the total
// number of clock cycles, then divide by the number of clock
// cycles per millisecond.
return timer0GetOverflowCount() * timer0GetPrescaler() * 256L / F_CPU * 1000L;
}
void delay(unsigned long ms)
{
timerPause(ms);
}
int main(void)
{
sei();
// timer 0 is used for millis() and delay()
timer0Init();
// timer 1 is used for the hardware pwm
timer1Init();
timer1SetPrescaler(TIMER_CLK_DIV1);
timer1PWMInit(8);
//a2dInit();
//a2dSetPrescaler(ADC_PRESCALE_DIV128);
// set a2d reference to AVCC (5 volts)
cbi(ADMUX, REFS1);
sbi(ADMUX, REFS0);
// set a2d prescale factor to 128
// 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
// XXX: this will not work properly for other clock speeds, and
// this code should use F_CPU to determine the prescale factor.
sbi(ADCSRA, ADPS2);
sbi(ADCSRA, ADPS1);
sbi(ADCSRA, ADPS0);
// enable a2d conversions
sbi(ADCSRA, ADEN);
setup();
for (;;)
loop();
return 0;
}