TLB,
Many many thanks for your code. I have modified it slightly for my own use. All I am looking for is to output the encoder values as fast as possible over RS232. The maximum speed I am getting for the RS232 output is 64Hz. I adjusted the GUI Update Time to 5000 and was getting 200Hz but now can't seem to get it.
Can anybody suggest what may be limiting the serial output to 64Hz?
See code below:
/*
To convert from raw encoder * 0.00137290914
Send back values to be read by Python pyserial
Send back 6 values for realtime X,Y,Z and latched X,Y,Z
On button push, latch X,Y,Z with realtime X,Y,Z
Send lines with
RX<value>\n (realtime)
RY<value>\n
RZ<value>\n
LX<value>\n (latched)
LY<value>\n
LZ<value>\n
Send back <value> as ascii string
Only send back latched value once after latching
Also send back comments with MS<string>
Check if any bytes received
If axis to be zeroed, expect string
ZZXY where ZXY are 1 if axis to be zeroed
0 otherwise
*/
/* Use Teensy3.1 FTM (FlexTimerModule) Quadrature Decode
* to determine position on 2 axis
* (3rd channel with second Teensy TBD)
* Position Counter is 16-bit counter
* Read position every 100 mS and determine if counting up
* or down
* Count up in interrupt routine for 200 mS GUI update
*/
/* Pinout
* Function Arduino K20ARM Pin Direction Pin Alternative
* LED 13 PTC5 50 Output
* ENCXA 3 PTA12 28 Input FTM1 7
* ENCXB 4 PTA13 29 Input FTM1 7
* ENCYA 16/A2 PTB0 35 Input FTM1 6
* ENCYB 17/A3 PTB1 36 Input FTM1 6
* ENCZA 32 PTB18 41 Input FTM2 6
* ENCZB 25 PTB19 42 Input FTM2 6
* ENCA 9 PTC3 46 Output
* ENCB 10 PTC4 49 Output
*
*/
/*
* Pin Control Registers PORTx_PCRn
* Bit 10-8 MUX Pin Mux Control 1-7 alternative
* Alternative 1 is GPIO
* Bit 4 PFE Passive Filter Enable 1 to enable
* Bit 1 PE Pull Enable 1 to enable
* Bit 0 PS Pull Select 0 is pulldown 1 is pullup
*/
/* Quadrature Decoding with FTM1 Setup
* FTMEM=1 QUADEN=1
* Filter A PHAFLTREN bit CH0FVAL[3:0] in FILTER0
* Filter B PHBFLTREN bit CH1FVAL[3:0] in FILTER0
* No channel logic used
* FTM channels in input capture or output compare modes
* PHAPOL and PHBPOL selects polarity
* QUADMODE = 0 for quadrature decode
* CNTIN=0 to count from 0
* MOD = 64K for maximum range
* TOF and TOFDIR indication Top Overflow and Direction
* Set CNTIN and MOD before set FTMEM
*
* The following registers are set in pins_teensy.c
* and need to be reset.
* FTM1_SC
* FTM1_CNT
* FTM1_MOD
* FTM1_C0SC
* FTM1_C1SC
*
* FTM1_CNT Counter value
* Bit 15-0 is counter value
* Writing any value updates counter with CNTIN
* FTM1_MOD Modulo (Max value)
* Bit 15-0 is counter value - set to 0xFFFF
* Write to CNT first
* FTM1_MODE Features Mode Selection
* Bit0 FTMEN FTM Enable - [WPDIS must be 1 to write]
* Bit2 WPDIS Write Protect to Disable
* Set WPDIS, then set FTMEN - must be set to access FTM regs
* FTM1_FMS Fault Mode Status
* Bit 6 WPEN Write Protect Enable
* Write 1 to clear WPDIS
* FTM1_FILTER
* Filter out pulses shorter than CHxFVALx 4 system clocks
* Bit 7-4 CH1FVAL for PHB
* Bit 3-0 CH0FVAL for PHA
* FTM1_QDCTRL Quadrature Decoder Control and Status
* Bit 7 PHAFLTREN Phase A Filter Enable
* Bit 6 PHBFLTREN Phase B Filter Enable
* Bit 5 PHAPOL Phase A Polarity
* Bit 4 PHBPOL Phase B Polarity
* Bit 3 QUADMODE Quadrature Decoder Mode
* 0 for Quadrature
* Bit 2 QUADIR Counting Direction
* Bit 1 TOFDIR Timer Overflow Dir
* 0 was set on bottom of counting
* 1 was set on top of counting
* Bit 0 QUADEN Quadrature Mode Enable
* 1 is quadrature mode enabled [WPDIS to write]
*/
/* Generate 32 bit position value from 16 bit counter
* Keep track of BasePosition which indicates how many times wrapped
* around
* Generate TotalPosition by reading counter and adjusting from
* Base Position
* To generate Base Position interrupt at every quadrant
* This is to avoid issues if sitting and oscillating around either point
* Use every quadrant interrupt to determine direction
* To generate base position
* Interrupt on Timer Overflow (TOV)
* Look at current and previous overflow direction
* If overflow in same direction, add or subtract counter value (64K)
* If overflow in opposite direction, reversed direction
* BasePosition count remains the same
* Set Interrupt to Compare at quarter points +-(64K/2)
* Disable Overflow interrupt
* Leave Overflow bit set
* Will be cleared during Compare Interrupt or Position reading
* Need to check during Position reading
* Interrupt on Compare
* Save last overflow direction to know which way were going
* Clear overflow bit
* Far enough away so no oscillation
* Need to interrupt again when reach overflow point
* Set interrupt to overflow
*
* To get TotalPosition read counter and adjust from Base Position
* Read counter as unsigned integer
* Read overflow direction
* If last overflowed counting up, add to Base Position
* If last overflowed counting down, subtract 64K and add to
* Base Position
* Issues with Overflow interrupt occuring during reading
* To deal with this:
* If Interrupt on Compare clear Overflow bit
* Store Base Count
* Read Counter
* Read Overflow Direction
* Read Overflow bit
* If Overflow bit set re-do sequence 3x or until Overflow bit not set
* If 3x and still getting overflow, oscillating around zero
* Default to zero, and add zero to Base Count
* BaseCount should be remaining the same
*/
/* Registers for 16 to 32 conversion interrupts
*
* FTM1_SC FTM1 Status and Control
* Bit 7 TOF Timer Overflow Flag
* Bit 6 TOIE Timer Overflow Interrupt Enable
* Bit 5 CPWMS Center Aligned PWM Select
* Resets to 0 (Write when WPDIS is 1)
* Rest of bits are 0 (Write when WPDIS is 1)
*
* FTM1_C0SC FTM1 Channel 0 Status and Control
* Set WPDIS before writing control bits
* Bit 7 CHF Channel Flag
* Channel event occured
* Read and write 0 to clear
* Bit 6 CHIE Channel Interrupt Enable
* Set for compare interrupt
* Bit 5 MSB Channel Mode Select B
* Set to 0
* Bit 4 MSA Channel Mode Select A
* Set to 1
* Bit 3:2 ELS Edge or Level Select
* Set to 0:0
*
* FTM1_COMBINE
* Set WPDIS to 1 before writing
* DECAPEN (Dual Edge Capture Enable)
* COMBINE (Combine Channels)
* Resets to all zero
*
* FTM1_C0V Channel 0 Value
* Channel Compare Value
* Set to 0x80 - halfway thru count
*
* FTM1_STATUS
* Duplicate of CHnF bit for all channels
* Bit 0 CH0F
*
*/
/* To zero and initialize channel
* Zero counter
* Set last Overflow Dir to Counting Direction
*/
#include "WProgram.h"
#include "QuadDecode_def.h"
#include <stdbool.h>
#define INT_Pin0 23
#define INT_Pin1 22
#include <avr/io.h>
#include <avr/interrupt.h>
#include <Arduino.h>
// Timing for GUI update time, how often send back data values
#define GUI_UPDATE_TIME 10000 // 200 mSec update
// Command headers for X,Y,Z data channels
const char cmd1[] = "RX";
const char cmd2[] = "RY";
const char cmd3[] = "RZ";
const char* cmdPointers[]= {cmd1,cmd2,cmd3};
const uint8_t num_cmds = 3; // Only send up RXYZ continually
// Variables from CMM program
volatile int32_t rtX=0, rtY=0, rtZ=0; // Realtime values of X,Y,Z
float rtXD = 0, rtYD = 0;
volatile bool zero_rtX=0, zero_rtY=0, zero_rtZ=0; // Zero values of X,Y,Z
volatile bool doOutput=false; // Run output routine
IntervalTimer serialTimer; // How often to update serial
void timerInt(void); // Main timing loop interrupt
QuadDecode<1> xPosn; // Template using FTM1
QuadDecode<2> yPosn; // Template using FTM2
extern "C" int main(void)
{
//bool LED_ON=false;
char inbuf[3]; // Characters to be received
char inByte;
int32_t buffer[3]; // Values to send, X,Y,Z realtime and latched
uint8_t n; // Number of characters received
uint8_t j;
Serial1.begin(115200); // USB is always 12 Mbit/sec
pinMode(INT_Pin0, INPUT);
attachInterrupt(INT_Pin0, zerocounterX, RISING);
pinMode(INT_Pin1, INPUT);
attachInterrupt(INT_Pin1, zerocounterY, RISING);
xPosn.setup(); // Start Quad Decode position count
yPosn.setup(); // Start Quad Decode position count
serialTimer.begin(timerInt,GUI_UPDATE_TIME); // GUI Update time
xPosn.start(); // Start Quad Decode position count
yPosn.start(); // Start Quad Decode position count
while (1) {
if (doOutput){
doOutput=false;
// if (zero_rtX ){
// xPosn.zeroFTM();
// }
rtX=xPosn.calcPosn();
if (rtX < 0){
rtXD= rtX + 262144;
}
else {
rtXD = rtX;
}
rtY=yPosn.calcPosn();
rtYD = rtY;
// if (zero_rtZ ){
// rtZ=0;
// }
// Send out axis values
buffer[0] = rtXD;
buffer[1] = rtYD;
buffer[2] = rtZ;
rtXD = rtXD*0.001373;
rtYD = rtYD*0.001373;
// Send out rtX, rtY, rtZ values
Serial1.print(rtXD,2);
Serial1.print(",");
Serial1.println(rtYD,2);
}
}
}
void timerInt(void){
doOutput=true;
}
void zerocounterX(void)
{
cli();
xPosn.zeroFTM();
sei();
}
void zerocounterY(void)
{
cli();
yPosn.zeroFTM();
sei();
}
