Jira-32 and Jira-386. CurieTimerOne lib

Author: SidLeung

libraries/CurieTimerOne/CurieTimer.cpp

@@ -0,0 +1,263 @@
+//***************************************************************
+//
+// Copyright (c) 2015 Intel Corporation.  All rights reserved.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+//
+//***************************************************************
+
+//***************************************************************
+//
+// Module: CurieTimer
+//
+//
+// Notes:
+//
+//   - Arc has two timers, Timer-0 is used.  Please check the file
+//     arcv2_timer0.cpp.
+//
+// Cautions:
+//   - The module, Tone.cpp, also makes use of Arc Timer-1 which
+//     is used here.
+//
+//***************************************************************
+
+
+#include "CurieTimer.h"
+#include <conf.h>
+
+CurieTimer  CurieTimerOne;
+
+static void timerOneIsrWrapper(void)
+{
+  CurieTimerOne.timerIsr();
+}
+static void timerOnePwmCbWrapper(void)
+{
+  CurieTimerOne.pwmCallBack();
+}
+
+
+CurieTimer::CurieTimer(const unsigned int timerNum) :
+  tickCnt(0), currState(IDLE), userCB(NULL)
+{
+  if(timerNum == 0) {
+    timerCountAddr = ARC_V2_TMR0_COUNT;
+    timerControlAddr = ARC_V2_TMR0_CONTROL;
+    timerLimitAddr = ARC_V2_TMR0_LIMIT;
+    timerIrqNum = ARCV2_IRQ_TIMER0;
+    isrFuncPtr = NULL;
+    pwmCB = NULL;
+  }
+  else {
+    timerCountAddr = ARC_V2_TMR1_COUNT;
+    timerControlAddr = ARC_V2_TMR1_CONTROL;
+    timerLimitAddr = ARC_V2_TMR1_LIMIT;
+    timerIrqNum = ARCV2_IRQ_TIMER1;
+    isrFuncPtr = &timerOneIsrWrapper;
+    pwmCB = &timerOnePwmCbWrapper;
+  }
+}
+
+
+// Method:  kill
+// Description:
+//   Set the timer back to power up default condition.
+
+void CurieTimer::kill()
+{
+  interrupt_disable(timerIrqNum);  // Disable Timer at controller
+  aux_reg_write(timerControlAddr, 0);  // Disable Timer itself
+  aux_reg_write(timerLimitAddr, 0);
+  aux_reg_write(timerCountAddr, 0);
+
+  tickCnt = 0;
+  userCB = NULL;
+  currState = IDLE;
+}
+
+
+void CurieTimer::attachInterrupt(void (*userCallBack)())
+{
+  unsigned int reg;
+
+  // Disable timer interrupt first.
+  reg = aux_reg_read(timerControlAddr) & ~ARC_TIMER_EN_INTR_BIT_FLAG;
+  aux_reg_write(timerControlAddr, reg);
+
+  // Record the user call back routine.
+  userCB = userCallBack;
+
+  // Let timer interrupt go again.
+  reg |= ARC_TIMER_EN_INTR_BIT_FLAG;
+  aux_reg_write(timerControlAddr, reg);
+}
+
+
+unsigned int CurieTimer::rdRstTickCount(void)
+{
+  unsigned int tmp;
+
+  tmp = tickCnt;
+  tickCnt = 0;
+  return tmp;
+}
+
+
+void CurieTimer::pause(void)
+{
+  if(currState != RUNNING)
+    return;
+
+  pauseCntrl = aux_reg_read(timerControlAddr);
+  pauseCount = aux_reg_read(timerCountAddr);
+
+  interrupt_disable(timerIrqNum);  // Disable Timer at controller
+  aux_reg_write(timerControlAddr, 0);  // Disable Timer itself
+
+  currState = PAUSED;
+}
+
+
+void CurieTimer::resume(void)
+{
+  if(currState != PAUSED)
+    return;
+
+  aux_reg_write(timerCountAddr, pauseCount);
+  aux_reg_write(timerControlAddr, pauseCntrl);
+  currState = RUNNING;
+}
+
+
+// Method: pwmStart
+//   Kick off a timer as the mean to time a pwm.  Calculate the durations of the duty cycle
+// and they are loaded into the timer in the pwm call back.
+
+int CurieTimer::pwmStart(unsigned int outputPin, double dutyPercentage, unsigned int periodUsec)
+{
+  unsigned int pwmPeriod;
+
+  if(periodUsec == 0)
+    return -(INVALID_PERIOD);
+
+  if((dutyPercentage < 0.0) || (dutyPercentage > 100.0))
+    return -(INVALID_DUTY_CYCLE);
+
+  pwmPin = outputPin;
+  pinMode(pwmPin, OUTPUT);
+
+  if(dutyPercentage == 0.0) {
+    digitalWrite(pwmPin, LOW);
+    return SUCCESS;
+  }
+
+  if(dutyPercentage == 100.0) {
+    digitalWrite(pwmPin, HIGH);
+    return SUCCESS;
+  }
+
+  pwmPeriod = periodUsec * HZ_USEC;
+
+  dutyCycle = (unsigned int)(((double)pwmPeriod / 100.0) * dutyPercentage);
+  nonDutyCycle = pwmPeriod - dutyCycle;
+
+  dutyToggle = true;
+  digitalWrite(pwmPin, HIGH);
+  init(dutyCycle, pwmCB);
+
+  return SUCCESS;
+}
+
+
+int CurieTimer::pwmStart(unsigned int outputPin, int dutyRange, unsigned int periodUsec)
+{
+  if((dutyRange < 0) || (dutyRange > MAX_DUTY_RANGE))
+    return -(INVALID_DUTY_CYCLE);
+
+  return pwmStart(outputPin, ((double)dutyRange * 100.0)/(double)MAX_DUTY_RANGE, periodUsec);
+}
+
+
+// Method:  pwmCallBack
+//   Software PWM ISR.  Timer generates interrupt and calls this method in
+// its ISR.  This routine is responsible to toggle the PWM signal according
+// to duty cycle duration.
+
+inline void CurieTimer::pwmCallBack(void)
+{
+  dutyToggle = !dutyToggle;
+
+  digitalWrite(pwmPin, dutyToggle ? HIGH : LOW);
+
+  aux_reg_write(timerLimitAddr, dutyToggle ? dutyCycle : nonDutyCycle);
+  aux_reg_write(timerCountAddr, 0);
+}
+
+
+// Method:  init
+//   Kick off the timer with a period, in Hz, provided.  Initialize
+// timer to run in non-halt mode, enable timer interrupt.  Always install
+// the generic ISR and initialize the user call back if provided.
+
+int CurieTimer::init(const unsigned int periodHz,
+  void (*userCallBack)())
+{
+  if((periodHz == 0) || (periodHz > MAX_PERIOD))
+    return -(INVALID_PERIOD);
+
+  interrupt_disable(timerIrqNum);  // Disable Timer at controller
+  aux_reg_write(timerControlAddr, 0);  // Disable Timer itself
+
+  if(userCallBack != NULL)
+    userCB = userCallBack;
+  aux_reg_write(timerLimitAddr, periodHz);  // Load Timer period
+
+  aux_reg_write(timerCountAddr, 0);  // Reset variables
+  tickCnt = 0;
+
+  if(isrFuncPtr != NULL) {  // Enable timer running with interrupt
+    interrupt_connect(timerIrqNum, isrFuncPtr);
+    aux_reg_write(timerControlAddr, ARC_TIMER_EN_INTR_BIT_FLAG |
+		  ARC_TIMER_NON_HALT_ONLY_BIT_FLAG);
+    interrupt_enable(timerIrqNum);
+  }
+  else {  // Timer runs without interrupt
+    aux_reg_write(timerControlAddr, ARC_TIMER_NON_HALT_ONLY_BIT_FLAG);
+  }
+
+  currState = RUNNING;
+  return SUCCESS;
+}
+
+
+// Method:  timerIsr
+//   It's the generic timer ISR.  Will call user call back here.
+
+inline void CurieTimer::timerIsr(void)
+{
+  unsigned int reg;
+
+  // Clear the interrupt pending bit.
+  reg = aux_reg_read(timerControlAddr) & ~ARC_TIMER_INTR_PENDING_BIT_FLAG;
+  aux_reg_write(timerControlAddr, reg);
+
+  tickCnt++;  // Account for the interrupt
+
+  if(userCB != NULL)  // Call user ISR if available
+    userCB();
+}
+
+