working MCP4725

Nanpy/BME280Class.cpp

@@ -0,0 +1,49 @@
+#include "cfg.h"
+
+#if USE_BME280
+
+#include <Arduino.h>
+#include <Adafruit_BME280.h>
+#include "BME280Class.h"
+#include <stdlib.h>
+
+const char *nanpy::BME280Class::get_firmware_id()
+{
+    return "BME280";
+}
+
+void nanpy::BME280Class::elaborate(MethodDescriptor *m)
+{
+    ObjectsManager<Adafruit_BME280>::elaborate(m);
+
+    if (strcmp(m->getName(), "new") == 0)
+    {
+        Adafruit_BME280 *sensor = new Adafruit_BME280();
+        sensor->begin(m->getInt(0));
+        v.insert(sensor);
+        m->returns(v.getLastIndex());
+    }
+
+    // float get_temperature();
+    if (strcmp(m->getName(), "get_temperature") == 0)
+    {
+        float temperature = v[m->getObjectId()]->readTemperature();
+        m->returns(temperature);
+    }
+
+    // float get_pressure();
+    if (strcmp(m->getName(), "get_pressure") == 0)
+    {
+        float pressure = v[m->getObjectId()]->readPressure();
+        m->returns(pressure);
+    }
+
+    // float get_humidity();
+    if (strcmp(m->getName(), "get_humidity") == 0)
+    {
+        float humidity = v[m->getObjectId()]->readHumidity();
+        m->returns(humidity);
+    }
+}
+
+#endif

Nanpy/BME280Class.h

@@ -0,0 +1,19 @@
+#ifndef BME280_CLASS
+#define BME280_CLASS
+
+#include "BaseClass.h"
+#include "MethodDescriptor.h"
+
+class Adafruit_BME280;
+
+namespace nanpy
+{
+class BME280Class : public ObjectsManager<Adafruit_BME280>
+{
+  public:
+    void elaborate(nanpy::MethodDescriptor *m);
+    const char *get_firmware_id();
+};
+} // namespace nanpy
+
+#endif

Nanpy/MCP4725Class.cpp

@@ -0,0 +1,32 @@
+#include "cfg.h"
+
+#if USE_MCP4725
+
+#include <Arduino.h>
+#include <Adafruit_MCP4725.h>
+#include "MCP4725Class.h"
+#include <stdlib.h>
+
+const char* nanpy::MCP4725Class::get_firmware_id() {
+  return "MCP4725";
+}
+
+void nanpy::MCP4725Class::elaborate( MethodDescriptor* m ) {
+  ObjectsManager<Adafruit_MCP4725>::elaborate(m);
+
+  if(strcmp(m->getName(), "new") == 0) {
+    //Adafruit_TLC5947* tlc = new Adafruit_TLC5947(m->getInt(0), m->getInt(1), m->getInt(2), m->getInt(3));
+    Adafruit_MCP4725* dac = new Adafruit_MCP4725();
+    dac->begin(m->getInt(0));
+    v.insert(dac);
+    m->returns(v.getLastIndex());
+  }
+
+  // void setVoltage( uint16_t output, bool writeEEPROM );
+  if (strcmp(m->getName(), "setVoltage") == 0) {
+    v[m->getObjectId()]->setVoltage(m->getInt(0),m->getBool(1));
+    m->returns(0); 
+   }
+}
+
+#endif

Nanpy/MCP4725Class.h

@@ -0,0 +1,17 @@
+#ifndef MCP4725_CLASS
+#define MCP4725_CLASS
+
+#include "BaseClass.h"
+#include "MethodDescriptor.h"
+
+class Adafruit_MCP4725;
+
+namespace nanpy{
+    class MCP4725Class: public ObjectsManager<Adafruit_MCP4725>{
+      public:
+        void elaborate( nanpy::MethodDescriptor* m);
+        const char* get_firmware_id();
+    };
+}
+
+#endif

Nanpy/MemsClass.cpp

@@ -0,0 +1,97 @@
+#include "cfg_all.h"
+
+#if USE_MEMS
+
+#include <Arduino.h>
+#include <Wire.h>
+#include "MemsClass.h"
+#include <stdlib.h>
+
+const char* nanpy::MemsClass::get_firmware_id()
+{
+    return "Mems";
+}
+
+void nanpy::MemsClass::elaborate( MethodDescriptor* m ) {
+
+    if (strcmp(m->getName(), "begin") == 0) {
+        if (m->getNArgs())
+        {
+            // slave
+            Wire.begin(m->getInt(0));
+        }
+        else
+        {
+            // master
+            Wire.begin();
+        }
+        m->returns(0);
+    }
+    if (strcmp(m->getName(), "get_error_code") == 0) {
+        uint8_t addr;
+        addr = m->getInt(0);
+        Wire.beginTransmission(addr);
+        Wire.write((uint8_t)MEMS_REG_ERROR_CODE);
+        Wire.endTransmission();
+        Wire.requestFrom(addr, (uint8_t)1);
+        uint8_t errorCode = Wire.read();
+        m->returns(errorCode);
+    }
+    if (strcmp(m->getName(), "get_firmware_version") == 0) {
+        uint8_t addr;
+        addr = m->getInt(0);
+        Wire.beginTransmission(addr);
+        Wire.write((uint8_t)MEMS_REG_FIRMWARE_VERSION);
+        Wire.endTransmission();
+        Wire.requestFrom(addr, (uint8_t)3);
+        uint32_t data; // Firmware version is made up of 3 bytes
+        data = Wire.read() & 0xFF; // Trim each read result
+        data <<= 8;
+        data |= Wire.read() & 0xFF;
+        data <<= 8;
+        data |= Wire.read() & 0xFF;
+        m->returns(data);
+    }
+    if (strcmp(m->getName(), "get_status") == 0) {
+        uint8_t addr;
+        addr = m->getInt(0);
+        Wire.beginTransmission(addr);
+        Wire.write((uint8_t)MEMS_REG_GET_CHANNEL_NUMBER);
+        Wire.endTransmission();
+        Wire.requestFrom(addr, (uint8_t)2);
+        uint16_t data;
+        data = Wire.read(); // Status code
+        data <<= 8;
+        data |= Wire.read(); // Channel number
+        m->returns(data);
+    }
+    if (strcmp(m->getName(), "set_channel_number") == 0) {
+        uint8_t addr;
+        uint8_t channel;
+        addr = m->getInt(0);
+        channel = m->getInt(1);
+        Wire.beginTransmission(addr);
+        Wire.write((uint8_t)MEMS_REG_SET_CHANNEL_NUMBER);
+        Wire.write(channel);
+        Wire.endTransmission();
+        delay(15); // Delay while switch updates (from spec)
+        Wire.requestFrom(addr, (uint8_t)1);
+        uint8_t data = Wire.read();
+        m->returns(data);
+    }
+    if (strcmp(m->getName(), "get_device_dimensions") == 0) {
+        uint8_t addr;
+        addr = m->getInt(0);
+        Wire.beginTransmission(addr);
+        Wire.write((uint8_t)MEMS_REG_DEVICE_DIMENSIONS);
+        Wire.endTransmission();
+        Wire.requestFrom(addr, (uint8_t)2);
+        uint16_t data;
+        data = Wire.read(); // Number of inputs
+        data <<= 8;
+        data |= Wire.read(); // Number of outputs
+        m->returns(data);
+    }
+};
+
+#endif

Nanpy/MemsClass.h

@@ -0,0 +1,47 @@
+#ifndef MEMS_CLASS
+#define MEMS_CLASS
+
+#include "BaseClass.h"
+#include "MethodDescriptor.h"
+
+// Default I2C address
+#define MEMS_I2CADDR_DEFAULT                0x49
+
+// I2C Register Channels
+#define MEMS_CHANNEL_PARKING                0x00
+#define MEMS_CHANNEL_1                      0x01
+#define MEMS_CHANNEL_2                      0x02
+#define MEMS_CHANNEL_3                      0x03
+#define MEMS_CHANNEL_4                      0x04
+
+// Commands
+#define MEMS_REG_ERROR_CODE                 0x30
+#define MEMS_REG_FIRMWARE_VERSION           0x31
+#define MEMS_REG_GET_CHANNEL_NUMBER         0x79
+#define MEMS_REG_DEVICE_DIMENSIONS          0x70
+#define MEMS_REG_SET_CHANNEL_NUMBER         0x78
+
+// Error Codes (Command 30)
+#define MEMS_ERROR_COMMAND_INVALID          0x12
+#define MEMS_ERROR_VALUE_OUT_OF_RANGE       0x22
+#define MEMS_ERROR_COMMAND_EXECUTION_FAILED 0x32
+#define MEMS_ERROR_COMMAND_NOT_ALLOWEDD     0x52
+
+// Status Codes (Commands 78 and 79)
+#define MEMS_STATUS_READY                   0x00
+#define MEMS_STATUS_BUSY                    0x01
+#define MEMS_STATUS_ERROR                   0x02
+
+class Wire;
+
+namespace nanpy {
+    class MemsClass: public BaseClass {
+
+        public:
+            void elaborate( nanpy::MethodDescriptor* m );
+            const char* get_firmware_id();
+
+    };
+}
+
+#endif

Nanpy/Nanpy.ino

@@ -7,6 +7,18 @@
 #include <MCP41xxx.h>
 #endif
 
+#if USE_MCP4725
+#include <Adafruit_MCP4725.h>
+#endif
+
+#if USE_TMP007
+#include <Adafruit_TMP007.h>
+#endif
+
+#if USE_BME280
+#include <Adafruit_BME280.h>
+#endif
+
 #if USE_EEPROM
 #include <EEPROM.h>
 #endif
@@ -51,7 +63,10 @@
 #include <Adafruit_TLC5947.h>
 #endif
 
-
+#include "MemsClass.h"
+#include "MCP4725Class.h"
+#include "TMP007Class.h"
+#include "BME280Class.h"
 #include "MCP41xxxClass.h"
 #include "BaseClass.h"
 #include "ArduinoClass.h"
@@ -87,13 +102,20 @@ using namespace nanpy;
 MethodDescriptor *m = NULL;
 
 void setup() {
+#if INIT_PINS
+    // Register the defined pins as output pins
+    for (int pinNumber = 0; pinNumber < initPinCount; pinNumber++) {
+        pinMode(initPins[pinNumber], OUTPUT);
+    }
+#endif
+
     disable_watchdog_at_startup();
-   
+
     REGISTER_CLASS(ArduinoClass);                                                   // 0.8 k
 //
     REGISTER_CLASS_CONDITIONAL(MCP41xxxClass, USE_MCP41xxx);
     REGISTER_CLASS_CONDITIONAL(nanpy::EEPROMClass, USE_EEPROM);                     // 0.3 k
-    REGISTER_CLASS_CONDITIONAL(nanpy::RAMClass, USE_RAM);                           // 
+    REGISTER_CLASS_CONDITIONAL(nanpy::RAMClass, USE_RAM);                           //
     REGISTER_CLASS_CONDITIONAL(LiquidCrystalClass, USE_LiquidCrystal);              //  2.3 k
     REGISTER_CLASS_CONDITIONAL(LiquidCrystalClass_I2C, USE_LiquidCrystal_I2C);
     REGISTER_CLASS_CONDITIONAL(OneWireClass, USE_OneWire);                          // 1.7 k
@@ -103,23 +125,27 @@ void setup() {
     REGISTER_CLASS_CONDITIONAL(ToneClass, USE_Tone);                                // 2.2 k
     REGISTER_CLASS_CONDITIONAL(CapacitiveSensorClass, USE_CapacitiveSensor);        // 2.2 k
     REGISTER_CLASS_CONDITIONAL(DefineClass, USE_Define);                            // 0.6 k
-    REGISTER_CLASS_CONDITIONAL(ArduinoCoreClass, USE_ArduinoCore);                  // 
+    REGISTER_CLASS_CONDITIONAL(ArduinoCoreClass, USE_ArduinoCore);                  //
     REGISTER_CLASS_CONDITIONAL(WatchdogClass, USE_Watchdog);                        // 0.2 k
     REGISTER_CLASS_CONDITIONAL(RegisterClass, USE_Register);                        // 1.5 k
 
-    REGISTER_CLASS_CONDITIONAL(CounterClass, USE_Counter);                          // 
-    REGISTER_CLASS_CONDITIONAL(InfoClass, USE_Info);                          // 
+    REGISTER_CLASS_CONDITIONAL(CounterClass, USE_Counter);                          //
+    REGISTER_CLASS_CONDITIONAL(InfoClass, USE_Info);                          //
     REGISTER_CLASS_CONDITIONAL(DHTClass, USE_DHT);
     REGISTER_CLASS_CONDITIONAL(WireClass, USE_Wire);
-
+    REGISTER_CLASS_CONDITIONAL(MCP4725Class, USE_MCP4725);
+    REGISTER_CLASS_CONDITIONAL(TMP007Class, USE_TMP007);
+    REGISTER_CLASS_CONDITIONAL(BME280Class, USE_BME280);
+    REGISTER_CLASS_CONDITIONAL(MemsClass, USE_MEMS);
+
     REGISTER_CLASS_CONDITIONAL(TLC5947Class, USE_TLC5947);
 
     REGISTER_CLASS_CONDITIONAL(nanpy::EspClass, USE_ESP);
 
     // GW Classes
     REGISTER_CLASS_CONDITIONAL(UltrasonicClass, USE_Ultrasonic);
     REGISTER_CLASS_CONDITIONAL(ColorSensorClass, USE_ColorSensor);
-    
+
     ComChannel::connect();
 }
 

Nanpy/TMP007Class.cpp

@@ -0,0 +1,42 @@
+#include "cfg.h"
+
+#if USE_TMP007
+
+#include <Arduino.h>
+#include "Adafruit_TMP007.h"
+#include "TMP007Class.h"
+#include <stdlib.h>
+
+const char *nanpy::TMP007Class::get_firmware_id()
+{
+    return "TMP007";
+}
+
+void nanpy::TMP007Class::elaborate(MethodDescriptor *m)
+{
+    ObjectsManager<Adafruit_TMP007>::elaborate(m);
+
+    if (strcmp(m->getName(), "new") == 0)
+    {
+        Adafruit_TMP007 *sensor = new Adafruit_TMP007(m->getInt(0));
+        sensor->begin(m->getInt(1));
+        v.insert(sensor);
+        m->returns(v.getLastIndex());
+    }
+
+    // float get_object_temperature();
+    if (strcmp(m->getName(), "get_object_temperature") == 0)
+    {
+        float objectTemp = v[m->getObjectId()]->readObjTempC();
+        m->returns(objectTemp);
+    }
+
+    // float get_die_temperature();
+    if (strcmp(m->getName(), "get_die_temperature") == 0)
+    {
+        float dieTemp = v[m->getObjectId()]->readDieTempC();
+        m->returns(dieTemp);
+    }
+}
+
+#endif