STSPIN32G4 driver

Author: Richard Unger

src/drivers/stspin32g4/README.md

@@ -0,0 +1,42 @@
+
+# SimpleFOC STSPIN32G4 Driver
+
+This driver initializes the PWM stage of the STSPIN32G4, and provides access to its configuration via I2C.
+
+:warning: in development!
+
+## Setup
+
+Since there are currently no standard boards for Arduino based on the STSPIN32G4 you will need a custom board definition, associated linker script and project setup to compile for your board. These topics are out of scope for this driver, but you can find a working example for the [FunQi STSPIN32G4 board](TODO link) [here](TODO link);
+
+Once you can compile for your board, and flash it with a "blinky" test sketch, then you're ready to try SimpleFOC and more complex code.
+
+## Usage
+
+Basic usage, as you can see it is very simple. Since the pins are all pre-defined due to internal connections, setup
+is easier than with the standard drivers. Here is an example for open loop mode:
+
+```c++
+#include <Arduino.h>
+#include "SimpleFOC.h"
+#include "SimpleFOCDrivers.h"
+#include "drivers/stspin32g4/STSPIN32G4.h"
+
+
+STSPIN32G4 driver = STSPIN32G4();
+BLDCMotor motor = BLDCMotor(7);
+
+void setup() {
+    driver.voltage_power_supply = 12.0f;
+    driver.init();
+    motor.voltage_limit = driver.voltage_limit / 2.0f;
+    motor.controller = MotionControlType::velocity_openloop;
+    motor.linkDriver(&driver);
+    motor.init();
+}
+
+void loop(){
+    motor.move(5.0f); // 5 rad/s open loop
+    delayMicroseconds(100); // STM32G4 is very fast, add a delay in open loop if we do nothing else
+}
+```

src/drivers/stspin32g4/STSPIN32G4.cpp

@@ -0,0 +1,176 @@
+
+#include "./STSPIN32G4.h"
+
+#ifdef _STM32_DEF_
+
+
+STSPIN32G4::STSPIN32G4() : BLDCDriver6PWM(STSPIN32G4_PIN_INUH, STSPIN32G4_PIN_INUL, STSPIN32G4_PIN_INVH, 
+                                          STSPIN32G4_PIN_INVL, STSPIN32G4_PIN_INWH, STSPIN32G4_PIN_INWL),
+                           _wire(STSPIN32G4_PIN_SDA, STSPIN32G4_PIN_SCL) {
+
+};
+
+
+
+STSPIN32G4::~STSPIN32G4(){
+    _wire.end();
+};
+
+
+
+int STSPIN32G4::init(){
+    // init pins
+    pinMode(STSPIN32G4_PIN_WAKE, OUTPUT);
+    pinMode(STSPIN32G4_PIN_READY, INPUT_PULLUP);
+    pinMode(STSPIN32G4_PIN_FAULT, INPUT_PULLUP);
+
+    // wake up
+    digitalWrite(STSPIN32G4_PIN_WAKE, HIGH);
+
+    // init I2C
+    _wire.begin();
+
+    // init PWM
+    return BLDCDriver6PWM::init();
+
+    // TODO init fault monitor
+};
+
+
+
+void STSPIN32G4::wake() {
+    digitalWrite(STSPIN32G4_PIN_WAKE, HIGH);
+};
+
+
+
+void STSPIN32G4::sleep() {
+    digitalWrite(STSPIN32G4_PIN_WAKE, LOW);
+    writeRegister(STSPIN32G4_REG_STBY, 0x01);
+};
+
+
+
+bool STSPIN32G4::isReady(){
+    return digitalRead(STSPIN32G4_PIN_READY)==HIGH;
+};
+
+
+
+bool STSPIN32G4::isFault(){
+    return digitalRead(STSPIN32G4_PIN_FAULT)==LOW;
+};
+
+
+
+STSPIN32G4Status STSPIN32G4::status(){
+    STSPIN32G4Status result;
+    result.reg = readRegister(STSPIN32G4_REG_STATUS);
+    return result;
+};
+
+
+
+void STSPIN32G4::lock(){
+    writeRegister(STSPIN32G4_REG_LOCK, 0x00);
+};
+
+
+
+void STSPIN32G4::unlock(){
+    writeRegister(STSPIN32G4_REG_LOCK, 0xF0);
+};
+
+
+
+STSPIN32G4NFault STSPIN32G4::getNFaultRegister(){
+    STSPIN32G4NFault result;
+    result.reg = readRegister(STSPIN32G4_REG_NFAULT);
+    return result;
+};
+
+
+
+STSPIN32G4Ready STSPIN32G4::getReadyRegister(){
+    STSPIN32G4Ready result;
+    result.reg = readRegister(STSPIN32G4_REG_READY);
+    return result;
+};
+
+
+
+STSPIN32G4Logic STSPIN32G4::getLogicRegister(){
+    STSPIN32G4Logic result;
+    result.reg = readRegister(STSPIN32G4_REG_LOGIC);
+    return result;
+};
+
+
+
+STSPIN32G4PowMng STSPIN32G4::getPowMngRegister(){
+    STSPIN32G4PowMng result;
+    result.reg = readRegister(STSPIN32G4_REG_POWMNG);
+    return result;
+};
+
+
+
+void STSPIN32G4::setNFaultRegister(STSPIN32G4NFault value){
+    writeRegister(STSPIN32G4_REG_NFAULT, value.reg);
+};
+
+
+
+void STSPIN32G4::setReadyRegister(STSPIN32G4Ready value){
+    writeRegister(STSPIN32G4_REG_READY, value.reg);
+};
+
+
+
+void STSPIN32G4::setLogicRegister(STSPIN32G4Logic value){
+    writeRegister(STSPIN32G4_REG_LOGIC, value.reg);
+};
+
+
+
+void STSPIN32G4::setPowMngRegister(STSPIN32G4PowMng value){
+    writeRegister(STSPIN32G4_REG_POWMNG, value.reg);
+};  
+
+
+
+void STSPIN32G4::resetRegisters(){
+    // write 0xFF to reset register
+    writeRegister(STSPIN32G4_REG_RESET, 0xFF);
+};
+
+
+
+void STSPIN32G4::clearFaults(){
+    // write 0xFF to clear faults
+    writeRegister(STSPIN32G4_REG_CLEAR, 0xFF);
+};
+
+
+
+uint8_t STSPIN32G4::readRegister(uint8_t reg){
+    uint8_t result = 0;
+    _wire.beginTransmission(STSPIN32G4_I2C_ADDR);
+    _wire.write(reg);
+    _wire.endTransmission(false);
+    _wire.requestFrom(STSPIN32G4_I2C_ADDR, 1);
+    result = _wire.read();
+    return result;
+};
+
+
+
+void STSPIN32G4::writeRegister(uint8_t reg, uint8_t val){
+    _wire.beginTransmission(STSPIN32G4_I2C_ADDR);
+    _wire.write(reg);
+    _wire.write(val);
+    _wire.endTransmission();
+};
+
+
+#endif

src/drivers/stspin32g4/STSPIN32G4.h

@@ -0,0 +1,148 @@
+
+#pragma once
+
+#include "Arduino.h"
+
+#ifdef _STM32_DEF_
+
+#include "Wire.h"
+#include "drivers/BLDCDriver6PWM.h"
+
+
+#define STSPIN32G4_PIN_INUL  PE8
+#define STSPIN32G4_PIN_INUH  PE9
+#define STSPIN32G4_PIN_INVL  PE10
+#define STSPIN32G4_PIN_INVH  PE11
+#define STSPIN32G4_PIN_INWL  PE12
+#define STSPIN32G4_PIN_INWH  PE13
+
+#define STSPIN32G4_PIN_WAKE  PE7
+#define STSPIN32G4_PIN_READY PE14
+#define STSPIN32G4_PIN_FAULT PE15
+
+#define STSPIN32G4_PIN_SDA   PC9
+#define STSPIN32G4_PIN_SCL   PC8
+
+#define STSPIN32G4_I2C_ADDR  0b1000111
+
+#define STSPIN32G4_REG_POWMNG 0x01
+#define STSPIN32G4_REG_LOGIC  0x02
+#define STSPIN32G4_REG_READY  0x07
+#define STSPIN32G4_REG_NFAULT 0x08
+#define STSPIN32G4_REG_CLEAR  0x19
+#define STSPIN32G4_REG_STBY   0x0A
+#define STSPIN32G4_REG_LOCK   0x0B
+#define STSPIN32G4_REG_RESET  0x0C
+#define STSPIN32G4_REG_STATUS 0x80
+
+
+
+
+
+union STSPIN32G4Status {
+    struct {
+        uint8_t vcc_uvlo:1;
+        uint8_t thsd:1;
+        uint8_t vds_p:1;
+        uint8_t reset:1;
+        uint8_t unused:3;
+        uint8_t lock:1;
+    };
+    uint8_t reg;
+};
+
+
+
+union STSPIN32G4NFault {
+    struct {
+        uint8_t vcc_uvlo_flt:1;
+        uint8_t thsd_flt:1;
+        uint8_t vds_p_flt:1;
+        uint8_t unused:5;
+    };
+    uint8_t reg;
+};
+
+
+union STSPIN32G4Ready {
+    struct {
+        uint8_t vcc_uvlo_rdy:1;
+        uint8_t thsd_rdy:1;
+        uint8_t unused:1;
+        uint8_t stby_rdy:1;
+        uint8_t unused2:4;
+    };
+    uint8_t reg;
+};
+
+
+
+union STSPIN32G4Logic {
+    struct {
+        uint8_t ilock:1;
+        uint8_t dtmin:1;
+        uint8_t vds_p_deg:2;
+        uint8_t unused:4;
+    };
+    uint8_t reg;
+};
+
+
+
+union STSPIN32G4PowMng {
+    struct {
+        uint8_t vcc_val:2;
+        uint8_t unused:2;
+        uint8_t stby_reg_en:1;
+        uint8_t vcc_dis:1;
+        uint8_t reg3v3_dis:1;
+        uint8_t unused2:1;
+    };
+    uint8_t reg;
+};
+
+
+
+
+
+
+
+
+
+
+
+class STSPIN32G4 : public BLDCDriver6PWM {
+public:
+    STSPIN32G4();
+    ~STSPIN32G4();
+
+    int init() override;
+
+    void wake();
+    void sleep();
+    bool isReady();
+    bool isFault();
+
+    STSPIN32G4Status status();
+    void lock();
+    void unlock();
+    STSPIN32G4NFault getNFaultRegister();
+    STSPIN32G4Ready getReadyRegister();
+    STSPIN32G4Logic getLogicRegister();
+    STSPIN32G4PowMng getPowMngRegister();
+    void setNFaultRegister(STSPIN32G4NFault value);
+    void setReadyRegister(STSPIN32G4Ready value);
+    void setLogicRegister(STSPIN32G4Logic value);
+    void setPowMngRegister(STSPIN32G4PowMng value);    
+    void resetRegisters();
+    void clearFaults();
+
+protected:
+    uint8_t readRegister(uint8_t reg);
+    void writeRegister(uint8_t reg, uint8_t val);
+
+    TwoWire _wire;
+};
+
+
+#endif