DCCTimerGiga.cpp

@@ -43,19 +43,14 @@
 
 INTERRUPT_CALLBACK interruptHandler=0;
 
-#ifndef DCC_EX_TIMER
+//HardwareTimer*  timer = NULL;
-#if defined(TIM6)
+//HardwareTimer*  timerAux = NULL;
-#define DCC_EX_TIMER TIM6
+HardwareTimer timer(TIM3);
-#elif defined(TIM7)
+HardwareTimer timerAux(TIM2);
-#define DCC_EX_TIMER TIM7
+
-#elif defined(TIM12)
+static bool tim2ModeHA = false;
-#define DCC_EX_TIMER TIM12
+static bool tim3ModeHA = false;
-#else
-#warning This Giga variant does not have Timers 1,8 or 11!!
-#endif
-#endif // ifndef DCC_EX_TIMER
 
-HardwareTimer dcctimer(TIM8);
 void DCCTimer_Handler() __attribute__((interrupt));
 
 void DCCTimer_Handler() {
@@ -64,38 +59,66 @@ void DCCTimer_Handler() {
 
 void DCCTimer::begin(INTERRUPT_CALLBACK callback) {
   interruptHandler=callback;
-  noInterrupts();
+    noInterrupts();
     
-  dcctimer.pause();
+ // adc_set_sample_rate(ADC_SAMPLETIME_480CYCLES);
-  dcctimer.setPrescaleFactor(1);
+    timer.pause();
-//  timer.setOverflow(CLOCK_CYCLES * 2);
+    timerAux.pause();
-  dcctimer.setOverflow(DCC_SIGNAL_TIME, MICROSEC_FORMAT);
+    timer.setPrescaleFactor(1);
-  // dcctimer.attachInterrupt(Timer11_Handler);
+    timer.setOverflow(DCC_SIGNAL_TIME, MICROSEC_FORMAT);
-  dcctimer.attachInterrupt(DCCTimer_Handler);
+    timer.attachInterrupt(DCCTimer_Handler);
-  dcctimer.setInterruptPriority(0, 0); // Set highest preemptive priority!
+    timer.refresh();
-  dcctimer.refresh();
+    timerAux.setPrescaleFactor(1);
-  dcctimer.resume();
+    timerAux.setOverflow(DCC_SIGNAL_TIME, MICROSEC_FORMAT);
+    timerAux.refresh();
 
-  interrupts();
+    timer.resume();
+    timerAux.resume();
+
+    interrupts();
 }
 
 bool DCCTimer::isPWMPin(byte pin) {
-  //TODO: STM32 whilst this call to digitalPinHasPWM will reveal which pins can do PWM,
+    switch (pin) {
-  //      there's no support yet for High Accuracy, so for now return false
+     case 12:
-  //  return digitalPinHasPWM(pin);
+       return true;
-  (void) pin;
+     case 13:
-  return false;
+       return true;
+     default:
+       return false;
+    }
 }
 
 void DCCTimer::setPWM(byte pin, bool high) {
-    // TODO: High Accuracy mode is not supported as yet, and may never need to be
+    switch (pin) {
-    (void) pin;
+     case 12:
-    (void) high;
+       if (!tim3ModeHA) {
-    return;
+         timerAux.setMode(1, TIMER_OUTPUT_COMPARE_INACTIVE, 12);
+         tim3ModeHA = true;
+       }
+       if (high) 
+         TIM3->CCMR1 = (TIM3->CCMR1 & ~TIM_CCMR1_OC1M_Msk) | TIM_CCMR1_OC1M_0;
+       else
+         TIM3->CCMR1 = (TIM3->CCMR1 & ~TIM_CCMR1_OC1M_Msk) | TIM_CCMR1_OC1M_1;
+       break;
+     case 13:
+       if (!tim2ModeHA) {
+         timer.setMode(1, TIMER_OUTPUT_COMPARE_INACTIVE, 13);
+         tim2ModeHA = true;
+       }
+       if (high) 
+         TIM2->CCMR1 = (TIM2->CCMR1 & ~TIM_CCMR1_OC1M_Msk) | TIM_CCMR1_OC1M_0;
+       else
+         TIM2->CCMR1 = (TIM2->CCMR1 & ~TIM_CCMR1_OC1M_Msk) | TIM_CCMR1_OC1M_1;
+       break;
+   }
  }
 
 void DCCTimer::clearPWM() {
-  return;
+  timer.setMode(1, TIMER_OUTPUT_COMPARE_INACTIVE, NC);
+  tim2ModeHA = false;
+  timerAux.setMode(1, TIMER_OUTPUT_COMPARE_INACTIVE, NC);  
+  tim3ModeHA = false;
 }
 
 void   DCCTimer::getSimulatedMacAddress(byte mac[6]) {
@@ -138,7 +161,6 @@ void DCCTimer::reset() {
   //Watchdog::start(500);
   
   //while(true) {};
-  return;
 }
 
 int * ADCee::analogvals = NULL;
@@ -148,15 +170,9 @@ int16_t ADCee::ADCmax()
     return 1023;
 }
 
-AdvancedADC adc;
+AdvancedADC adc(A0, A1);
-pin_size_t active_pins[] = {A0, A1, A2, A3};
-pin_size_t active_pinsB[] = {A4, A5, A6, A7};
-int num_active_pins = 4;
-const int samples_per_round = 512;
 int ADCee::init(uint8_t pin) {
-  adc.stop();
+  adc.begin(AN_RESOLUTION_10, 16000, 1, 512);
-  if (pin >= A0 && pin <= A3) adc.begin(AN_RESOLUTION_10, 16000, 1, samples_per_round, num_active_pins, active_pins);
-  else if (pin >= A4 && pin <= A7) adc.begin(AN_RESOLUTION_10, 16000, 1, samples_per_round, num_active_pins, active_pinsB);
   return 123;
 }
 
@@ -164,16 +180,13 @@ int ADCee::init(uint8_t pin) {
  * Read function ADCee::read(pin) to get value instead of analogRead(pin)
  */
 int ADCee::read(uint8_t pin, bool fromISR) {
-  int tmpPin = 0;
-  if (pin >= A0 && pin <= A3) tmpPin = (pin - A0);
-  else if (pin >= A4 && pin <= A7) tmpPin = ((pin - A0) - 4);
   static SampleBuffer buf = adc.read();
   int retVal = -123;
   if (adc.available()) {
     buf.release();
     buf = adc.read();
   }
-  return (buf[tmpPin]);
+  return (buf[pin - A0]);
 }
 
 /*

I2CManager_Wire.h

@@ -35,7 +35,11 @@
 #define WIRE_HAS_TIMEOUT
 #endif
 
-
+#if defined(GIGA_I2C_1)
+#define DCCEX_WIRE Wire1
+#else
+#define DCCEX_WIRE Wire
+#endif
 
 
 
@@ -43,9 +47,9 @@
  *  Initialise I2C interface software
  ***************************************************************************/
 void I2CManagerClass::_initialise() {
-  Wire.begin();
+  DCCEX_WIRE.begin();
 #if defined(WIRE_HAS_TIMEOUT) 
-  Wire.setWireTimeout(_timeout, true);
+  DCCEX_WIRE.setWireTimeout(_timeout, true);
 #endif
 }
 
@@ -54,7 +58,7 @@ void I2CManagerClass::_initialise() {
  *   on Arduino.  Mega4809 supports 1000000 (Fast+) too.
  ***************************************************************************/
 void I2CManagerClass::_setClock(unsigned long i2cClockSpeed) {
-  Wire.setClock(i2cClockSpeed);
+  DCCEX_WIRE.setClock(i2cClockSpeed);
 }
 
 /***************************************************************************
@@ -65,7 +69,7 @@ void I2CManagerClass::_setClock(unsigned long i2cClockSpeed) {
 void I2CManagerClass::setTimeout(unsigned long value) {
   _timeout = value;
 #if defined(WIRE_HAS_TIMEOUT) 
-  Wire.setWireTimeout(value, true);
+  DCCEX_WIRE.setWireTimeout(value, true);
 #endif
 }
 
@@ -78,7 +82,7 @@ static uint8_t muxSelect(I2CAddress address) {
   I2CMux muxNo = address.muxNumber();
   I2CSubBus subBus = address.subBus();
   if (muxNo != I2CMux_None) {
-    Wire.beginTransmission(I2C_MUX_BASE_ADDRESS+muxNo); 
+    DCCEX_WIRE.beginTransmission(I2C_MUX_BASE_ADDRESS+muxNo); 
     uint8_t data =  (subBus == SubBus_All) ? 0xff :
                     (subBus == SubBus_None) ? 0x00 :
 #if defined(I2CMUX_PCA9547)
@@ -90,8 +94,8 @@ static uint8_t muxSelect(I2CAddress address) {
                     // with a bit set for the subBus to be enabled
                     1 << subBus;
 #endif
-    Wire.write(&data, 1);
+    DCCEX_WIRE.write(&data, 1);
-    return Wire.endTransmission(true);  // have to release I2C bus for it to work
+    return DCCEX_WIRE.endTransmission(true);  // have to release I2C bus for it to work
   }
   return I2C_STATUS_OK;
 }
@@ -114,9 +118,9 @@ uint8_t I2CManagerClass::write(I2CAddress address, const uint8_t buffer[], uint8
 #endif
     // Only send new transaction if address is non-zero.
     if (muxStatus == I2C_STATUS_OK && address != 0) {
-      Wire.beginTransmission(address);
+      DCCEX_WIRE.beginTransmission(address);
-      if (size > 0) Wire.write(buffer, size);
+      if (size > 0) DCCEX_WIRE.write(buffer, size);
-      status = Wire.endTransmission();
+      status = DCCEX_WIRE.endTransmission();
     }
 #ifdef I2C_EXTENDED_ADDRESS
     // Deselect MUX if there's more than one MUX present, to avoid having multiple ones selected
@@ -165,25 +169,25 @@ uint8_t I2CManagerClass::read(I2CAddress address, uint8_t readBuffer[], uint8_t
     // Only start new transaction if address is non-zero.
     if (muxStatus == I2C_STATUS_OK && address != 0) {
       if (writeSize > 0) {
-        Wire.beginTransmission(address);
+        DCCEX_WIRE.beginTransmission(address);
-        Wire.write(writeBuffer, writeSize);
+        DCCEX_WIRE.write(writeBuffer, writeSize);
-        status = Wire.endTransmission(false); // Don't free bus yet
+        status = DCCEX_WIRE.endTransmission(false); // Don't free bus yet
       }
       if (status == I2C_STATUS_OK) {
 #ifdef WIRE_HAS_TIMEOUT
-        Wire.clearWireTimeoutFlag();
+        DCCEX_WIRE.clearWireTimeoutFlag();
-        Wire.requestFrom(address, (size_t)readSize);
+        DCCEX_WIRE.requestFrom(address, (size_t)readSize);
-        if (!Wire.getWireTimeoutFlag()) {
+        if (!DCCEX_WIRE.getWireTimeoutFlag()) {
-          while (Wire.available() && nBytes < readSize) 
+          while (DCCEX_WIRE.available() && nBytes < readSize) 
-            readBuffer[nBytes++] = Wire.read();
+            readBuffer[nBytes++] = DCCEX_WIRE.read();
           if (nBytes < readSize) status = I2C_STATUS_TRUNCATED;
         } else {
           status = I2C_STATUS_TIMEOUT;
         }
 #else
-        Wire.requestFrom(address, (size_t)readSize);
+        DCCEX_WIRE.requestFrom(address, (size_t)readSize);
-          while (Wire.available() && nBytes < readSize) 
+          while (DCCEX_WIRE.available() && nBytes < readSize) 
-            readBuffer[nBytes++] = Wire.read();
+            readBuffer[nBytes++] = DCCEX_WIRE.read();
           if (nBytes < readSize) status = I2C_STATUS_TRUNCATED;
 #endif
       }

defines.h

@@ -161,6 +161,14 @@
   //#endif
   #define SDA I2C_SDA
   #define SCL I2C_SCL
+  #define DCC_EX_TIMER
+  // these don't work...
+  //extern const uint16_t PROGMEM port_to_input_PGM[];
+  //extern const uint16_t PROGMEM port_to_output_PGM[];
+  //extern const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[];
+  //#define digitalPinToBitMask(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM + (P) ) )
+  //#define portOutputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_output_PGM + (P))) )
+  //#define portInputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_input_PGM + (P))) )
   
 /* TODO when ready 
 #elif defined(ARDUINO_ARCH_RP2040)