RoboBuggy

// declare pins

int enc = 1;

// declare globals

int count = 0;

int state = 1; // 1 if was high, 0 if was low

//code that keeps loop time constant each loop

int STD_LOOP_TIME = 9;

int hz = 40;

int print_period = 1000 / hz;

unsigned long last_time = 0;

void setup(){

  Serial.begin(9600);

  pinMode(enc, INPUT);

}

/* returns 1 if there is a magnet

 * returns 0 otherwise

 */

int isMagnet(){

  int val = analogRead(enc);

  if (val < 512){

   return 0; 

  } else {

    return 1;

  }

}

void loop(){

  // START Loop timing control  ********************************

  if (last_time < (millis() - print_period)) {

    Serial.println(count);

    last_time = millis();

  }

  // END loop timing control    ********************************

  if (state != isMagnet()){

    count++; 

    state = !state;

  }

}

int enc = 10;

void setup(){

  Serial.begin(115200);

  pinMode(enc, OUTPUT); 

}

void loop(){

 for(int i = 0; i < 100000; i++){

 } 

}

int enc = 10;

void setup(){

  Serial.begin(9600);

  pinMode(enc, OUTPUT);

}

#include "RCArduinoFastLib.h"

// include the pinchangeint library - see the links in the related topics section above for details

#include "PinChangeInt.h"  

// Assign your channel in pins

#define THROTTLE_IN_PIN 5

#define STEERING_IN_PIN 6

#define AUX_IN_PIN 7

// Assign your channel out pins

#define THROTTLE_OUT_PIN 9//8 

#define STEERING_OUT_PIN 8//9

#define AUX_OUT_PIN 10

// Assign servo indexes

#define SERVO_THROTTLE 0

#define SERVO_STEERING 1

#define SERVO_AUX 2

#define SERVO_FRAME_SPACE 3

// These bit flags are set in bUpdateFlagsShared to indicate which

// channels have new signals

#define THROTTLE_FLAG 1

#define STEERING_FLAG 2

#define AUX_FLAG 4

// holds the update flags defined above

volatile uint8_t bUpdateFlagsShared;

// shared variables are updated by the ISR and read by loop.

// In loop we immediatley take local copies so that the ISR can keep ownership of the

// shared ones. To access these in loop

// we first turn interrupts off with noInterrupts

// we take a copy to use in loop and the turn interrupts back on

// as quickly as possible, this ensures that we are always able to receive new signals

volatile uint16_t unThrottleInShared;

volatile uint16_t unSteeringInShared;

volatile uint16_t unAuxInShared;

// These are used to record the rising edge of a pulse in the calcInput functions

// They do not need to be volatile as they are only used in the ISR. If we wanted

// to refer to these in loop and the ISR then they would need to be declared volatile

uint16_t unThrottleInStart;

uint16_t unSteeringInStart;

uint16_t unAuxInStart;

uint16_t unLastAuxIn = 0;

uint32_t ulVariance = 0;

uint32_t ulGetNextSampleMillis = 0;

uint16_t unMaxDifference = 0;

void setup()

{

  Serial.begin(115200);

  Serial.println("multiChannels");

  // attach servo objects, these will generate the correct

  // pulses for driving Electronic speed controllers, servos or other devices

  // designed to interface directly with RC Receivers

  CRCArduinoFastServos::attach(SERVO_THROTTLE,THROTTLE_OUT_PIN);

  CRCArduinoFastServos::attach(SERVO_STEERING,STEERING_OUT_PIN);

  CRCArduinoFastServos::attach(SERVO_AUX,AUX_OUT_PIN);

  // lets set a standard rate of 50 Hz by setting a frame space of 10 * 2000 = 3 Servos + 7 times 2000

  CRCArduinoFastServos::setFrameSpaceA(SERVO_FRAME_SPACE,7*2000);

  CRCArduinoFastServos::begin();

  // using the PinChangeInt library, attach the interrupts

  // used to read the channels

  PCintPort::attachInterrupt(THROTTLE_IN_PIN, calcThrottle,CHANGE);

  PCintPort::attachInterrupt(STEERING_IN_PIN, calcSteering,CHANGE);

  PCintPort::attachInterrupt(AUX_IN_PIN, calcAux,CHANGE);

}

void loop()

{

  // create local variables to hold a local copies of the channel inputs

  // these are declared static so that thier values will be retained

  // between calls to loop.

  static uint16_t unThrottleIn;

  static uint16_t unSteeringIn;

  static uint16_t unAuxIn;

  // local copy of update flags

  static uint8_t bUpdateFlags;

  // check shared update flags to see if any channels have a new signal

  if(bUpdateFlagsShared)

  {

    noInterrupts(); // turn interrupts off quickly while we take local copies of the shared variables

    // take a local copy of which channels were updated in case we need to use this in the rest of loop

    bUpdateFlags = bUpdateFlagsShared;

    // in the current code, the shared values are always populated

    // so we could copy them without testing the flags

    // however in the future this could change, so lets

    // only copy when the flags tell us we can.

    if(bUpdateFlags & THROTTLE_FLAG)

    {

      unThrottleIn = unThrottleInShared;

    }

    if(bUpdateFlags & STEERING_FLAG)

    {

      unSteeringIn = unSteeringInShared;

    }

    if(bUpdateFlags & AUX_FLAG)

    {

      unAuxIn = unAuxInShared;

    }

    // clear shared copy of updated flags as we have already taken the updates

    // we still have a local copy if we need to use it in bUpdateFlags

    bUpdateFlagsShared = 0;

    interrupts(); // we have local copies of the inputs, so now we can turn interrupts back on

    // as soon as interrupts are back on, we can no longer use the shared copies, the interrupt

    // service routines own these and could update them at any time. During the update, the

    // shared copies may contain junk. Luckily we have our local copies to work with :-)

  }

  // do any processing from here onwards

  // only use the local values unAuxIn, unThrottleIn and unSteeringIn, the shared

  // variables unAuxInShared, unThrottleInShared, unSteeringInShared are always owned by

  // the interrupt routines and should not be used in loop

  // the following code provides simple pass through

  // this is a good initial test, the Arduino will pass through

  // receiver input as if the Arduino is not there.

  // This should be used to confirm the circuit and power

  // before attempting any custom processing in a project.

  // we are checking to see if the channel value has changed, this is indicated

  // by the flags. For the simple pass through we don't really need this check,

  // but for a more complex project where a new signal requires significant processing

  // this allows us to only calculate new values when we have new inputs, rather than

  // on every cycle.

  if(bUpdateFlags & THROTTLE_FLAG)

  {

    CRCArduinoFastServos::writeMicroseconds(SERVO_THROTTLE,unThrottleIn);

  }

  if(bUpdateFlags & STEERING_FLAG)

  {

    CRCArduinoFastServos::writeMicroseconds(SERVO_STEERING,unSteeringIn);

  }

  if(bUpdateFlags & AUX_FLAG)

  {

   CRCArduinoFastServos::writeMicroseconds(SERVO_AUX,unAuxIn);

  }

  delay(500);

  bUpdateFlags = 0;

}

// simple interrupt service routine

void calcThrottle()

{

  if(PCintPort::pinState)

  {

    unThrottleInStart = TCNT1;

  }

  else

  {

    unThrottleInShared = (TCNT1 - unThrottleInStart)>>1;

    bUpdateFlagsShared |= THROTTLE_FLAG;

  }

}

void calcSteering()

{

  if(PCintPort::pinState)

  {

    unSteeringInStart = TCNT1;

  }

  else

  {

    unSteeringInShared = (TCNT1 - unSteeringInStart)>>1;

    bUpdateFlagsShared |= STEERING_FLAG;

  }

}

void calcAux()

{

  if(PCintPort::pinState)

  {

    unAuxInStart = TCNT1;

  }

  else

  {

    unAuxInShared = (TCNT1 - unAuxInStart)>>1;

    bUpdateFlagsShared |= AUX_FLAG;  }

}

// We use 4-character tabstops, so IN VIM:  <esc>:set ts=4   and  <esc>:set sw=4

// ...that's: ESCAPE key, colon key, then "s-e-t SPACE key t-s-=-4"

//

/*

 * 	This is the PinChangeInt library for the Arduino.

	See google code project for latest, bugs and info http://code.google.com/p/arduino-pinchangeint/

	For more information Refer to avr-gcc header files, arduino source and atmega datasheet.

	This library was inspired by and derived from "johnboiles" (it seems) 

	PCInt Arduino Playground example here: http://www.arduino.cc/playground/Main/PcInt

	If you are the original author, please let us know at the google code page

	It provides an extension to the interrupt support for arduino by

	adding pin change interrupts, giving a way for users to have

	interrupts drive off of any pin.

	This program is free software: you can redistribute it and/or modify

	it under the terms of the GNU General Public License as published by

	the Free Software Foundation, either version 3 of the License, or

	(at your option) any later version.

	This program 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 General Public License for more details.

	You should have received a copy of the GNU General Public License

	along with this program.  If not, see <http://www.gnu.org/licenses/>.

	(the file gpl.txt is included with the library's zip package)

*/

//-------- define these in your sketch, if applicable ----------------------------------------------------------

//-------- These must go in your sketch ahead of the #include <PinChangeInt.h> statement -----------------------

// You can reduce the memory footprint of this handler by declaring that there will be no pin change interrupts

// on any one or two of the three ports.  If only a single port remains, the handler will be declared inline

// reducing the size and latency of the handler.

// #define NO_PORTB_PINCHANGES // to indicate that port b will not be used for pin change interrupts

// #define NO_PORTC_PINCHANGES // to indicate that port c will not be used for pin change interrupts

// #define NO_PORTD_PINCHANGES // to indicate that port d will not be used for pin change interrupts

// --- Mega support ---

// #define NO_PORTB_PINCHANGES // to indicate that port b will not be used for pin change interrupts

// #define NO_PORTJ_PINCHANGES // to indicate that port c will not be used for pin change interrupts

// #define NO_PORTK_PINCHANGES // to indicate that port d will not be used for pin change interrupts

// In the Mega, there is no Port C, no Port D.  Instead, you get Port J and Port K.  Port B remains.

// Port J, however, is practically useless because there is only 1 pin available for interrupts.  Most

// of the Port J pins are not even connected to a header connection.  // </end> "Mega Support" notes

// --- Sanguino, Mioduino support ---

// #define NO_PORTA_PINCHANGES // to indicate that port a will not be used for pin change interrupts

// --------------------

//

// Other preprocessor directives...

// You can reduce the code size by 20-50 bytes, and you can speed up the interrupt routine

// slightly by declaring that you don't care if the static variables PCintPort::pinState and/or

// PCintPort::arduinoPin are set and made available to your interrupt routine.

// #define NO_PIN_STATE        // to indicate that you don't need the pinState

// #define NO_PIN_NUMBER       // to indicate that you don't need the arduinoPin

// #define DISABLE_PCINT_MULTI_SERVICE // to limit the handler to servicing a single interrupt per invocation.

// #define GET_PCINT_VERSION   // to enable the uint16_t getPCIintVersion () function.

// The following is intended for testing purposes.  If defined, then a whole host of static variables can be read

// in your interrupt subroutine.  It is not defined by default, and you DO NOT want to define this in

// Production code!:

// #define PINMODE

//-------- define the above in your sketch, if applicable ------------------------------------------------------

/*

	PinChangeInt.h

	---- VERSIONS --- (NOTE TO SELF: Update the PCINT_VERSION define, below) -----------------

Version 2.19 (beta) Tue Nov 20 07:33:37 CST 2012

Version 2.17 (beta) Sat Nov 17 09:46:50 CST 2012

Version 2.11 (beta) Mon Nov 12 09:33:06 CST 2012

	Version 2.01 (beta) Thu Jun 28 12:35:48 CDT 2012

	Version 1.72 Wed Mar 14 18:57:55 CDT 2012

	Version 1.71beta Sat Mar 10 12:57:05 CST 2012

	Version 1.6beta Fri Feb 10 08:48:35 CST 2012

	Version 1.51 Sun Feb  5 23:28:02 CST 2012

	Version 1.5 Thu Feb  2 18:09:49 CST 2012

	Version 1.4 Tue Jan 10 09:41:14 CST 2012

	Version 1.3 Sat Dec  3 22:56:20 CST 2011

	Version 1.2 Sat Dec  3 Sat Dec  3 09:15:52 CST 2011

	Version 1.1 Sat Dec  3 00:06:03 CST 2011

	*/

#ifndef PinChangeInt_h

#define	PinChangeInt_h

#define PCINT_VERSION 2190 // This number MUST agree with the version number, above.

#include "stddef.h"

// Thanks to Maurice Beelen, nms277, Akesson Karlpetter, and Orly Andico for these fixes.

#if defined(ARDUINO) && ARDUINO >= 100

  #include <Arduino.h>

  #include <new.h>

  #include <wiring_private.h> // cby and sbi defined here

#else

  #include <WProgram.h>

  #include <pins_arduino.h>

  #ifndef   LIBCALL_PINCHANGEINT

    #include "../cppfix/cppfix.h"

  #endif

#endif

#undef DEBUG

/*

* Theory: all IO pins on Atmega168 are covered by Pin Change Interrupts.

* The PCINT corresponding to the pin must be enabled and masked, and

* an ISR routine provided.  Since PCINTs are per port, not per pin, the ISR

* must use some logic to actually implement a per-pin interrupt service.

*/

/* Pin to interrupt map:

* D0-D7 = PCINT 16-23 = PCIR2 = PD = PCIE2 = pcmsk2

* D8-D13 = PCINT 0-5 = PCIR0 = PB = PCIE0 = pcmsk0

* A0-A5 (D14-D19) = PCINT 8-13 = PCIR1 = PC = PCIE1 = pcmsk1

*/

#undef	INLINE_PCINT

#define INLINE_PCINT

// Thanks to cserveny...@gmail.com for MEGA support!

#if defined __AVR_ATmega2560__ || defined __AVR_ATmega1280__ || defined __AVR_ATmega1281__ || defined __AVR_ATmega2561__ || defined __AVR_ATmega640__

	#define __USE_PORT_JK

	// Mega does not have PORTA, C or D

	#define NO_PORTA_PINCHANGES

	#define NO_PORTC_PINCHANGES

	#define NO_PORTD_PINCHANGES

	#if ((defined(NO_PORTB_PINCHANGES) && defined(NO_PORTJ_PINCHANGES)) || \

			(defined(NO_PORTJ_PINCHANGES) && defined(NO_PORTK_PINCHANGES)) || \

			(defined(NO_PORTK_PINCHANGES) && defined(NO_PORTB_PINCHANGES)))

		#define	INLINE_PCINT inline

	#endif

#else

	#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)

		#ifndef NO_PORTA_PINCHANGES

			#define __USE_PORT_A

		#endif

	#else

		#define NO_PORTA_PINCHANGES

	#endif

	// if defined only D .OR. only C .OR. only B .OR. only A, then inline it

	#if (   (defined(NO_PORTA_PINCHANGES) && defined(NO_PORTB_PINCHANGES) && defined(NO_PORTC_PINCHANGES)) || \

			(defined(NO_PORTA_PINCHANGES) && defined(NO_PORTB_PINCHANGES) && defined(NO_PORTD_PINCHANGES)) || \

			(defined(NO_PORTA_PINCHANGES) && defined(NO_PORTC_PINCHANGES) && defined(NO_PORTD_PINCHANGES)) || \

			(defined(NO_PORTB_PINCHANGES) && defined(NO_PORTC_PINCHANGES) && defined(NO_PORTD_PINCHANGES)) )

		#define	INLINE_PCINT inline

	#endif

#endif

// Provide drop in compatibility with johnboiles PCInt project at

// http://www.arduino.cc/playground/Main/PcInt

#define	PCdetachInterrupt(pin)	PCintPort::detachInterrupt(pin)

#define	PCattachInterrupt(pin,userFunc,mode) PCintPort::attachInterrupt(pin, userFunc,mode)

#define PCgetArduinoPin() PCintPort::getArduinoPin()

typedef void (*PCIntvoidFuncPtr)(void);

class PCintPort {

public:

	PCintPort(int index,int pcindex, volatile uint8_t& maskReg) :

	portInputReg(*portInputRegister(index)),

	portPCMask(maskReg),

	PCICRbit(1 << pcindex),

	portRisingPins(0),

	portFallingPins(0),

	firstPin(NULL)

#ifdef PINMODE

	,intrCount(0)

#endif

	{

		#ifdef FLASH

		ledsetup();

		#endif

	}

	volatile	uint8_t&		portInputReg;

	static		int8_t attachInterrupt(uint8_t pin, PCIntvoidFuncPtr userFunc, int mode);

	static		void detachInterrupt(uint8_t pin);

	INLINE_PCINT void PCint();

	static volatile uint8_t curr;

	#ifndef NO_PIN_NUMBER

	static	volatile uint8_t	arduinoPin;

	#endif

	#ifndef NO_PIN_STATE

	static volatile	uint8_t	pinState;

	#endif

	#ifdef PINMODE

	static volatile uint8_t pinmode;

	static volatile uint8_t s_portRisingPins;

	static volatile uint8_t s_portFallingPins;

	static volatile uint8_t s_lastPinView;

	static volatile uint8_t s_pmask;

	static volatile char s_PORT;

	static volatile uint8_t s_changedPins;

	static volatile uint8_t s_portRisingPins_nCurr;

	static volatile uint8_t s_portFallingPins_nNCurr;

	static volatile uint8_t s_currXORlastPinView;

	volatile uint8_t intrCount;

	static volatile uint8_t s_count;

	static volatile uint8_t pcint_multi;

	static volatile uint8_t PCIFRbug;

	#endif

	#ifdef FLASH

	static void ledsetup(void);

	#endif

protected:

	class PCintPin {

	public:

		PCintPin() :

		PCintFunc((PCIntvoidFuncPtr)NULL),

		mode(0) {}

		PCIntvoidFuncPtr PCintFunc;

		uint8_t 	mode;

		uint8_t		mask;

		uint8_t arduinoPin;

		PCintPin* next;

	};

	void 		enable(PCintPin* pin, PCIntvoidFuncPtr userFunc, uint8_t mode);

	int8_t		addPin(uint8_t arduinoPin,PCIntvoidFuncPtr userFunc, uint8_t mode);

	volatile	uint8_t&		portPCMask;

	const		uint8_t			PCICRbit;

	volatile	uint8_t			portRisingPins;

	volatile	uint8_t			portFallingPins;

	volatile uint8_t		lastPinView;

	PCintPin*	firstPin;

};

#ifndef LIBCALL_PINCHANGEINT // LIBCALL_PINCHANGEINT ***********************************************

volatile uint8_t PCintPort::curr=0;

#ifndef NO_PIN_NUMBER

volatile uint8_t PCintPort::arduinoPin=0;

#endif

#ifndef NO_PIN_STATE

volatile uint8_t PCintPort::pinState=0;

#endif

#ifdef PINMODE

volatile uint8_t PCintPort::pinmode=0;

volatile uint8_t PCintPort::s_portRisingPins=0;

volatile uint8_t PCintPort::s_portFallingPins=0;

volatile uint8_t PCintPort::s_lastPinView=0;

volatile uint8_t PCintPort::s_pmask=0;

volatile char	 PCintPort::s_PORT='x';

volatile uint8_t PCintPort::s_changedPins=0;

volatile uint8_t PCintPort::s_portRisingPins_nCurr=0;

volatile uint8_t PCintPort::s_portFallingPins_nNCurr=0;

volatile uint8_t PCintPort::s_currXORlastPinView=0;

volatile uint8_t PCintPort::s_count=0;

volatile uint8_t PCintPort::pcint_multi=0;

volatile uint8_t PCintPort::PCIFRbug=0;

#endif

#ifdef FLASH

#define PINLED 13

volatile uint8_t *led_port;

uint8_t led_mask;

uint8_t not_led_mask;

boolean ledsetup_run=false;

void PCintPort::ledsetup(void) {

	if (! ledsetup_run) {

		led_port=portOutputRegister(digitalPinToPort(PINLED));

		led_mask=digitalPinToBitMask(PINLED);

		not_led_mask=led_mask^0xFF;

		pinMode(PINLED, OUTPUT); digitalWrite(PINLED, LOW);

		ledsetup_run=true;

	}

};

#endif

// ATMEGA 644 

//

#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__) // Sanguino, Mosquino uino bobino bonanafannafofino, me my momino...

#ifndef NO_PORTA_PINCHANGES

PCintPort portA=PCintPort(1, 0,PCMSK0); // port PB==2  (from Arduino.h, Arduino version 1.0)

#endif

#ifndef NO_PORTB_PINCHANGES

PCintPort portB=PCintPort(2, 1,PCMSK1); // port PB==2  (from Arduino.h, Arduino version 1.0)

#endif

#ifndef NO_PORTC_PINCHANGES

PCintPort portC=PCintPort(3, 2,PCMSK2); // port PC==3  (also in pins_arduino.c, Arduino version 022)

#endif

#ifndef NO_PORTD_PINCHANGES

PCintPort portD=PCintPort(4, 3,PCMSK3); // port PD==4

#endif

#else // others

#ifndef NO_PORTB_PINCHANGES

PCintPort portB=PCintPort(2, 0,PCMSK0); // port PB==2  (from Arduino.h, Arduino version 1.0)

#endif

#ifndef NO_PORTC_PINCHANGES  // note: no PORTC on MEGA

PCintPort portC=PCintPort(3, 1,PCMSK1); // port PC==3  (also in pins_arduino.c, Arduino version 022)

#endif

#ifndef NO_PORTD_PINCHANGES  // note: no PORTD on MEGA

PCintPort portD=PCintPort(4, 2,PCMSK2); // port PD==4

#endif

#endif // defined __AVR_ATmega644__

#ifdef __USE_PORT_JK

#ifndef NO_PORTJ_PINCHANGES

PCintPort portJ=PCintPort(10,1,PCMSK1); // port PJ==10 

#endif

#ifndef NO_PORTK_PINCHANGES

PCintPort portK=PCintPort(11,2,PCMSK2); // port PK==11

#endif

#endif // USE_PORT_JK

static PCintPort *lookupPortNumToPort( int portNum ) {

    PCintPort *port = NULL;

        switch (portNum) {

#ifndef NO_PORTA_PINCHANGES

        case 1:

                port=&portA;

                break;

#endif

#ifndef NO_PORTB_PINCHANGES

        case 2:

                port=&portB;

                break;

#endif

#ifndef NO_PORTC_PINCHANGES

        case 3:

                port=&portC;

                break;

#endif

#ifndef NO_PORTD_PINCHANGES

        case 4:

                port=&portD;

                break;

#endif

#ifdef __USE_PORT_JK

#ifndef NO_PORTJ_PINCHANGES

        case 10:

                port=&portJ;

                break;

#endif

#ifndef NO_PORTK_PINCHANGES

        case 11:

                port=&portK;

                break;

#endif

#endif

    }

    return port;

}

void PCintPort::enable(PCintPin* p, PCIntvoidFuncPtr userFunc, uint8_t mode) {

	// Enable the pin for interrupts by adding to the PCMSKx register.

	// ...The final steps; at this point the interrupt is enabled on this pin.

	p->mode=mode;

	p->PCintFunc=userFunc;

	portPCMask |= p->mask;

	if ((p->mode == RISING) || (p->mode == CHANGE)) portRisingPins |= p->mask;

	if ((p->mode == FALLING) || (p->mode == CHANGE)) portFallingPins |= p->mask;

	PCICR |= PCICRbit;

}

int8_t PCintPort::addPin(uint8_t arduinoPin, PCIntvoidFuncPtr userFunc, uint8_t mode)

{

	PCintPin* tmp;

	// Add to linked list, starting with firstPin. If pin already exists, just enable.

	if (firstPin != NULL) {

		tmp=firstPin;

		do {

			if (tmp->arduinoPin == arduinoPin) { enable(tmp, userFunc, mode); return(0); }

			if (tmp->next == NULL) break;

			tmp=tmp->next;

		} while (true);

	}

	// Create pin p:  fill in the data.

	PCintPin* p=new PCintPin;

	if (p == NULL) return(-1);

	p->arduinoPin=arduinoPin;

	p->mode = mode;

	p->next=NULL;

	p->mask = digitalPinToBitMask(arduinoPin); // the mask

	if (firstPin == NULL) firstPin=p;

	else tmp->next=p;

#ifdef DEBUG

	Serial.print("addPin. pin given: "); Serial.print(arduinoPin, DEC);

	int addr = (int) p;

	Serial.print(" instance addr: "); Serial.println(addr, HEX);

	Serial.print("userFunc addr: "); Serial.println((int)p->PCintFunc, HEX);

#endif

	enable(p, userFunc, mode);

#ifdef DEBUG

	Serial.print("addPin. pin given: "); Serial.print(arduinoPin, DEC), Serial.print (" pin stored: ");

	int addr = (int) p;

	Serial.print(" instance addr: "); Serial.println(addr, HEX);

#endif

	return(1);

}

/*

 * attach an interrupt to a specific pin using pin change interrupts.

 */

int8_t PCintPort::attachInterrupt(uint8_t arduinoPin, PCIntvoidFuncPtr userFunc, int mode)

{

	PCintPort *port;

	uint8_t portNum = digitalPinToPort(arduinoPin);

	if ((portNum == NOT_A_PORT) || (userFunc == NULL)) return(-1);

	port=lookupPortNumToPort(portNum);

	// Added by GreyGnome... must set the initial value of lastPinView for it to be correct on the 1st interrupt.

	// ...but even then, how do you define "correct"?  Ultimately, the user must specify (not provisioned for yet).

	port->lastPinView=port->portInputReg;

#ifdef DEBUG

	Serial.print("attachInterrupt FUNC: "); Serial.println(arduinoPin, DEC);

#endif

	// map pin to PCIR register

	return(port->addPin(arduinoPin,userFunc,mode));

}

void PCintPort::detachInterrupt(uint8_t arduinoPin)

{

	PCintPort *port;

	PCintPin* current;

	uint8_t mask;

#ifdef DEBUG

	Serial.print("detachInterrupt: "); Serial.println(arduinoPin, DEC);

#endif

	uint8_t portNum = digitalPinToPort(arduinoPin);

	if (portNum == NOT_A_PORT) return;

	port=lookupPortNumToPort(portNum);

	mask=digitalPinToBitMask(arduinoPin);

	current=port->firstPin;

	//PCintPin* prev=NULL;

	while (current) {

		if (current->mask == mask) { // found the target

			uint8_t oldSREG = SREG;

			cli(); // disable interrupts

			port->portPCMask &= ~mask; // disable the mask entry.

			if (port->portPCMask == 0) PCICR &= ~(port->PCICRbit);

			port->portRisingPins &= ~current->mask; port->portFallingPins &= ~current->mask;

			// Link the previous' next to the found next. Then remove the found.

			//if (prev != NULL) prev->next=current->next; // linked list skips over current.

			//else firstPin=current->next; // at the first pin; save the new first pin

			SREG = oldSREG; // Restore register; reenables interrupts

			return;

		}

		//prev=current;

		current=current->next;

	}

}

// common code for isr handler. "port" is the PCINT number.

// there isn't really a good way to back-map ports and masks to pins.

void PCintPort::PCint() {

	uint8_t thisChangedPin; //MIKE

	#ifdef FLASH

	if (*led_port & led_mask) *led_port&=not_led_mask;

	else *led_port|=led_mask;

    #endif

	#ifndef DISABLE_PCINT_MULTI_SERVICE

	uint8_t pcifr;

	while (true) {

	#endif

		// get the pin states for the indicated port.

		#ifdef PINMODE

		PCintPort::s_lastPinView=lastPinView;

		intrCount++;

		PCintPort::s_count=intrCount;

		#endif

		// OLD v. 2.01 technique: Test 1: 3163; Test 7: 3993

		// From robtillaart online: ------------ (starting v. 2.11beta)

		// uint8_t changedPins = PCintPort::curr ^ lastPinView;

		// lastPinView = PCintPort::curr;

		// uint8_t fastMask = changedPins & ((portRisingPins & PCintPort::curr ) | ( portFallingPins & ~PCintPort::curr ));

		// NEW v. 2.11 technique: Test 1: 3270 Test 7: 3987

		// -------------------------------------

		// was: uint8_t changedPins = PCintPort::curr ^ lastPinView;

		// makes test 6 of the PinChangeIntSpeedTest go from 3867 to 3923.  Not good.

		uint8_t changedPins = (PCintPort::curr ^ lastPinView) &

							  ((portRisingPins & PCintPort::curr ) | ( portFallingPins & ~PCintPort::curr ));

		#ifdef PINMODE

		PCintPort::s_currXORlastPinView=PCintPort::curr ^ lastPinView;

		PCintPort::s_portRisingPins_nCurr=portRisingPins & PCintPort::curr;

		PCintPort::s_portFallingPins_nNCurr=portFallingPins & ~PCintPort::curr;

		#endif

		lastPinView = PCintPort::curr;

		PCintPin* p = firstPin;

		while (p) {

			// Trigger interrupt if the bit is high and it's set to trigger on mode RISING or CHANGE

			// Trigger interrupt if the bit is low and it's set to trigger on mode FALLING or CHANGE

			thisChangedPin=p->mask & changedPins; // PinChangeIntSpeedTest makes this 3673... weird.  But GOOD!!!

			if (p->mask & changedPins) {

				#ifndef NO_PIN_STATE

				PCintPort::pinState=PCintPort::curr & p->mask ? HIGH : LOW;

				#endif

				#ifndef NO_PIN_NUMBER

				PCintPort::arduinoPin=p->arduinoPin;

				#endif

				#ifdef PINMODE

				PCintPort::pinmode=p->mode;

				PCintPort::s_portRisingPins=portRisingPins;

				PCintPort::s_portFallingPins=portFallingPins;

				PCintPort::s_pmask=p->mask;

				PCintPort::s_changedPins=changedPins;

				#endif

				p->PCintFunc();

			}

			p=p->next;

		}

	#ifndef DISABLE_PCINT_MULTI_SERVICE

		pcifr = PCIFR & PCICRbit;

		if (pcifr == 0) break;

		PCIFR |= PCICRbit;

		#ifdef PINMODE

		PCintPort::pcint_multi++;

		if (PCIFR & PCICRbit) PCintPort::PCIFRbug=1; // PCIFR & PCICRbit should ALWAYS be 0 here!

		#endif

		PCintPort::curr=portInputReg;

	}

	#endif

}

#ifndef NO_PORTA_PINCHANGES

ISR(PCINT0_vect) {

	#ifdef PINMODE

	PCintPort::s_PORT='A';

	#endif

	PCintPort::curr = portA.portInputReg;

	portA.PCint();

}

#define PORTBVECT PCINT1_vect

#define PORTCVECT PCINT2_vect

#define PORTDVECT PCINT3_vect

#else

#define PORTBVECT PCINT0_vect

#define PORTCVECT PCINT1_vect

#define PORTDVECT PCINT2_vect

#endif

#ifndef NO_PORTB_PINCHANGES

ISR(PORTBVECT) {

	#ifdef PINMODE

	PCintPort::s_PORT='B';

	#endif

	PCintPort::curr = portB.portInputReg;

	portB.PCint();

}

#endif

#ifndef NO_PORTC_PINCHANGES

ISR(PORTCVECT) {

	#ifdef PINMODE

	PCintPort::s_PORT='C';

	#endif

	PCintPort::curr = portC.portInputReg;

	portC.PCint();

}

#endif

#ifndef NO_PORTD_PINCHANGES

ISR(PORTDVECT){ 

	#ifdef PINMODE

	PCintPort::s_PORT='D';

	#endif

	PCintPort::curr = portD.portInputReg;

	portD.PCint();

}

#endif

#ifdef __USE_PORT_JK

#ifndef NO_PORTJ_PINCHANGES

ISR(PCINT1_vect) {

	#ifdef PINMODE

	PCintPort::s_PORT='J';

	#endif

	PCintPort::curr = portJ.portInputReg;

	portJ.PCint();

}

#endif

#ifndef NO_PORTK_PINCHANGES

ISR(PCINT2_vect){ 

	#ifdef PINMODE

	PCintPort::s_PORT='K';

	#endif

	PCintPort::curr = portK.portInputReg;

	portK.PCint();

}

#endif

#endif // __USE_PORT_JK

#ifdef GET_PCINT_VERSION

uint16_t getPCIntVersion () {

	return ((uint16_t) PCINT_VERSION);

}

#endif // GET_PCINT_VERSION

#endif // #ifndef LIBCALL_PINCHANGEINT *************************************************************

#endif // #ifndef PinChangeInt_h *******************************************************************

/*

  ByteBuffer.cpp - A circular buffer implementation for Arduino

  Created by Sigurdur Orn, July 19, 2010.

  siggi@mit.edu

  Updated by GreyGnome (aka Mike Schwager) Thu Feb 23 17:25:14 CST 2012

  	added the putString() method and the fillError variable.

	added the checkError() and resetError() methods.  The checkError() method resets the fillError variable

	to false as a side effect.

	added the ByteBuffer(unsigned int buf_size) constructor.

	added the init() method, and had the constructor call it automagically.

	Also made the capacity, position, length, and fillError variables volatile, for safe use by interrupts.

 */

#include "ByteBuffer.h"

void ByteBuffer::init(){

	ByteBuffer::init(DEFAULTBUFSIZE);

}

void ByteBuffer::init(unsigned int buf_length){

	data = (byte*)malloc(sizeof(byte)*buf_length);

	capacity = buf_length;

	position = 0;

	length = 0;

	fillError=false;

}

void ByteBuffer::deAllocate(){

	free(data);

}

void ByteBuffer::clear(){

	position = 0;

	length = 0;

}

void ByteBuffer::resetError(){

	fillError=false;

}

boolean ByteBuffer::checkError(){

	/*

	if (fillError) {

		Serial.print("E: checkError: length ");

		Serial.println(length, DEC);

	}

	*/

	boolean result=fillError;

	fillError=false;

	return(result);

}

int ByteBuffer::getSize(){

	return length;

}

int ByteBuffer::getCapacity(){

	return capacity;

}

byte ByteBuffer::peek(unsigned int index){

	byte b = data[(position+index)%capacity];

	return b;

}

uint8_t ByteBuffer::put(byte in){

	if(length < capacity){

		// save data byte at end of buffer

		data[(position+length) % capacity] = in;

		// increment the length

		length++;

		return 1;

	}

	// return failure

	//Serial.print("E: put: ");

	//Serial.println(length, DEC);

	fillError=true;

	return 0;

}

uint8_t ByteBuffer::putString(char *in){

	uint8_t count=0;

	char *inString;

	inString=in;

	uint8_t oldSREG = SREG; cli();

	while(length <= capacity){

		if (length == capacity) {

			fillError=true;

			return count;

		}

		// save data byte at end of buffer

		data[(position+length) % capacity] = *inString;

		// increment the length

		length++;

		inString++;

		count++;

		if (*inString == 0) {

			if (count==0) fillError=true; // Serial.println("E: putString"); };

			SREG = oldSREG; // Restore register; reenables interrupts

			return count;

		}

	}

	SREG = oldSREG; // Restore register; reenables interrupts

	return count;

}

uint8_t ByteBuffer::putInFront(byte in){

	uint8_t oldSREG = SREG; cli();

	if(length < capacity){

			// save data byte at end of buffer

			if( position == 0 )

					position = capacity-1;

			else

					position = (position-1)%capacity;

			data[position] = in;

			// increment the length

			length++;

			SREG = oldSREG; // Restore register; reenables interrupts

			return 1;

	}

	// return failure

	//Serial.println("E: putInFront");

	fillError=true;

	SREG = oldSREG; // Restore register; reenables interrupts

	return 0;

}

byte ByteBuffer::get(){

	uint8_t oldSREG = SREG; cli();

	byte b = 0;

	if(length > 0){

		b = data[position];

		// move index down and decrement length

		position = (position+1)%capacity;

		length--;

	}

	SREG = oldSREG; // Restore register; reenables interrupts

	return b;

}

byte ByteBuffer::getFromBack(){

	byte b = 0;

	if(length > 0){

		uint8_t oldSREG = SREG; cli();

		b = data[(position+length-1)%capacity];

		length--;

		SREG = oldSREG; // Restore register; reenables interrupts

	}

	return b;

}

//

// Ints

//

void ByteBuffer::putIntInFront(int in){

    byte *pointer = (byte *)∈

	putInFront(pointer[0]);	

	putInFront(pointer[1]);	

}

void ByteBuffer::putInt(int in){

    byte *pointer = (byte *)∈

	put(pointer[1]);	

	put(pointer[0]);	

}

int ByteBuffer::getInt(){

	int ret;

    byte *pointer = (byte *)&ret;

	pointer[1] = get();

	pointer[0] = get();

	return ret;

}

int ByteBuffer::getIntFromBack(){

	int ret;

    byte *pointer = (byte *)&ret;

	pointer[0] = getFromBack();

	pointer[1] = getFromBack();

	return ret;

}

//

// Longs

//

void ByteBuffer::putLongInFront(long in){

    byte *pointer = (byte *)∈

	putInFront(pointer[0]);	

	putInFront(pointer[1]);	

	putInFront(pointer[2]);	

	putInFront(pointer[3]);	

}

void ByteBuffer::putLong(long in){

    byte *pointer = (byte *)∈

	put(pointer[3]);	

	put(pointer[2]);	

	put(pointer[1]);	

	put(pointer[0]);	

}

long ByteBuffer::getLong(){

	long ret;

    byte *pointer = (byte *)&ret;

	pointer[3] = get();

	pointer[2] = get();

	pointer[1] = get();

	pointer[0] = get();

	return ret;

}

long ByteBuffer::getLongFromBack(){

	long ret;

    byte *pointer = (byte *)&ret;

	pointer[0] = getFromBack();

	pointer[1] = getFromBack();

	pointer[2] = getFromBack();

	pointer[3] = getFromBack();

	return ret;

}

//

// Floats

//

void ByteBuffer::putFloatInFront(float in){

    byte *pointer = (byte *)∈

	putInFront(pointer[0]);	

	putInFront(pointer[1]);	

	putInFront(pointer[2]);	

	putInFront(pointer[3]);	

}

void ByteBuffer::putFloat(float in){

    byte *pointer = (byte *)∈

	put(pointer[3]);	

	put(pointer[2]);	

	put(pointer[1]);	

	put(pointer[0]);	

}

float ByteBuffer::getFloat(){

	float ret;

    byte *pointer = (byte *)&ret;

	pointer[3] = get();

	pointer[2] = get();

	pointer[1] = get();

	pointer[0] = get();

	return ret;

}

float ByteBuffer::getFloatFromBack(){

	float ret;

    byte *pointer = (byte *)&ret;

	pointer[0] = getFromBack();

	pointer[1] = getFromBack();

	pointer[2] = getFromBack();

	pointer[3] = getFromBack();

	return ret;

}

/*

  ByteBuffer.h - A circular buffer implementation for Arduino

  Created by Sigurdur Orn, July 19, 2010.  siggi@mit.edu

  Updated by GreyGnome (aka Mike Schwager) Thu Feb 23 17:25:14 CST 2012

  	added the putString() method and the fillError variable.

	added the checkError() and resetError() methods.  The checkError() method resets the fillError variable

	to false as a side effect.

	added the ByteBuffer(unsigned int buf_size) constructor.

	added the init() method, and had the constructor call it automagically.

	protected certain sections of the code with cli()/sei() calls, for safe use by interrupts.

	Also made the capacity, position, length, and fillError variables volatile, for safe use by interrupts.

 */

#ifndef ByteBuffer_h

#define ByteBuffer_h

#if defined(ARDUINO) && ARDUINO >= 100

  #include <Arduino.h>

#else

  #include <WProgram.h>

#endif

//#include <util/atomic.h>

#define DEFAULTBUFSIZE 32

class ByteBuffer

{

public:

	ByteBuffer() {

		init();

	};

	ByteBuffer(unsigned int buf_size) {

		init(buf_size);

	};

	// This method initializes the datastore of the buffer to a certain size.

	void init(unsigned int buf_size);

	// This method initializes the datastore of the buffer to the default size.

	void init();

	// This method resets the buffer into an original state (with no data)	

	void clear();

	// This method resets the fillError variable to false.

	void resetError();

	// This method tells you if your buffer overflowed at some time since the last

	// check.  The error state will be reset to false.

	boolean checkError();

	// This releases resources for this buffer, after this has been called the buffer should NOT be used

	void deAllocate();

	// Returns how much space is used in the buffer

	int getSize();

	// Returns the maximum capacity of the buffer

	int getCapacity();

	// This method returns the byte that is located at index in the buffer but doesn't modify the buffer like the get methods (doesn't remove the retured byte from the buffer)

	byte peek(unsigned int index);

	//

	// Put methods, either a regular put in back or put in front

	// 

	uint8_t putInFront(byte in);

	uint8_t put(byte in);

	uint8_t putString(char *in);

	void putIntInFront(int in);

	void putInt(int in);

	void putLongInFront(long in);

	void putLong(long in);

	void putFloatInFront(float in);

	void putFloat(float in);

	//

	// Get methods, either a regular get from front or from back

	// 

	byte get();

	byte getFromBack();

	int getInt();

	int getIntFromBack();

	long getLong();	

	long getLongFromBack();	

	float getFloat();	

	float getFloatFromBack();	

private:

	byte* data;

	volatile unsigned int capacity;

	volatile unsigned int position;

	volatile unsigned int length;

	volatile boolean fillError;

};

#endif

#ifndef INCLUDE_GETPSTR

#define INCLUDE_GETPSTR

#if defined(ARDUINO) && ARDUINO >= 100

  #include <Arduino.h>

#else

  #include "pins_arduino.h"

  #include "WProgram.h"

  #include "wiring.h"

#endif

#define getPSTR(s) pgmStrToRAM(PSTR(s))

char *_pstr_to_print;

char *pgmStrToRAM(PROGMEM char *theString) {

	free(_pstr_to_print);

	_pstr_to_print=(char *) malloc(strlen_P(theString));

	strcpy_P(_pstr_to_print, theString);

	return (_pstr_to_print);

}

#endif

// PinChangeIntExample, version 1.1 Sun Jan 15 06:24:19 CST 2012

// See the Wiki at http://code.google.com/p/arduino-pinchangeint/wiki for more information.

//-------- define these in your sketch, if applicable ----------------------------------------------------------

// You can reduce the memory footprint of this handler by declaring that there will be no pin change interrupts

// on any one or two of the three ports.  If only a single port remains, the handler will be declared inline

// reducing the size and latency of the handler.

//#define NO_PORTB_PINCHANGES // to indicate that port b will not be used for pin change interrupts

//#define NO_PORTC_PINCHANGES // to indicate that port c will not be used for pin change interrupts

// #define NO_PORTD_PINCHANGES // to indicate that port d will not be used for pin change interrupts

// if there is only one PCInt vector in use the code can be inlined

// reducing latency and code size

// define DISABLE_PCINT_MULTI_SERVICE below to limit the handler to servicing a single interrupt per invocation.

// #define       DISABLE_PCINT_MULTI_SERVICE

//-------- define the above in your sketch, if applicable ------------------------------------------------------

#include <PinChangeInt.h>

// This example demonstrates a configuration of 3 interrupting pins and 2 interrupt functions.

// All interrupts are serviced immediately, but one of the pins (pin 4) will show you immediately

// on the Terminal.  The other function connected to 2 pins sets an array member that is queried in loop().

// You can then query the array at your leisure.

// This makes loop timing non-critical.

// Add more Pins at your leisure.

// For the Analog Input pins used as digital input pins, and you can use 14, 15, 16, etc.

// or you can use A0, A1, A2, etc. (the Arduino code comes with #define's

// for the Analog Input pins and will properly recognize e.g., pinMode(A0, INPUT);

#define PIN1 2

#define PIN2 3

#define PIN3 4

uint8_t latest_interrupted_pin;

uint8_t interrupt_count[20]={0}; // 20 possible arduino pins

void quicfunc() {

  latest_interrupted_pin=PCintPort::arduinoPin;

  interrupt_count[latest_interrupted_pin]++;

};

// You can assign any number of functions to any number of pins.

// How cool is that?

void pin3func() {

  Serial.print("Pin "); Serial.print(PIN3, DEC); Serial.println("!");

}

void setup() {

  pinMode(PIN1, INPUT); digitalWrite(PIN1, HIGH);

  PCintPort::attachInterrupt(PIN1, &quicfunc, FALLING);  // add more attachInterrupt code as required

  pinMode(PIN2, INPUT); digitalWrite(PIN2, HIGH);

  PCintPort::attachInterrupt(PIN2, &quicfunc, FALLING);

  pinMode(PIN3, INPUT); digitalWrite(PIN3, HIGH);

  PCintPort::attachInterrupt(PIN3, &pin3func, CHANGE);

  Serial.begin(115200);

  Serial.println("---------------------------------------");

}

uint8_t i;

void loop() {

  uint8_t count;

  Serial.print(".");

  delay(1000);

  for (i=0; i < 20; i++) {

    if (interrupt_count[i] != 0) {

      count=interrupt_count[i];

      interrupt_count[i]=0;

      Serial.print("Count for pin ");

      if (i < 14) {

        Serial.print("D");

        Serial.print(i, DEC);

      } else {

        Serial.print("A");

        Serial.print(i-14, DEC);

      }

      Serial.print(" is ");

      Serial.println(count, DEC);

    }

  }

}

// PinChangeIntSpeedTest by GreyGnome aka Mike Schwager.  Version numbers here refer to this sketch.

// Version 1.0 - initial version

// Version 1.1 - added code to test digitalRead()

// Version 1.2 - added new comments for the #define's for the NO_PORTx_PINCHANGES.

// Version 1.3 - includes cbiface.h with ooPinChangeInt, rather than cb.h

// Version 1.4 - testing version 2.10Beta with robtillaart's optimization

//   Also added a #define/#undef INLINE_PCINTFUNC for inlining of the function called by the interrupt.

//   Default:  #undef for using the function as per usual.  Changed PCIVERSION so that

//   ooPinChangeInt starts at 1000 instead of 200.  Modified the "Start" message to show "Start..", pause

//   for 1 second, show "*\n" (where \n is a newline), pause for 1 second, then run the test.

// Version 1.4 - made this compatible with version 1.5 of PinChangeInt

// Version 1.5 - modified it to use #define OOPCIVERSION for ooPinChangeInt

// This version number is for ooPinChangeInt

//#define OOPCIVERSION 1030

#ifndef OOPCIVERSION

#define PCIVERSION 217 // 110 if using PinChangeInt-1.1, 120 for version 1.2

                       // 1000 for ooPinChangeIntversion 1.00, 1001 for ooPinChangeInt version 1.01, etc.

#endif

//-------- define these in your sketch, if applicable ----------------------------------------------------------

// You can reduce the memory footprint of this handler by declaring that there will be no pin change interrupts

// on any one or two of the three ports.  If only a single port remains, the handler will be declared inline

// reducing the size and latency of the handler.

#undef NO_PORTB_PINCHANGES // to indicate that port b will not be used for pin change interrupts

#undef NO_PORTC_PINCHANGES // to indicate that port c will not be used for pin change interrupts

// #define NO_PORTD_PINCHANGES // to indicate that port d will not be used for pin change interrupts

// You can reduce the code size by 20-50 bytes, and you can speed up the interrupt routine

// slightly by declaring that you don't care if the static variables PCintPort::pinState and/or

// PCintPort::arduinoPin are set and made available to your interrupt routine.

// #define NO_PIN_STATE        // to indicate that you don't need the pinState

// #define NO_PIN_NUMBER       // to indicate that you don't need the arduinoPin

// if there is only one PCInt vector in use the code can be inlined

// reducing latency and code size

// define DISABLE_PCINT_MULTI_SERVICE below to limit the handler to servicing a single interrupt per invocation.

//#define       DISABLE_PCINT_MULTI_SERVICE

//-------- define the above in your sketch, if applicable ------------------------------------------------------

#if defined(OOPCIVERSION)

  #define LIBRARYUNDERTEST "ooPinChangeInt"

  #include <ooPinChangeInt.h>

  #if PCIVERSION == 1001

    #include <cb.h>

  #else

    #include <cbiface.h>

  #endif

#else

  #define LIBRARYUNDERTEST "PinChangeInt"

  #include <PinChangeInt.h>

#endif

#define SERIALSTUFF // undef to take out all serial statements.  Default:  #define for measuring time.

#undef MEMTEST     // undef to take out memory tests.  Default:  #undef for measuring time.

#undef INLINE_PCINTFUNC // define to inline the function called from the interrupt.  This should have no effect,

                        // because the compiler will store the registers upon calling the interrupt routine, just

                        // like calling a function.  Still, we test all assumptions.

//-----------------------

// NOTE:  BECAUSE OF COLLISIONS in these libraries, you CANNOT have both libraries:  PinChangeInt

// and ooPinChangeInt in the libraries directory at the same time.  That said, under UNIX-y operating

// systems, it's easy to move the library directory to a name such as "PinChangeInt-1.3", which the

// Arduino will not recognize, and then create a symbolic link when you want to use a library.  Such as:

// cd ~/Documents/Arduino/libaries

// mv PinChangeInt PinChangeInt-1.30

// mv ooPinChangeInt ooPinChangeInt-1.00