Arduino and kop encoder

[Michael Hill]

Originally Posted by SeanPerez

sorry if i was unclear but i was looking for code for a encoder that reads 360 positions per revolution compared to your 1 . no worries, all i did was divide your rpm by 360.

So you got it working then? Dividing by 360 would be the solution I think.

[Michael Hill]

Oh, and I thought I'd caution you. There's a maximum read rate on the arduinos. It takes about 100 microseconds to take a reading, so it can read about 10,000 times/second. Since you're reading all 360 values every rotation, you've got a maximum of 27.78 rev/sec, or 1666.67 RPM. Not really sure what you're using it for, but keep that in mind.

[docdavies]

Thank you folks. I found this thread very informative and useful.

We are also working to "off-load" more robot functions to an Arduino Mega.

Doc

[SeanPerez]

Originally Posted by Michael Hill

Oh, and I thought I'd caution you. There's a maximum read rate on the arduinos. It takes about 100 microseconds to take a reading, so it can read about 10,000 times/second. Since you're reading all 360 values every rotation, you've got a maximum of 27.78 rev/sec, or 1666.67 RPM. Not really sure what you're using it for, but keep that in mind.

are you sure its 1666? i went up to as high as 2000 multiple times in a row

[SeanPerez]

i think the fastest i could spin it was 2100rpm

[taichichuan]

Actually, the Arduino mega maxes out at about 30,000 PPS. It can easily read 3500-5000 RPM depending on your encoder. Rather than sample at 1x/second, you might try sampling at 100x/second and adjusting the RPM accordingly. Here's an example:

/***
File : turret.pde (opens in arduino IDE www.arduino.cc)
Description : Counts digital pulse on External Interrupt 0 (Digital pin 2) for 100 mseconds and prints the value via UDP
Date : 18th March 2012
Author : Mike Anderson FRC Team #116
Contact : manderson13@cox.net
***/

// include the library code:
#include <SPI.h> // needed for Arduino versions later than 0018
#include <Ethernet.h>
#include <EthernetUdp.h> // UDP library from: bjoern@cs.stanford.edu 12/30/2008
#include <SimpleTimer.h>

// Conversion of Analog value to degrees using U.S. Digital
#define ANALOG_TO_DEGREES 2.84

// Number of pulses per revolution on the shaft encoder
#define SHAFT_ENCODER_PPR 64.0

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(10, 1, 16, 9);
static uint8_t crio_ip[4] = { 10,1,16,2 };
unsigned int remPort = 8888;
unsigned int distance = 0;

unsigned int localPort = 8888; // local port to listen on

// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,

// An EthernetUDP instance to let us send and receive packets over UDP
EthernetUDP Udp;

int iTestPin=13; //Pin which generates test pulses, this is not needed when actual pulse is available for measurement
int iPulsePin = 2; //Pin serving as external interrupt (INT 0) to count the pulses
static int siPulseCounter=0; //Variable keeping track of pulse counts
static int reportInterval=1;

static int multiplierFactor = 60 / reportInterval;

int sensorPin = A0; // select the input pin for the potentiometer
int sensorValue = 0; // variable to store the value coming from the sensor
int tmpDegrees = 0;
int oldDegrees = 0;
float tempFloat = 0.0;

SimpleTimer rpmTimer;
SimpleTimer hoodAngleTimer;

void sendRPM() {
tempFloat = (siPulseCounter / SHAFT_ENCODER_PPR) * 600.0;
Serial.println(siPulseCounter, DEC);
sprintf(packetBuffer, "1 %d\n\0", (int)(tempFloat));
// send a reply, to the IP address and port that sent us the packet we received
// Serial.write(packetBuffer);
Udp.beginPacket(crio_ip, remPort);
Udp.write(packetBuffer);
Udp.endPacket();

siPulseCounter=0; //Reset counter values for next minute cycle

}

void sendHoodAngle() {
sensorValue = analogRead(sensorPin);
tmpDegrees = (int) (sensorValue / ANALOG_TO_DEGREES);

sprintf(packetBuffer, "2 %d\n\0", tmpDegrees);
// send a reply, to the IP address and port that sent us the packet we received
// Serial.write(packetBuffer);
Udp.beginPacket(crio_ip, remPort);
Udp.write(packetBuffer);
Udp.endPacket();
oldDegrees = tmpDegrees;

}

void setup(void)
{

// start the Ethernet and UDP:
Ethernet.begin(mac,ip);
Udp.begin(localPort);

pinMode(iPulsePin, INPUT); // Set Pulsepin to accept inputs

digitalWrite(iPulsePin, HIGH);
pinMode(iTestPin, OUTPUT); // Test signal generator pin as output. Can be ignored if the actual digital signal is available
attachInterrupt(0, count, RISING); // Caputres external interrupt 0 at iPulsepin at rising edge and calls funtion count defined below
Serial.begin(115200); // Begin Serial communication at baudrate 115200 bps
Serial.println(" Initialising, Please wait...");
rpmTimer.setInterval(100, sendRPM);
hoodAngleTimer.setInterval(250, sendHoodAngle);

}

void loop(void)
{
rpmTimer.run();
hoodAngleTimer.run();

/*** Following 4 lines just generate pulses for testing purposes.
All the 4 lines Can be ignored if the actual digital signal is available ***/
//
// digitalWrite(iTestPin, HIGH); // sets the iTestPin ON
// delay(1); // waits for a second
// digitalWrite(iTestPin, LOW); // sets the iTestPin off
// delay(1); // waits for a second

}

void count() // Function called by AttachInterrupt at interrupt at int 0
{
siPulseCounter++; //increment the pulse count
}


/* End of turret.ino */

[purduephotog]

Originally Posted by taichichuan

We are using a Grayhill 63R64 encoder with an Arduino mega for the RPMs of our shooter. We opted for that encoder instead of the KOP because the PPR on the KOP encoder is so high that we were concerned at overrunning the Arduino. Further testing shows that the Arduino is easily capable of 30,000 PPS. So, that concern turned out to be bogus. But, using the KOP encoder would require another gearbox up high on our bot that would adversely effect the COG while trying to balance or going over the bump.

The Arduino mega can source the 5V for the Grayhill or the KOP encoder with no problem. We bring the A channel back from the encoder to Digital Pin 2 on the Arduino. The magic you're looking for can be found in the "attachInterrupt" command. Use it to increment a counter on the rising edge of the encoder pulse and then periodically read the pulse count and do your math for the RPM.

We also added the "SimpleTimer" library from the Arduino playground site so we could get updates every 100 ms. This library attaches a timer interrupt to a function so it's called at the interval you desire rather than simply polling the counter.

Our code sends it's output via an Ethernet shield direct to the cRio using UDP. We found some really interesting gotchas with the cRio robot code in that you must read the packets or face the possibility of a robot lockup. So, you'll need a blocking thread to read the socket constantly. Our robot code is written in C++, so creating a thread was pretty easy.

In addition, our Arduino is also sampling an absolute encoder on our ball shooting angle device. No problem doing both functions and sending out the results.

I'd say that the entire Arduino program for both sensors and the Ethernet output is maybe 50 lines of code total.

You are blocking what here- or are you saying there is a sync here on this. Using java there is the observer observable classes that I found handled serial come quite nicely.

[taichichuan]

Originally Posted by purduephotog

You are blocking what here- or are you saying there is a sync here on this. Using java there is the observer observable classes that I found handled serial come quite nicely.

We're not using Java, but rather C++. Nonetheless, the blocking is in a thread that simply reads from the UDP socket (recvfrom() call) using a blocking socket (one not marked as FIONBIO via ioctl()). No synchronization is needed because the thread gives up the CPU when there is no data to be read and the main robot code continues as normal.

HTH,

Mike