Hi I’m just wondering if anyone did anything like Capacitive Sensing Library that I could use on my Panda 2 board.
Link:
http://playground.arduino.cc//Main/CapacitiveSensor?from=Main.CapSense
In application like:
http://www.pjrc.com/teensy/td_libs_CapacitiveSensor.html
Is there easy way to use Arduino libraries on FEZ devices?
I’ve searched codeshare and forum but I couldn’t find a toppic regarding capacative touch sensors.
Well that is not the anwser I’'m looking for. Sorce library is written in c++ about 200 lines of code + cross lang refeference (arduino code to micro c#).
There is not a problem for me to translate arduino code to c#. The problem are the libraries written for arduino to get them work on FEZ board’s. And to translate the library to get all that working …nevermind
Btw here is the code:
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#include "pins_arduino.h"
#include "WConstants.h"
#endif
#include "CapacitiveSensor.h"
// Constructor /////////////////////////////////////////////////////////////////
// Function that handles the creation and setup of instances
CapacitiveSensor::CapacitiveSensor(uint8_t sendPin, uint8_t receivePin)
{
uint8_t sPort, rPort;
// initialize this instance's variables
// Serial.begin(9600); // for debugging
error = 1;
loopTimingFactor = 310; // determined empirically - a hack
CS_Timeout_Millis = (2000 * (float)loopTimingFactor * (float)F_CPU) / 160000000; //ive changed that
CS_AutocaL_Millis = 20000;
// Serial.print("timwOut = ");
// Serial.println(CS_Timeout_Millis);
// get pin mapping and port for send Pin - from PinMode function in core
#ifdef NUM_DIGITAL_PINS
if (sendPin >= NUM_DIGITAL_PINS) error = -1;
if (receivePin >= NUM_DIGITAL_PINS) error = -1;
#endif
sBit = digitalPinToBitMask(sendPin); // get send pin's ports and bitmask
sPort = digitalPinToPort(sendPin);
sReg = portModeRegister(sPort);
sOut = portOutputRegister(sPort); // get pointer to output register
rBit = digitalPinToBitMask(receivePin); // get receive pin's ports and bitmask
rPort = digitalPinToPort(receivePin);
rReg = portModeRegister(rPort);
rIn = portInputRegister(rPort);
rOut = portOutputRegister(rPort);
// get pin mapping and port for receive Pin - from digital pin functions in Wiring.c
noInterrupts();
*sReg |= sBit; // set sendpin to OUTPUT
interrupts();
leastTotal = 0x0FFFFFFFL; // input large value for autocalibrate begin
lastCal = millis(); // set millis for start
}
// Public Methods //////////////////////////////////////////////////////////////
// Functions available in Wiring sketches, this library, and other libraries
long CapacitiveSensor::capacitiveSensor(uint8_t samples)
{
total = 0;
if (samples == 0) return 0;
if (error < 0) return -1; // bad pin
for (uint8_t i = 0; i < samples; i++) { // loop for samples parameter - simple lowpass filter
if (SenseOneCycle() < 0) return -2; // variable over timeout
}
// only calibrate if time is greater than CS_AutocaL_Millis and total is less than 10% of baseline
// this is an attempt to keep from calibrating when the sensor is seeing a "touched" signal
if ( (millis() - lastCal > CS_AutocaL_Millis) && abs(total - leastTotal) < (int)(.10 * (float)leastTotal) ) {
// Serial.println(); // debugging
// Serial.println("auto-calibrate");
// Serial.println();
// delay(2000); */
leastTotal = 0x0FFFFFFFL; // reset for "autocalibrate"
lastCal = millis();
}
/*else{ // debugging
Serial.print(" total = ");
Serial.print(total);
Serial.print(" leastTotal = ");
Serial.println(leastTotal);
Serial.print("total - leastTotal = ");
x = total - leastTotal ;
Serial.print(x);
Serial.print(" .1 * leastTotal = ");
x = (int)(.1 * (float)leastTotal);
Serial.println(x);
} */
// routine to subtract baseline (non-sensed capacitance) from sensor return
if (total < leastTotal) leastTotal = total; // set floor value to subtract from sensed value
return(total - leastTotal);
}
long CapacitiveSensor::capacitiveSensorRaw(uint8_t samples)
{
total = 0;
if (samples == 0) return 0;
if (error < 0) return -1; // bad pin - this appears not to work
for (uint8_t i = 0; i < samples; i++) { // loop for samples parameter - simple lowpass filter
if (SenseOneCycle() < 0) return -2; // variable over timeout
}
return total;
}
void CapacitiveSensor::reset_CS_AutoCal(void){
leastTotal = 0x0FFFFFFFL;
}
void CapacitiveSensor::set_CS_AutocaL_Millis(unsigned long autoCal_millis){
CS_AutocaL_Millis = autoCal_millis;
}
void CapacitiveSensor::set_CS_Timeout_Millis(unsigned long timeout_millis){
CS_Timeout_Millis = (timeout_millis * (float)loopTimingFactor * (float)F_CPU) / 16000000; // floats to deal with large numbers
}
// Private Methods /////////////////////////////////////////////////////////////
// Functions only available to other functions in this library
int CapacitiveSensor::SenseOneCycle(void)
{
noInterrupts();
*sOut &= ~sBit; // set Send Pin Register low
*rReg &= ~rBit; // set receivePin to input
*rOut &= ~rBit; // set receivePin Register low to make sure pullups are off
*rReg |= rBit; // set pin to OUTPUT - pin is now LOW AND OUTPUT
*rReg &= ~rBit; // set pin to INPUT
*sOut |= sBit; // set send Pin High
interrupts();
while ( !(*rIn & rBit) && (total < CS_Timeout_Millis) ) { // while receive pin is LOW AND total is positive value
total++;
}
if (total > CS_Timeout_Millis) {
return -2; // total variable over timeout
}
// set receive pin HIGH briefly to charge up fully - because the while loop above will exit when pin is ~ 2.5V
noInterrupts();
*rOut |= rBit; // set receive pin HIGH - turns on pullup
*rReg |= rBit; // set pin to OUTPUT - pin is now HIGH AND OUTPUT
*rReg &= ~rBit; // set pin to INPUT
*rOut &= ~rBit; // turn off pullup
*sOut &= ~sBit; // set send Pin LOW
interrupts();
while ( (*rIn & rBit) && (total < CS_Timeout_Millis) ) { // while receive pin is HIGH AND total is less than timeout
total++;
}
// Serial.println(total);
if (total >= CS_Timeout_Millis) {
return -2; // total variable over timeout
} else {
return 1;
}
}
And the header:
#ifndef CapacitiveSensor_h
#define CapacitiveSensor_h
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
// library interface description
class CapacitiveSensor
{
// user-accessible "public" interface
public:
// methods
CapacitiveSensor(uint8_t sendPin, uint8_t receivePin);
long capacitiveSensorRaw(uint8_t samples);
long capacitiveSensor(uint8_t samples);
void set_CS_Timeout_Millis(unsigned long timeout_millis);
void reset_CS_AutoCal();
void set_CS_AutocaL_Millis(unsigned long autoCal_millis);
// library-accessible "private" interface
private:
// variables
int error;
unsigned long leastTotal;
unsigned int loopTimingFactor;
unsigned long CS_Timeout_Millis;
unsigned long CS_AutocaL_Millis;
unsigned long lastCal;
unsigned long total;
uint8_t sBit; // send pin's ports and bitmask
volatile uint8_t *sReg;
volatile uint8_t *sOut;
uint8_t rBit; // receive pin's ports and bitmask
volatile uint8_t *rReg;
volatile uint8_t *rIn;
volatile uint8_t *rOut;
// methods
int SenseOneCycle(void);
};
#endif