Restructure core bindings

cores/arduino/Arduino.h

@@ -86,8 +86,11 @@ typedef struct _PinDescription
   PinName name;
   mbed::InterruptIn* irq;
   mbed::PwmOut* pwm;
+  gpio_t* gpio;
 } PinDescription ;
 
+int PinNameToIndex(PinName P);
+
 /* Pins table to be instantiated into variant.cpp */
 extern PinDescription g_APinDescription[];
 

cores/arduino/Interrupts.cpp

@@ -19,44 +19,19 @@
 #include "Arduino.h"
 
 #ifdef digitalPinToInterruptObj
-static mbed::InterruptIn* PinNameToInterruptObj(PinName P) {
-  // reverse search for pinName in g_APinDescription[P].name fields
-  for (pin_size_t i=0; i < PINS_COUNT; i++) {
-    if (g_APinDescription[i].name == P) {
-      return g_APinDescription[i].irq;
-    }
-  }
-  return NULL;
-}
-#endif
 
 void detachInterrupt(PinName interruptNum) {
-#ifdef digitalPinToInterruptObj
-  if (PinNameToInterruptObj(interruptNum) != NULL) {
-    delete PinNameToInterruptObj(interruptNum);
-  }
-#endif
+  detachInterrupt(PinNameToIndex(interruptNum));
 }
 
 void detachInterrupt(pin_size_t interruptNum) {
-#ifdef digitalPinToInterruptObj
   if (digitalPinToInterruptObj(interruptNum) != NULL) {
     delete digitalPinToInterruptObj(interruptNum);
   }
-#endif
 }
 
 void attachInterruptParam(PinName interruptNum, voidFuncPtrParam func, PinStatus mode, void* param) {
-  detachInterrupt(interruptNum);
-  mbed::InterruptIn* irq = new mbed::InterruptIn(interruptNum);
-  if (mode == FALLING) {
-    irq->fall(mbed::callback(func, param));
-  } else {
-    irq->rise(mbed::callback(func, param));
-  }
-#ifdef digitalPinToInterruptObj
-  digitalPinToInterruptObj(interruptNum) = irq;
-#endif
+  attachInterruptParam(PinNameToIndex(interruptNum), func, mode, param);
 }
 
 void attachInterrupt(PinName interruptNum, voidFuncPtr func, PinStatus mode) {
@@ -71,11 +46,15 @@ void attachInterruptParam(pin_size_t interruptNum, voidFuncPtrParam func, PinSta
   } else {
     irq->rise(mbed::callback(func, param));
   }
-#ifdef digitalPinToInterruptObj
   digitalPinToInterruptObj(interruptNum) = irq;
-#endif
 }
 
 void attachInterrupt(pin_size_t interruptNum, voidFuncPtr func, PinStatus mode) {
   attachInterruptParam(interruptNum, (voidFuncPtrParam)func, mode, NULL);
-}
+}
+
+#else
+
+#warning "Arduino style interrupts can only be used with boards defining an Arduino pinmap"
+
+#endif

cores/arduino/macros.h

@@ -23,25 +23,28 @@
 #pragma once
 #ifdef USE_ARDUINO_PINOUT
 
-#define analogPinToPinName(P)			(P < A0 ? g_APinDescription[P+A0].name : g_APinDescription[P].name)
-#define digitalPinToPinName(P)			(g_APinDescription[P].name)
-#define digitalPinToInterrupt(P)		(P)
-#define digitalPinToInterruptObj(P)		(g_APinDescription[P].irq)
-#define digitalPinToPwmObj(P)		    (g_APinDescription[P].pwm)
+#define analogPinToPinName(P)       (P < A0 ? g_APinDescription[P+A0].name : g_APinDescription[P].name)
+#define digitalPinToPinName(P)      (g_APinDescription[P].name)
+#define digitalPinToInterruptObj(P) (g_APinDescription[P].irq)
+#define digitalPinToPwm(P)          (g_APinDescription[P].pwm)
+#define digitalPinToGpio(P)         (g_APinDescription[P].gpio)
+
+// this is needed for backwards compatibility
+#define digitalPinToInterrupt(P)    (P)
 
 #else
 
-#define analogPinToPinName(P)			((PinName)P)
-#define digitalPinToPinName(P)			((PinName)P)
-#define digitalPinToInterrupt(P) 		((PinName)P)
+#define analogPinToPinName(P)       ((PinName)P)
+#define digitalPinToPinName(P)      ((PinName)P)
+#define digitalPinToInterrupt(P)    ((PinName)P)
 
 #endif
 
-#define REDIRECT_STDOUT_TO(stream) 			namespace mbed {										\
-											FileHandle *mbed_override_console(int fd) { 			\
-												return &stream;										\
-											}														\
-											FileHandle *mbed_target_override_console(int fd) { 		\
-												return &stream;										\
-											}														\
-											}
+#define REDIRECT_STDOUT_TO(stream)          namespace mbed {                                        \
+                                            FileHandle *mbed_override_console(int fd) {             \
+                                                return &stream;                                     \
+                                            }                                                       \
+                                            FileHandle *mbed_target_override_console(int fd) {      \
+                                                return &stream;                                     \
+                                            }                                                       \
+                                            }

cores/arduino/pinToIndex.cpp

@@ -0,0 +1,10 @@
+#include "Arduino.h"
+
+inline int PinNameToIndex(PinName P) {
+  for (pin_size_t i=0; i < PINS_COUNT; i++) {
+    if (g_APinDescription[i].name == P) {
+      return i;
+    }
+  }
+  return NOT_A_PIN;
+}

cores/arduino/wiring_analog.cpp

@@ -26,69 +26,45 @@
 static int write_resolution = 8;
 static int read_resolution = 10;
 
-#ifdef digitalPinToPwmObj
-static mbed::PwmOut* PinNameToPwmObj(PinName P) {
-  // reverse search for pinName in g_APinDescription[P].name fields
-  for (pin_size_t i=0; i < PINS_COUNT; i++) {
-    if (g_APinDescription[i].name == P) {
-      return g_APinDescription[i].pwm;
-    }
-  }
-  return NULL;
-}
-#endif
+#ifdef digitalPinToPwm
 
 void analogWrite(PinName pin, int val)
 {
-  float percent = (float)val/(float)(1 << write_resolution);
-#ifdef digitalPinToPwmObj
-  mbed::PwmOut* pwm = PinNameToPwmObj(pin);
-  if (pwm == NULL) {
-    pwm = new mbed::PwmOut(pin);
-    digitalPinToPwmObj(pin) = pwm;
-    pwm->period_ms(2); //500Hz
-  }
-#else
-  // attention: this leaks badly
-  mbed::PwmOut* pwm = new mbed::PwmOut(digitalPinToPinName(pin));
-#endif
-  pwm->write(percent);
+  analogWrite(PinNameToIndex(pin), val);
 }
 
 void analogWrite(pin_size_t pin, int val)
 {
   float percent = (float)val/(float)(1 << write_resolution);
-#ifdef digitalPinToPwmObj
-  mbed::PwmOut* pwm = digitalPinToPwmObj(pin);
+  mbed::PwmOut* pwm = digitalPinToPwm(pin);
   if (pwm == NULL) {
     pwm = new mbed::PwmOut(digitalPinToPinName(pin));
-    digitalPinToPwmObj(pin) = pwm;
+    digitalPinToPwm(pin) = pwm;
     pwm->period_ms(2); //500Hz
   }
   pwm->write(percent);
-#endif
 }
 
 void analogWriteResolution(int bits)
 {
   write_resolution = bits;
 }
 
+#else
+
+#warning "Arduino style analogWrite can only be used with boards defining an Arduino pinmap"
+
+#endif //digitalPinToPwm
+
 int analogRead(PinName pin)
 {
   int multiply_factor = 1;
-#ifdef ANALOG_BUG_MBED
-  multiply_factor = 4;
-#endif
   return (mbed::AnalogIn(pin).read_u16() >> (16 - read_resolution)) * multiply_factor;
 }
 
 int analogRead(pin_size_t pin)
 {
   int multiply_factor = 1;
-#ifdef ANALOG_BUG_MBED
-  multiply_factor = 4;
-#endif
   return (mbed::AnalogIn(analogPinToPinName(pin)).read_u16() >> (16 - read_resolution)) * multiply_factor;
 }
 

cores/arduino/wiring_digital.cpp

@@ -23,58 +23,84 @@
 #include "Arduino.h"
 #include "pins_arduino.h"
 
+#ifdef digitalPinToGpio
+
 void pinMode(PinName pin, PinMode mode)
 {
-  switch (mode) {
-    case INPUT:
-      mbed::DigitalIn(pin, PullNone);
-      break;
-    case OUTPUT:
-      mbed::DigitalOut(pin, 0);
-      break;
-    case INPUT_PULLUP:
-      mbed::DigitalIn(pin, PullUp);
-      break;
-    case INPUT_PULLDOWN:
-      mbed::DigitalIn(pin, PullDown);
-      break;
-  }
+  pinMode(PinNameToIndex(pin), mode);
 }
 
 void pinMode(pin_size_t pin, PinMode mode)
 {
+  gpio_t* gpio = digitalPinToGpio(pin);
+  if (gpio == NULL) {
+    gpio = new gpio_t();
+    digitalPinToGpio(pin) = gpio;
+  }
+
   switch (mode) {
     case INPUT:
-      mbed::DigitalIn(digitalPinToPinName(pin), PullNone);
+      gpio_init_in_ex(gpio, digitalPinToPinName(pin), PullNone);
       break;
     case OUTPUT:
-      mbed::DigitalOut(digitalPinToPinName(pin));
+      gpio_init_out(gpio, digitalPinToPinName(pin));
       break;
     case INPUT_PULLUP:
-      mbed::DigitalIn(digitalPinToPinName(pin), PullUp);
+      gpio_init_in_ex(gpio, digitalPinToPinName(pin), PullUp);
       break;
     case INPUT_PULLDOWN:
-      mbed::DigitalIn(digitalPinToPinName(pin), PullDown);
+      gpio_init_in_ex(gpio, digitalPinToPinName(pin), PullDown);
       break;
   }
 }
 
 void digitalWrite(PinName pin, PinStatus val)
 {
-  mbed::DigitalOut(pin).write((int)val);
+  digitalWrite(PinNameToIndex(pin), val);
 }
 
 void digitalWrite(pin_size_t pin, PinStatus val)
 {
-	mbed::DigitalOut(digitalPinToPinName(pin)).write((int)val);
+  gpio_write(digitalPinToGpio(pin), (int)val);
+}
+
+PinStatus digitalRead(PinName pin)
+{
+  return (PinStatus)digitalRead(PinNameToIndex(pin));
+}
+
+PinStatus digitalRead(pin_size_t pin)
+{
+  return (PinStatus)gpio_read(digitalPinToGpio(pin));
+}
+
+#else
+
+void pinMode(PinName pin, PinMode mode) {
+}
+
+void pinMode(pin_size_t pin, PinMode mode) {
+  return pinMode((PinName)pin, mode);
 }
 
 PinStatus digitalRead(PinName pin)
 {
+  #warning "digitalRead always applies default pull"
   return (PinStatus)mbed::DigitalIn(pin).read();
 }
 
 PinStatus digitalRead(pin_size_t pin)
 {
-	return (PinStatus)mbed::DigitalIn(digitalPinToPinName(pin)).read();
-}
+  return digitalRead((PinName)pin);
+}
+
+void digitalWrite(PinName pin, PinStatus val)
+{
+  mbed::DigitalOut(pin, (int)val);
+}
+
+void digitalWrite(pin_size_t pin, PinStatus val) {
+  digitalWrite((PinName)pin, val);
+}
+
+#endif // digitalPinToGpio