2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								/* 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								 * This firmware reads all inputs and sends them as fast as it can.  It was
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								 * inspired by the ease-of-use of the Arduino2Max program.
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								 *
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								 * This example code is in the public domain.
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								 */
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								#include <Firmata.h>
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								byte pin;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								int analogValue;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								int previousAnalogValues[TOTAL_ANALOG_PINS];
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								byte portStatus[TOTAL_PORTS];	// each bit: 1=pin is digital input, 0=other/ignore
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								byte previousPINs[TOTAL_PORTS];
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								/* timer variables */
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								unsigned long currentMillis;     // store the current value from millis()
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								unsigned long previousMillis;    // for comparison with currentMillis
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								/* make sure that the FTDI buffer doesn't go over 60 bytes, otherwise you
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								   get long, random delays.  So only read analogs every 20ms or so */
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								int samplingInterval = 19;      // how often to run the main loop (in ms)
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								void sendPort(byte portNumber, byte portValue)
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								{
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  portValue = portValue & portStatus[portNumber];
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								  if(previousPINs[portNumber] != portValue) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    Firmata.sendDigitalPort(portNumber, portValue);
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    previousPINs[portNumber] = portValue;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  }
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								void setup()
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								{
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  byte i, port, status;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								  Firmata.setFirmwareVersion(0, 1);
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  for(pin = 0; pin < TOTAL_PINS; pin++) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    if IS_PIN_DIGITAL(pin) pinMode(PIN_TO_DIGITAL(pin), INPUT);
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								  }
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  for (port=0; port<TOTAL_PORTS; port++) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    status = 0;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    for (i=0; i<8; i++) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if (IS_PIN_DIGITAL(port * 8 + i)) status |= (1 << i);
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    }
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    portStatus[port] = status;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  }
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  Firmata.begin(57600);
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								void loop()
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								{
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  byte i;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  for (i=0; i<TOTAL_PORTS; i++) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    sendPort(i, readPort(i));
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  }
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								  /* make sure that the FTDI buffer doesn't go over 60 bytes, otherwise you
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								     get long, random delays.  So only read analogs every 20ms or so */
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  currentMillis = millis();
							 
						 
					
						
							
								
									
										
										
										
											2011-02-23 21:47:18 +01:00 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  if(currentMillis - previousMillis > samplingInterval) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    previousMillis += samplingInterval;
							 
						 
					
						
							
								
									
										
										
										
											2010-03-30 20:09:55 +02:00 
										
									 
								 
							 
							
								
							 
							
								 
							
							
								    while(Firmata.available()) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      Firmata.processInput();
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    }
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    for(pin = 0; pin < TOTAL_ANALOG_PINS; pin++) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      analogValue = analogRead(pin);
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      if(analogValue != previousAnalogValues[pin]) {
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        Firmata.sendAnalog(pin, analogValue); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								        previousAnalogValues[pin] = analogValue;
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								      }
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								    }
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  }
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								}