update

chip/basic/basic_h/pin.cpp

@@ -0,0 +1,237 @@
+#include "pin.hpp"
+namespace iflytop {
+const char* pinname(Pin_t pin) {
+  switch (pin) {
+    case PinNull:
+      return "PinNull";
+    case PA0:
+      return "PA0";
+    case PA1:
+      return "PA1";
+    case PA2:
+      return "PA2";
+    case PA3:
+      return "PA3";
+    case PA4:
+      return "PA4";
+    case PA5:
+      return "PA5";
+    case PA6:
+      return "PA6";
+    case PA7:
+      return "PA7";
+    case PA8:
+      return "PA8";
+    case PA9:
+      return "PA9";
+    case PA10:
+      return "PA10";
+    case PA11:
+      return "PA11";
+    case PA12:
+      return "PA12";
+    case PA13:
+      return "PA13";
+    case PA14:
+      return "PA14";
+    case PA15:
+      return "PA15";
+    case PB0:
+      return "PB0";
+    case PB1:
+      return "PB1";
+    case PB2:
+      return "PB2";
+    case PB3:
+      return "PB3";
+    case PB4:
+      return "PB4";
+    case PB5:
+      return "PB5";
+    case PB6:
+      return "PB6";
+    case PB7:
+      return "PB7";
+    case PB8:
+      return "PB8";
+    case PB9:
+      return "PB9";
+    case PB10:
+      return "PB10";
+    case PB11:
+      return "PB11";
+    case PB12:
+      return "PB12";
+    case PB13:
+      return "PB13";
+    case PB14:
+      return "PB14";
+    case PB15:
+      return "PB15";
+    case PC0:
+      return "PC0";
+    case PC1:
+      return "PC1";
+    case PC2:
+      return "PC2";
+    case PC3:
+      return "PC3";
+    case PC4:
+      return "PC4";
+    case PC5:
+      return "PC5";
+    case PC6:
+      return "PC6";
+    case PC7:
+      return "PC7";
+    case PC8:
+      return "PC8";
+    case PC9:
+      return "PC9";
+    case PC10:
+      return "PC10";
+    case PC11:
+      return "PC11";
+    case PC12:
+      return "PC12";
+    case PC13:
+      return "PC13";
+    case PC14:
+      return "PC14";
+    case PC15:
+      return "PC15";
+    case PD0:
+      return "PD0";
+    case PD1:
+      return "PD1";
+    case PD2:
+      return "PD2";
+    case PD3:
+      return "PD3";
+    case PD4:
+      return "PD4";
+    case PD5:
+      return "PD5";
+    case PD6:
+      return "PD6";
+    case PD7:
+      return "PD7";
+    case PD8:
+      return "PD8";
+    case PD9:
+      return "PD9";
+    case PD10:
+      return "PD10";
+    case PD11:
+      return "PD11";
+    case PD12:
+      return "PD12";
+    case PD13:
+      return "PD13";
+    case PD14:
+      return "PD14";
+    case PD15:
+      return "PD15";
+    case PE0:
+      return "PE0";
+    case PE1:
+      return "PE1";
+    case PE2:
+      return "PE2";
+    case PE3:
+      return "PE3";
+    case PE4:
+      return "PE4";
+    case PE5:
+      return "PE5";
+    case PE6:
+      return "PE6";
+    case PE7:
+      return "PE7";
+    case PE8:
+      return "PE8";
+    case PE9:
+      return "PE9";
+    case PE10:
+      return "PE10";
+    case PE11:
+      return "PE11";
+    case PE12:
+      return "PE12";
+    case PE13:
+      return "PE13";
+    case PE14:
+      return "PE14";
+    case PE15:
+      return "PE15";
+    case PF0:
+      return "PF0";
+    case PF1:
+      return "PF1";
+    case PF2:
+      return "PF2";
+    case PF3:
+      return "PF3";
+    case PF4:
+      return "PF4";
+    case PF5:
+      return "PF5";
+    case PF6:
+      return "PF6";
+    case PF7:
+      return "PF7";
+    case PF8:
+      return "PF8";
+    case PF9:
+      return "PF9";
+    case PF10:
+      return "PF10";
+    case PF11:
+      return "PF11";
+    case PF12:
+      return "PF12";
+    case PF13:
+      return "PF13";
+    case PF14:
+      return "PF14";
+    case PF15:
+      return "PF15";
+    case PG0:
+      return "PG0";
+    case PG1:
+      return "PG1";
+    case PG2:
+      return "PG2";
+    case PG3:
+      return "PG3";
+    case PG4:
+      return "PG4";
+    case PG5:
+      return "PG5";
+    case PG6:
+      return "PG6";
+    case PG7:
+      return "PG7";
+    case PG8:
+      return "PG8";
+    case PG9:
+      return "PG9";
+    case PG10:
+      return "PG10";
+    case PG11:
+      return "PG11";
+    case PG12:
+      return "PG12";
+    case PG13:
+      return "PG13";
+    case PG14:
+      return "PG14";
+    case PG15:
+      return "PG15";
+    default:
+      break;
+  }
+  return "UNKNOWN_PIN";
+};
+
+}  // namespace iflytop

chip/basic/basic_h/pin.hpp

@@ -115,3 +115,7 @@ typedef enum {
   PG14,
   PG15,
 } Pin_t;
+
+namespace iflytop {
+ const char* pinname(Pin_t pin);
+}

components/sensors/mcp41xxx/mcp41xxx.cpp

@@ -14,28 +14,43 @@ using namespace std;
 void MCP41XXX::initialize(hardware_config_t* hardwareconfig) {  //
   m_hardwareconfig = *hardwareconfig;
   ZASSERT(m_hardwareconfig.spihandler);
+  ZASSERT(m_hardwareconfig.mark);
 
-  if (m_hardwareconfig.ncspin != NULL) {
+  ZLOGI(TAG, " %s initialize...", m_hardwareconfig.mark)
+
+  if (m_hardwareconfig.ncspin != PinNull) {
+    ZLOGI(TAG, "    init ncspin %s", pinname(m_hardwareconfig.ncspin));
     m_ncspin.initAsOutput(m_hardwareconfig.ncspin, ZGPIO::kMode_nopull, false, true);
   }
 
-  if (m_hardwareconfig.nshdn != NULL) {
+  if (m_hardwareconfig.nshdn != PinNull) {
+    ZLOGI(TAG, "    init nshdn %s", pinname(m_hardwareconfig.nshdn));
     m_nshdn.initAsOutput(m_hardwareconfig.nshdn, ZGPIO::kMode_nopull, false, true);
   }
 
-  if (m_hardwareconfig.nrs != NULL) {
+  if (m_hardwareconfig.nrs != PinNull) {
+    ZLOGI(TAG, "    init nrs %s", pinname(m_hardwareconfig.nrs));
     m_nrs.initAsOutput(m_hardwareconfig.nrs, ZGPIO::kMode_nopull, false, true);
   }
 }
 
-void MCP41XXX::setPotentiometerValue_0(uint8_t value) { sendValue(POTENTIOMETER_ONE, value); }
-void MCP41XXX::setPotentiometerValue_1(uint8_t value) { sendValue(POTENTIOMETER_TWO, value); }
-void MCP41XXX::setPotentiometerValue_both(uint8_t value) { sendValue(POTENTIOMETER_BOTH, value); }
+void MCP41XXX::setPotentiometerValue_0(uint8_t value) {
+  ZLOGI(TAG, " %s set ohm0 %d", m_hardwareconfig.mark, value);
+  sendValue(POTENTIOMETER_ONE, value);
+}
+void MCP41XXX::setPotentiometerValue_1(uint8_t value) {
+  ZLOGI(TAG, " %s set ohm1 %d", m_hardwareconfig.mark, value);
+  sendValue(POTENTIOMETER_TWO, value);
+}
+void MCP41XXX::setPotentiometerValue_both(uint8_t value) {
+  ZLOGI(TAG, " %s set ohm0&1 %d", m_hardwareconfig.mark, value);
+  sendValue(POTENTIOMETER_BOTH, value);
+}
 void MCP41XXX::spi_send(uint8_t* data, int32_t len) {
   if (m_ncspin.isInit()) m_ncspin.setState(false);
-  zos_delay(3);
+  zos_early_delayus(10);
   HAL_SPI_Transmit(m_hardwareconfig.spihandler, data, len, HAL_MAX_DELAY);
-  zos_delay(3);
+  zos_early_delayus(10);
   if (m_ncspin.isInit()) m_ncspin.setState(true);
 }
 
@@ -56,10 +71,13 @@ void MCP41XXX::sendValue(Potentiometer num, uint8_t value) {
       break;
   }
   MCP41xxx_value[1] = value;
+  // MCP41xxx_value[0]= 0xAA;
+  // MCP41xxx_value[1]= 0xAA;
   spi_send(MCP41xxx_value, 2);
 }
 
 void MCP41XXX::potentiometerShutdonw(Potentiometer num, bool shutdown) {
+  ZLOGI(TAG, " %s potentiometerShutdonw %d %d", m_hardwareconfig.mark, num, shutdown);
   uint8_t MCP41xxx_off[2];
   switch ((uint8_t)num) {
     case POTENTIOMETER_ONE:

components/sensors/mcp41xxx/mcp41xxx.hpp

@@ -13,6 +13,7 @@ class MCP41XXX {
     Pin_t              ncspin;
     Pin_t              nshdn;
     Pin_t              nrs;
+    const char*        mark;
   } hardware_config_t;
 
  private: