Initial Arduino IDE based on Processing.

core/wiring.c

@@ -0,0 +1,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;
+}