View difference between Paste ID: dUjysqwt and NQtbVCFh

-/**********************************************************************
+// File: ppm-decode.cpp
- Various Maple tests.. including timer capture to memory via dma =)
+// Original code from http://pastebin.com/NQtbVCFh
- */
+// Posted on the leaflabs.com forum by Dweller:
 // http://forums.leaflabs.com/topic.php?id=1170
 ///**********************************************************************
 // Various Maple tests.. including timer capture to memory via dma =)
 // */
 #include "main.h"
-//quick method to return if there's anyone on the other end of the serialusb link yet.
+#include "wirish.h"
-boolean isConnected(){
+
-  return (SerialUSB.isConnected() && (SerialUSB.getDTR() || SerialUSB.getRTS()));
+
 #include "dma.h"
 #include "utils.h"
-void setup(){
+
-  SerialUSB.begin();
+//number of captures to do by dma
-  while(!isConnected()); //wait till console attaches.
+#define TIMERS 9
-  SerialUSB.println("Hello!");
+
 // timer prescale
 #define TIMER_PRESCALE 26
-/**********************************************************************
+
- timer tests.. seeing if the timer clock really does run at 72mhz..
+// TIMER_PRESCALE*(1/72 MHz) =
- */
+#define TICK_PERIOD ( TIMER_PRESCALE*0.0000138888889f )
 
-volatile int overflowCount=0;
+HardwareTimer timer4 = HardwareTimer(4);
-void countOverflows(){
+volatile int dma_data_captured=0;            //set to 1 when dma complete.
-  overflowCount++;
+
 uint16 delta=0;
 uint16 ppm_timeout=0;
-int PRESCALE=128;
+int do_print=1;
-int WAIT=50;
+
-int results[16];
+
-int overflow[16];
+
-void testHardwareTimer(HardwareTimer t){
+	float duty;
-  t.attachInterrupt(1,countOverflows);
+	for(int i=0; i<TIMERS; i++){
-  for(int i=0; i<16; i++){
+
-    t.setCount(0);
+		if(ppm_timeout==1){
-    overflowCount=0;
+			if(do_print==1)
-    t.resume();
+			{
-    delay(WAIT);
+				SerialUSB.println("PPM timeout!");
-    t.pause();
+				do_print=0;
-    results[i]=t.getCount();
+			}
-    overflow[i]=overflowCount;
+			return;
-  }
+		}
-  t.detachInterrupt(1);
+
 		if(i>0) delta = data[i]-data[i-1];
-void printResults(){
+		else delta = data[i] - data[TIMERS-1];
-  SerialUSB.print("Timing results: ");
+
-  for(int i=0; i<16; i++){
+		duty=(delta)*TICK_PERIOD;
-    SerialUSB.print(results[i]);
+
-    SerialUSB.print(" ");
+		SerialUSB.print(delta);
-  }
+		SerialUSB.print(":(");
-  SerialUSB.println();
+		SerialUSB.print(duty);
-  SerialUSB.print("Overflows: ");
+		SerialUSB.print(")");
-  for(int i=0; i<16; i++){
+		if ((i+1)%9==0)	SerialUSB.print("\r");
-    SerialUSB.print(overflow[i]);
+		else SerialUSB.print("\t");
-    SerialUSB.print(" ");
+
-  }
+	SerialUSB.println();
-  SerialUSB.println();
+
-  SerialUSB.print("Each count worth approx (ns): ");
+
-  for(int i=0; i<16; i++){
+
-    SerialUSB.print( waitToNanos(overflow[i], results[i]) );
+
-    SerialUSB.print(" ");
+
-  }
+	dma_irq_cause cause = dma_get_irq_cause(DMA1, DMA_CH1);
-  SerialUSB.println();
+        //using serialusb to print messages here is nice, but
         //it takes so long, we may never exit this isr invocation
-double expectedTimePeriod(){
+
-  //in nanos.. so 72mhz = 72000khz = 72000000hz  1/72000000hz = tick in seconds
+
-  // 1/72000 = tick in ms, 1/72 = tick in us (1/72) * 1000 = tick in ns
+	timer4.setCount(0);  // clear counter
-  //tick in ns * prescale == time we're supposed to see
+	if(ppm_timeout) ppm_timeout=0;
-  return ((double)1.0 / ((double)72.0)) * (double)1000.0 * (double)PRESCALE;
+	if(!do_print) do_print=1;
 	switch(cause)
-double waitToNanos( int overflows, int count ){
+
-  //wait is in millis, *1000 for micros, *1000 for nanos
+
-  double time = (((double)WAIT * (double)1000.0 * (double)1000.0) ) ;
+
-  time = time / ((double)count + ((double)65535*(double)overflows));
+                        //SerialUSB.println("DMA Complete");
-  return time;
+                        dma_data_captured=1;
 			break;
 		case DMA_TRANSFER_HALF_COMPLETE:
-int readInt(char terminator){
+
-  char current;
+                        SerialUSB.println("DMA Half Complete");
-  int output=0;
+
-  while(SerialUSB.available() && (current=SerialUSB.read())!=terminator){
+
-    if(current>='0' && current<='9'){
+
-      output=output*10;
+
-      output+=(current-'0');
+                        dma_data_captured=1;
-    }else{
+
-      output=-1;
+
-      break;
+
-    }
+
-  }
+
-  return output;
+                        dma_data_captured=1;
 			break;
 	}
-HardwareTimer timer2 = HardwareTimer(2);
+
-HardwareTimer timer1 = HardwareTimer(1);
+
-void timingTest(){
+
-      SerialUSB.println("Starting Timing test");
+void ppm_timeout_isr()
-      SerialUSB.print(" Prescale: ");
+
-      SerialUSB.println(PRESCALE);
+	// This failure mode indicates we lost comm with
-      SerialUSB.print(" Wait Period (ms): ");
+	// the transmitter
-      SerialUSB.println(WAIT);
+
-      SerialUSB.print(" Expected value for each tick :");
+	//TODO: re-initialize the timer and wait for ppm signal
-      SerialUSB.println(expectedTimePeriod());
+	//re-initializing should ensure that the ppm signal
-      timer1.pause();
+	// is captured on the sync pulse.
-      timer2.pause();
+	ppm_timeout=1;
 	dma_data_captured=0;
-      timer2.setMode(TIMER_CH1, TIMER_OUTPUT_COMPARE);
+
-      timer2.setPrescaleFactor(PRESCALE);
+
-      timer2.setOverflow(65535);
+void init_timer_input_capture_dma()
-      timer2.setCompare(1,65535);
+
-      timer2.setCount(0);
+
-      timer2.refresh();
+    timer_dev *t = TIMER4;
 
-      timer1.setMode(TIMER_CH1, TIMER_OUTPUT_COMPARE);
+    timer4.pause();
-      timer1.setPrescaleFactor(PRESCALE);
+    timer4.setPrescaleFactor(TIMER_PRESCALE);
-      timer1.setOverflow(65535);
+    timer4.setOverflow(65535);
-      timer1.setCompare(1,65535);
+    timer4.setCount(0);
-      timer1.setCount(0);
+
-      timer1.refresh();
+    // use channel 2 to detect when we stop receiving
     // a ppm signal from the encoder.
-      testHardwareTimer(timer1);
+    timer4.setMode(TIMER_CH2, TIMER_OUTPUT_COMPARE);
-      printResults();
+    timer4.setCompare(TIMER_CH2, 65535);
     timer4.attachCompare2Interrupt(ppm_timeout_isr);
-      testHardwareTimer(timer2);
+
-      printResults();
+
     timer4.refresh();
 
-/******************************************************************************
+    timer_reg_map r = t->regs;
- DMA from Timer Capture to array test..
+
- */
+    //using timer4, channel1, maps to pin d16 (maple mini) //d6 (maple?)
     //according to maple master pin map.
-//number of captures to do..
+    pinMode(PPM_PIN, INPUT);
-#define TIMERS 512
+
-volatile int exit=0;            //set to 1 when dma complete.
+    //capture compare regs TIMx_CCRx used to hold val after a transition on corresponding ICx
 
     //when cap occurs, flag CCXIF (TIMx_SR register) is set,
     //and interrupt, or dma req can be sent if they are enabled.
 
-  SerialUSB.print("DATA: ");
+    //if cap occurs while flag is already high CCxOF (overcapture) flag is set..
-  for(int i=0; i<TIMERS; i++){
+
-    SerialUSB.print(data[i]);
+    //CCIX can be cleared by writing 0, or by reading the capped data from TIMx_CCRx
-    SerialUSB.print(" ");
+    //CCxOF is cleared by writing 0 to it.
-  }
+
-  SerialUSB.println();
+    //Clear the CC1E bit to disable capture from the counter as we set it up.
     //CC1S bits aren't writeable when CC1E is set.
     //CC1E is bit 0 of CCER (page 401)
     bitClear(r.gen->CCER,0);
 
 
-	dma_irq_cause cause = dma_get_irq_cause(DMA1, DMA_CH2);
+    //Capture/Compare 1 Selection
-        //using serialusb to print messages here is nice, but
+    //  set CC1S bits to 01 in the capture compare mode register 1.
     //  01 selects TI1 as the input to use. (page 399 stm32 reference)
     //  (assuming here that TI1 is D16, according to maple master pin map)
     //CC1S bits are bits 1,0
     bitClear(r.gen->CCMR1, 1);
     bitSet(r.gen->CCMR1, 0);
 
-                        SerialUSB.println("DMA Complete");
+
-                        exit=1;
+    //Input Capture 1 Filter.
     //  need to set IC1F bits according to a table saying how long
     //  we should wait for a signal to be 'stable' to validate a transition
     //  on the input.
-                        SerialUSB.println("DMA Half Complete");
+    //  (page 401 stm32 reference)
     //IC1F bits are bits 7,6,5,4
     bitClear(r.gen->CCMR1, 7);
     bitClear(r.gen->CCMR1, 6);
     bitSet(r.gen->CCMR1, 5);
-                        exit=1;
+    bitSet(r.gen->CCMR1, 4);
 
     //sort out the input capture prescaler IC1PSC..
     //00 no prescaler.. capture is done at every edge detected
     bitClear(r.gen->CCMR1, 3);
     bitClear(r.gen->CCMR1, 2);
-                        exit=1;
+
     //select the edge for the transition on TI1 channel using CC1P in CCER
     //CC1P is bit 1 of CCER (page 401)
     // 0 = rising (non-inverted. capture is done on a rising edge of IC1)
     // 1 = falling (inverted. capture is done on a falling edge of IC1)
     bitClear(r.gen->CCER,1);
 
-void loop(){
+    //set the CC1E bit to enable capture from the counter.
-
+    //CC1E is bit 0 of CCER (page 401)
-  //simple main loop, listens for a char, and uses it as a command
+    bitSet(r.gen->CCER,0);
-  //to select what task to perform
+
-  //
+    //enable dma for this timer..
-  // a   echo test
+    //sets the Capture/Compare 1 DMA request enable bit on the DMA/interrupt enable register.
-  // b   echo test
+    //bit 9 is CC1DE as defined on page 393.
-  // c   serialusb disable/enable test
+    bitSet(r.gen->DIER,9);
-  // d   time the timer test, default params
+
-  // e   time the timer test, user supplied args
+    dma_init(DMA1);
-  // f   DMA timer capture of pulse widths from D6 straight to memory
+    dma_setup_transfer( DMA1,    //dma device, dma1 here because that's the only one we have
-
+                        DMA_CH1, //dma channel, channel1, because it looks after tim4_ch1 (timer4, channel1)
-  while(!SerialUSB.available());
+                        &(r.gen->CCR1), //peripheral address
-  char cmd = SerialUSB.read();
+                        DMA_SIZE_16BITS, //peripheral size
-  switch(cmd)
+                        data, //memory address
-  {
+                        DMA_SIZE_16BITS, //memory transfer size
-  case 'a':
+                        (0
-    {
+                         //| DMA_FROM_MEM  //set if going from memory, don't set if going to memory.
-      SerialUSB.println("Hello");
+                         | DMA_MINC_MODE //auto inc where the data does in memory (uses size_16bits to know how much)
-      break;
+                         | DMA_TRNS_ERR  //tell me if it's fubar
-    }
+                         //| DMA_HALF_TRNS //tell me half way (actually, don't as I spend so long there, I dont see 'complete')
-  case 'b':
+                         | DMA_TRNS_CMPLT //tell me at the end
-    {
+                         | DMA_CIRC_MODE // circular mode... capture "num_transfers" (below) and repeat
-      SerialUSB.println("There");
+                         )
-      break;
+                        );
-    }
+
     dma_attach_interrupt(DMA1, DMA_CH1, dma_isr); //hook up an isr for the dma chan to tell us if things happen.
-  case 'c':
+    dma_set_num_transfers(DMA1, DMA_CH1, TIMERS); //only allow it to transfer TIMERS number of times.
-    {
+    dma_enable(DMA1, DMA_CH1);                    //enable it..
-      SerialUSB.println("Going away for a while");
+
-      SerialUSB.end();
+
-      usbPowerOff();
+
-      delay(5000);
+
-      usbPowerOn();
+void ppm_decode_interrupt_dma()
-      SerialUSB.begin();
+
-      delay(5000);
+
-      while(!isConnected());
+	SerialUSB.print("Starting timer.. rising edge of D");
-      SerialUSB.println("Welcome back");
+    SerialUSB.print(PPM_PIN);
-      break;
+    disable_usarts();
-    }
+
-  case 'd':
+	//start the timer counting.
-    {
+	timer4.resume();
-       WAIT=50;
+	//the timer is now counting up, and any rising edges on D16
-       PRESCALE=128;
+	//will trigger a DMA request to clone the timercapture to the array
-       timingTest();
+
-       break;
+	//If we weren't using DMA, we could busy wait on the CC1IF bit in SR
-    }
+	//
-    case 'e':
+	//when the timer captures, the CC1IF bit will be set on the timer SR register.
-    {
+	//CC1IF bit is bit 1 (page 332)
-      int arg1=0;
+	//while(!bitRead(r.gen->SR, 1)){
-      int arg2=0;
+	//}
-
+	//SerialUSB.println("Timer triggered : ");
-      if(!SerialUSB.available())
+	//SerialUSB.println(r.gen->CCR1);
-        goto usage;
+
-      if(SerialUSB.read()!=' ')
+	//SerialUSB.println("Waiting for dma_data_captured flag from dma...");
-        goto usage;
+	//busy wait on the dma_data_captured flag
-
+	//we could do real work here if wanted..
-      arg1 = readInt(' ');
+	while(!dma_data_captured && !SerialUSB.available());
-      arg2 = readInt(' ');
+
-
+	while(!SerialUSB.available() && do_print==1)
-      if(arg1==-1 || arg2==-1)
+
-        goto usage;
+	  //dump the data
-
+	  printData();
-      SerialUSB.print("Setting prescale to: ");
+	  delay(100);
-      SerialUSB.println(arg1);
+
-      SerialUSB.print("Setting wait to: ");
+
-      SerialUSB.println(arg2);
+	//turn off the timer & tidy up before we leave this cmd.
-
+	timer4.pause();
-      WAIT=arg2;
+
-      PRESCALE=arg1;
+	//      dma_disable(DMA1, DMA_CH2);
-      timingTest();
+	//      dma_detach_interrupt(DMA1, DMA_CH2);
-
+	dma_data_captured=0;
-      goto done;
+
-usage:
+}