first commit

Author: facchinm

library.properties

@@ -0,0 +1,9 @@
+name=MKRMotorShield
+version=0.0.1
+author=Arduino
+maintainer=Arduino <[email protected]>
+sentence=Allows to use the MKR Motor Shield
+paragraph=Allows to use the MKR MotorShield
+category=I/o
+url=http://www.arduino.cc/en/Reference/
+architectures=samd

src/Battery.cpp

@@ -0,0 +1,23 @@
+#include "Battery.h"
+#include "Common.h"
+
+mc::Battery::Battery() {
+}
+
+int mc::Battery::getRaw() {
+  int ret;
+  getData(GET_RAW_ADC_BATTERY, (uint8_t*)&ret);
+  return ret;
+}
+
+int mc::Battery::getConverted() {
+  int ret;
+  getData(GET_CONVERTED_ADC_BATTERY, (uint8_t*)&ret);
+  return ret;
+}
+
+int mc::Battery::getFiltered() {
+  int ret;
+  getData(GET_FILTERED_ADC_BATTERY, (uint8_t*)&ret);
+  return ret;
+}

src/Battery.h

@@ -0,0 +1,12 @@
+#include "Arduino.h"
+
+namespace mc {
+
+class Battery {
+  public:
+    Battery();
+    int getRaw();
+    int getConverted();
+    int getFiltered();
+};
+}

src/Common.h

@@ -0,0 +1,50 @@
+enum Commands {
+  GET_VERSION = 0x01,
+  RESET,
+  SET_PWM_DUTY_CYCLE_SERVO,
+  SET_PWM_FREQUENCY_SERVO,
+  SET_PWM_DUTY_CYCLE_DC_MOTOR,
+  SET_PWM_FREQUENCY_DC_MOTOR,
+  GET_RAW_COUNT_ENCODER,
+  RESET_COUNT_ENCODER,
+  GET_OVERFLOW_UNDERFLOW_STATUS_ENCODER,
+  GET_COUNT_PER_SECOND_ENCODER,
+  SET_INTERRUPT_ON_COUNT_ENCODER,
+  SET_INTERRUPT_ON_VELOCITY_ENCODER,
+  GET_RAW_ADC_BATTERY,
+  GET_CONVERTED_ADC_BATTERY,
+  GET_FILTERED_ADC_BATTERY,
+  SET_PID_GAIN_CL_MOTOR,
+  RESET_PID_GAIN_CL_MOTOR,
+  SET_CONTROL_MODE_CL_MOTOR,
+  SET_POSITION_SETPOINT_CL_MOTOR,
+  SET_VELOCITY_SETPOINT_CL_MOTOR,
+  SET_MAX_ACCELERATION_CL_MOTOR,
+  SET_MAX_VELOCITY_CL_MOTOR,
+  SET_MIN_MAX_DUTY_CYCLE_CL_MOTOR,
+  PING,
+  GET_INTERNAL_TEMP,
+};
+
+enum IRQCause {
+  ENCODER_COUNTER_REACHED = 1,
+  ENCODER_VELOCITY_REACHED,
+};
+
+#define I2C_ADDRESS   0x66
+#define IRQ_PIN       6
+
+#define MOTOR_3_PIN_A 3
+#define MOTOR_3_PIN_B 2
+#define MOTOR_4_PIN_A 4
+#define MOTOR_4_PIN_B 5
+
+#define IN1 A6
+#define IN2 A1
+#define IN3 A5
+#define IN4 A2
+
+int getData(Commands cmd, uint8_t target, uint8_t* buf);
+void setData(Commands cmd, uint8_t target, int data);
+void setDataPIDGains(Commands cmd, uint8_t target, int16_t P, int16_t I, int16_t D);
+int getData(Commands cmd, uint8_t* buf);

src/DCMotor.cpp

@@ -0,0 +1,61 @@
+#include "DCMotor.h"
+#include "Common.h"
+
+namespace mc {
+static int next_instance = 0;
+
+DCMotor::DCMotor() {
+  instance = next_instance;
+  next_instance++;
+};
+
+void DCMotor::setDuty(int duty) {
+  setData(SET_PWM_DUTY_CYCLE_DC_MOTOR, instance, duty);
+}
+
+void DCMotor::setFrequency(int frequency) {
+  setData(SET_PWM_FREQUENCY_DC_MOTOR, instance, frequency);
+}
+
+}
+// D21 implementations
+
+namespace d21 {
+static int next_instance = 0;
+
+DCMotor::DCMotor() {
+  instance = next_instance;
+  next_instance++;
+  if (instance == 0) {
+    in1 = MOTOR_3_PIN_A; //2;
+    in2 = MOTOR_3_PIN_B; //3;
+  } else {
+    in1 = MOTOR_4_PIN_A; //5;
+    in2 = MOTOR_4_PIN_B; //4;
+  }
+  pinMode(in1, OUTPUT);
+  pinMode(in2, OUTPUT);
+};
+
+void DCMotor::setDuty(int duty) {
+  //setData(SET_PWM_DUTY_CYCLE_DC_MOTOR, instance, duty);
+  this->duty = duty;
+  if (duty == 0) {
+    analogWrite(in1, 0);
+    analogWrite(in2, 0);
+    return;
+  }
+  if (duty > 0) {
+    analogWrite(in1, 0);
+    analogWrite(in2, map(duty, 0, 100, 0, 255));
+  } else {
+    analogWrite(in2, 0);
+    analogWrite(in1, map(-duty, 0, 100, 0, 255));
+  }
+
+}
+
+void DCMotor::setFrequency(int frequency) {
+  //setData(SET_PWM_FREQUENCY_DC_MOTOR, instance, frequency);
+}
+}

src/DCMotor.h

@@ -0,0 +1,33 @@
+#ifndef __DCMOTOR_H__
+#define __DCMOTOR_H__
+
+#include "Arduino.h"
+
+namespace mc {
+
+class DCMotor {
+  public:
+    DCMotor();
+    void setDuty(int duty);
+    void setFrequency(int frequency);
+  private:
+    int instance;
+};
+}
+
+namespace d21 {
+
+class DCMotor {
+  public:
+    DCMotor();
+    void setDuty(int duty);
+    void setFrequency(int frequency);
+  private:
+    int instance;
+    int duty = 0;
+    int in1;
+    int in2;
+};
+}
+
+#endif

src/Encoder.cpp

@@ -0,0 +1,40 @@
+#include "Encoder.h"
+#include "Wire.h"
+#include "Common.h"
+
+static int next_instance = 0;
+
+mc::Encoder::Encoder() {
+  instance = next_instance;
+  next_instance++;
+};
+
+void mc::Encoder::resetCounter(long value) {
+  setData(RESET_COUNT_ENCODER, instance, value);
+}
+
+int mc::Encoder::getRawCount() {
+  int ret;
+  getData(GET_RAW_COUNT_ENCODER, instance, (uint8_t*)&ret);
+  return ret;
+}
+
+int mc::Encoder::getOverflowUnderflow() {
+  uint8_t ret[2];
+  getData(GET_OVERFLOW_UNDERFLOW_STATUS_ENCODER, instance, (uint8_t*)ret);
+  return ret[0] << 8 | ret[1];
+}
+
+int mc::Encoder::getCountPerSecond() {
+  int ret;
+  getData(GET_COUNT_PER_SECOND_ENCODER, instance, (uint8_t*)&ret);
+  return ret;
+}
+
+void mc::Encoder::setIrqOnCount(long value) {
+  setData(SET_INTERRUPT_ON_COUNT_ENCODER, instance, value);
+}
+
+void mc::Encoder::setIrqOnVelocity(long value, uint8_t margin) {
+  setData(SET_INTERRUPT_ON_VELOCITY_ENCODER, instance, (margin << 24 | value));
+}

src/Encoder.h

@@ -0,0 +1,22 @@
+#ifndef __ENCODER_H__
+#define __ENCODER_H__
+
+#include "Arduino.h"
+
+namespace mc {
+
+class Encoder {
+  public:
+    Encoder();
+    int getRawCount();
+    int getOverflowUnderflow();
+    int getCountPerSecond();
+    void resetCounter(long value);
+    void setIrqOnCount(long value);
+    void setIrqOnVelocity(long value, uint8_t margin = 2);
+  private:
+    int instance;
+};
+}
+
+#endif

src/MKRMotorShield.h

@@ -0,0 +1,8 @@
+#include <Wire.h>
+#include "Encoder.h"
+#include "Battery.h"
+#include "DCMotor.h"
+#include "ServoMotor.h"
+#include "MotorController.h"
+#include "Common.h"
+#include "PID.h"

src/MotorController.cpp

@@ -0,0 +1,23 @@
+#include "MotorController.h"
+#include "Common.h"
+
+String mc::MotorController::getFWVersion() {
+  char ret[5];
+  getData(GET_VERSION, (uint8_t*)ret);
+  ret[4] = '\0';
+  return String(ret);
+}
+
+void mc::MotorController::reboot() {
+  setData(RESET, 0, 0);
+}
+
+void mc::MotorController::ping() {
+  setData(PING, 0, 0);
+}
+
+float mc::MotorController::getTemperature() {
+  int ret;
+  getData(GET_INTERNAL_TEMP, (uint8_t*)&ret);
+  return (float)ret / 1000.0f;
+}