From c3104ab657734954b55716bbef56b03919111845 Mon Sep 17 00:00:00 2001
From: polymurph <eddyed.k@gmail.com>
Date: Sat, 16 Oct 2021 20:54:05 +0200
Subject: [PATCH] added driver dev folder

---
 driver_dev/max31865_dev/Makefile            |  24 ++++
 driver_dev/max31865_dev/driver/device.cpp   |  69 +++++++++++
 driver_dev/max31865_dev/driver/device.hpp   | 113 ++++++++++++++++++
 driver_dev/max31865_dev/driver/max31865.cpp |   0
 driver_dev/max31865_dev/driver/max31865.hpp |  64 ++++++++++
 driver_dev/max31865_dev/interfaces/i2c.cpp  |   0
 driver_dev/max31865_dev/interfaces/i2c.hpp  |   0
 driver_dev/max31865_dev/main.cpp            |  57 +++++++++
 driver_dev/max31865_dev/problem_test.txt    | 126 ++++++++++++++++++++
 driver_dev/max31865_dev/runtest             | Bin 0 -> 18376 bytes
 driver_dev/max31865_dev/utils/BitField.hpp  |  79 ++++++++++++
 11 files changed, 532 insertions(+)
 create mode 100644 driver_dev/max31865_dev/Makefile
 create mode 100644 driver_dev/max31865_dev/driver/device.cpp
 create mode 100644 driver_dev/max31865_dev/driver/device.hpp
 create mode 100644 driver_dev/max31865_dev/driver/max31865.cpp
 create mode 100644 driver_dev/max31865_dev/driver/max31865.hpp
 create mode 100644 driver_dev/max31865_dev/interfaces/i2c.cpp
 create mode 100644 driver_dev/max31865_dev/interfaces/i2c.hpp
 create mode 100644 driver_dev/max31865_dev/main.cpp
 create mode 100644 driver_dev/max31865_dev/problem_test.txt
 create mode 100755 driver_dev/max31865_dev/runtest
 create mode 100644 driver_dev/max31865_dev/utils/BitField.hpp

diff --git a/driver_dev/max31865_dev/Makefile b/driver_dev/max31865_dev/Makefile
new file mode 100644
index 0000000..38e5ad5
--- /dev/null
+++ b/driver_dev/max31865_dev/Makefile
@@ -0,0 +1,24 @@
+cpp_src = $(wildcard *.cpp) 
+cpp_src += $(wildcard ./utils/*.cpp)
+cpp_src += $(wildcard ./driver/*.cpp)
+
+cpp_obj = $(cpp_src:.cpp=.o)
+c_obj = $(c_src:.c=.o)
+CC = g++ 
+CFLAGS = -Wall -pedantic -li2c 
+LDFLAGS = 
+EXEC = runtest
+
+
+all : $(EXEC)
+
+$(EXEC): $(cpp_obj) $(c_obj)
+	$(CC) -o $@ $^ $(LDFLAGS) 
+ 
+clean: 
+	rm -rf $(c_obj) $(cpp_obj) $(EXEC)
+	clear
+
+cleanall: 
+	rm -rf $(c_obj) $(cpp_obj) $(EXEC)
+	clear
diff --git a/driver_dev/max31865_dev/driver/device.cpp b/driver_dev/max31865_dev/driver/device.cpp
new file mode 100644
index 0000000..715bf1e
--- /dev/null
+++ b/driver_dev/max31865_dev/driver/device.cpp
@@ -0,0 +1,69 @@
+#include "device.hpp"
+#include <iostream>
+
+Device::Device() :
+    reg_control(0x00)
+{
+
+    std::cout << "Device::Device()" << std::endl;
+    std::cout << +reg_control.raw << std::endl;
+
+    reg_control.bits.POWER_DEV = Reg_Control::POWER_DEV::TURN_OFF;
+    reg_control.bits.SPEED = Reg_Control::SPEED::STAND_STILL;
+
+    std::cout << "POWER = " << +reg_control.bits.POWER_DEV <<  std::endl;
+    std::cout << "SPEED = " <<+reg_control.bits.SPEED <<  std::endl;
+}
+
+void Device::doSomething()
+{
+    std::cout << "Device::doSomething()" << std::endl;
+
+    reg_control.bits.POWER_DEV = Reg_Control::POWER_DEV::TURN_ON;
+    reg_control.bits.SPEED = Reg_Control::SPEED::FAST;
+
+    if(reg_control.bits.POWER_DEV == Reg_Control::POWER_DEV::TURN_ON){
+        std::cout << "device turned on!" << std::endl;
+    }
+
+    std::cout << "POWER = " << +reg_control.bits.POWER_DEV <<  std::endl;
+    std::cout << "SPEED = " << +reg_control.bits.SPEED <<  std::endl;
+     
+    std::cout << +reg_control << std::endl;
+
+    reg_control = 0;
+
+    std::cout << +reg_control << std::endl;
+
+    std::cout << "POWER = " << +reg_control.bits.POWER_DEV <<  std::endl;
+    std::cout << "SPEED = " << +reg_control.bits.SPEED <<  std::endl;
+
+    //reg_control.bits.SPEED = Reg_Control::SPEED::FAST;
+    reg_control.bits.POWER_DEV = Reg_Control::POWER_DEV::TURN_ON;
+    
+    std::cout << "POWER = " << +reg_control.bits.POWER_DEV <<  std::endl;
+    std::cout << "SPEED = " << +reg_control.bits.SPEED <<  std::endl;
+
+
+
+    
+}
+
+void Device::status()
+{
+    // imitating read hardware register (for example reading from device via SPI or i2c)
+    reg_motorStatus = 0xFE;
+
+    if(reg_motorStatus.bits.POWER == Reg_MotorStatus::POWER::ON) {
+        std::cout << "Motor is Powered ON!" << std::endl;
+    } else {
+        std::cout << "Motor is Powered OFF!" << std::endl;
+    }
+
+    // will throw error because this bitfield is set const!
+    //reg_motorStatus.bits.STATUS = Reg_MotorStatus::STATUS::STANDSTILL;
+
+    std::cout << +reg_motorStatus.bits.POWER << std::endl;
+
+    std::cout << "Motor Status : " << +reg_motorStatus.bits.STATUS << std::endl;
+}
\ No newline at end of file
diff --git a/driver_dev/max31865_dev/driver/device.hpp b/driver_dev/max31865_dev/driver/device.hpp
new file mode 100644
index 0000000..2f9e1ea
--- /dev/null
+++ b/driver_dev/max31865_dev/driver/device.hpp
@@ -0,0 +1,113 @@
+#ifndef _DEVICE_HPP_
+#define _DEVICE_HPP_
+
+#include "../utils/BitField.hpp"
+
+#include <iostream>
+#include <stdint.h>
+
+class Device
+{
+    public:
+        Device();
+
+        void doSomething();
+
+        void status();
+
+    private:
+
+        //
+        //  Register declarations
+        //
+#ifdef EXAMPLE_CODE_FOR_REFERENCE
+        union Control {
+            struct OPM{
+                typedef Bits<uint16_t, 10, 2> bits;
+                enum { NO_CHANGE = 0, AS_STANDBY = 1};
+            };
+            struct CTRL_BR{
+                enum { NO_CHANGE = 0, BRANCH_NORMAL = 1};
+            };
+            struct CTRL_BR1 : CTRL_BR{
+                typedef Bits<uint16_t, 8, 2> bits;
+            };
+            struct CTRL_BR2 : CTRL_BR{
+                typedef Bits<uint16_t, 6, 2> bits;
+            };
+
+            union Bits {
+                Control::OPM::bits OPM;
+                Control::CTRL_BR1::bits CTRL_BR1;
+                Control::CTRL_BR2::bits CTRL_BR2;
+            } bits;
+            uint16_t raw;
+        };
+#endif
+        union Reg_Control
+        {
+            // bit 4
+            struct POWER_DEV{
+                typedef BitField<uint8_t, 7, 1> Bits;
+                enum{TURN_OFF = 0, TURN_ON = 1};
+            };
+            // bits 2-3
+            struct SPEED{
+                typedef BitField<uint8_t, 2, 2> Bits;
+                enum{STAND_STILL = 0,
+                     SLOW = 1,
+                     NORMAL = 2,
+                     FAST = 3};
+            };
+            union Bits{
+                Reg_Control::POWER_DEV::Bits POWER_DEV;
+                Reg_Control::SPEED::Bits SPEED;
+            } bits;
+            // raw value. all bitfields will be "unified" here ;)
+            uint8_t raw;
+            // union Ctor with default value set to 0x00
+            Reg_Control(uint8_t v = 0x00) : raw(v) {}
+            // raw value extraction of register
+            operator uint8_t() {return raw;}
+            // used for updating software immage of hardware register
+            void operator = (uint8_t v) {raw = v;}
+        };
+
+        union Reg_MotorStatus
+        {
+            struct POWER{
+                typedef BitField<uint8_t,0,1> Bits;
+                enum{OFF = 0, ON = 1};
+            };
+            struct STATUS{
+                typedef BitField<uint8_t, 2,3>Bits;
+                enum{STANDSTILL = 0,
+                     ACCELERATING_CW = 1,
+                     DEACCELERATING_CW = 2,
+                     ACCELERATING_CCW = 3,
+                     DEACCELERATING_CCW = 4,
+                     CONSTANT_SPEED = 5,
+                     BLOCKED = 6};
+            };
+            union Bits
+            {
+                // is set const because it only used for status indication
+                const Reg_MotorStatus::POWER::Bits POWER;
+                const Reg_MotorStatus::STATUS::Bits STATUS;
+            }bits;
+            uint8_t raw;
+
+            Reg_MotorStatus(uint8_t v = 0x00) : raw(v) {}
+            operator uint8_t() {return raw;}
+            void operator = (uint8_t v) {raw = v;}   
+        };
+
+        Reg_Control reg_control;
+
+        Reg_MotorStatus reg_motorStatus;
+
+
+
+};
+
+#endif // _DEVICE_HPP_
diff --git a/driver_dev/max31865_dev/driver/max31865.cpp b/driver_dev/max31865_dev/driver/max31865.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/driver_dev/max31865_dev/driver/max31865.hpp b/driver_dev/max31865_dev/driver/max31865.hpp
new file mode 100644
index 0000000..908dc3f
--- /dev/null
+++ b/driver_dev/max31865_dev/driver/max31865.hpp
@@ -0,0 +1,64 @@
+#ifdef __MAX31865_HPP_
+#define __MAX31865_HPP__
+
+#include <stdint.h>
+#include "../utils/BitFiled.hpp"
+
+
+class MAX31865
+{
+	public:
+		MAX31865();
+
+	private:
+
+		//
+		// register definitions
+		//
+
+		union CONFIG_REG {
+			struct VBIAS{
+				enum {
+					OFF = 0,
+					ON = 1
+				};
+				typedef BitField<uint8_t,7,1> Bits;
+			};
+		
+			struct CONVERSION_MODE{
+				enum {
+					OFF = 0,
+					AUTO = 1
+				};
+				typedef BitField<uint8_t,6,1> Bits;
+			};
+
+			struct ONE_SHOT{
+				enum {
+					IDLE = 0,
+					SET = 1
+				};
+				typedef BitField<uint8_t,5,1> Bits;
+			};
+			
+			struct WIRING{
+				enum {
+					TWO_OR_FOUR_WIRE = 0,
+					THREE_WIRE = 1
+				};
+				typedef BitField<uint8_t,4,1> Bits;
+			};
+			
+			struct {
+				enum {
+					IDLE = 0,
+					SET = 1
+				};
+				typedef BitField<uint8_t,5,1> Bits;
+			};
+			
+		};
+};
+
+
+#endif // __MAX31865_HPP__
diff --git a/driver_dev/max31865_dev/interfaces/i2c.cpp b/driver_dev/max31865_dev/interfaces/i2c.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/driver_dev/max31865_dev/interfaces/i2c.hpp b/driver_dev/max31865_dev/interfaces/i2c.hpp
new file mode 100644
index 0000000..e69de29
diff --git a/driver_dev/max31865_dev/main.cpp b/driver_dev/max31865_dev/main.cpp
new file mode 100644
index 0000000..ea510f1
--- /dev/null
+++ b/driver_dev/max31865_dev/main.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <stdint.h>
+
+#include "./driver/device.hpp"
+#include "./utils/BitField.hpp"
+
+#ifdef SIMPLE_TEST
+
+int main(void)
+{
+    std::cout << "test" << std::endl;
+    
+    BitField<uint8_t, 1, 2> bitfield_0;
+    BitField<uint8_t, 5, 2> bitfield_1;
+
+    
+    std::cout << "testing bitfield 0" << std::endl;
+
+    for(uint8_t i = 0; i < 10; i++) {
+
+        bitfield_0 = i;
+        std::cout << static_cast<uint32_t>(bitfield_0()) << std::endl;
+    }
+
+    std::cout << "testing bitfield 1" << std::endl;
+
+    for(uint8_t i = 0; i < 10; i++) {
+
+        bitfield_1 = i;
+        std::cout << static_cast<uint32_t>(bitfield_1()) << std::endl;
+    }
+
+    Device dev();
+
+    return 0;
+}
+
+#endif
+
+
+int main(void)
+{
+    std::cout << "test" << std::endl;
+    
+    //std::cout << std::hex << ((1ULL << 2)-1) << std::endl;
+    std::cout << 1ULL << std::endl;
+
+    Device dev;
+
+    //dev.doSomething();
+
+    dev.status();
+
+    //dev.doSomething();
+
+    return 0;
+}
diff --git a/driver_dev/max31865_dev/problem_test.txt b/driver_dev/max31865_dev/problem_test.txt
new file mode 100644
index 0000000..ed7d1ee
--- /dev/null
+++ b/driver_dev/max31865_dev/problem_test.txt
@@ -0,0 +1,126 @@
+// Example program
+#include <iostream>
+#include <string>
+
+
+#include <stdint.h>
+
+/**
+ * @brief Template class for portable Bitfields
+ * 
+ * @tparam T type of variable in which the bitfield resides
+ * @tparam START bit index starting from LSB where the bitfield starts
+ * @tparam SIZE number of bits
+ */
+template<typename T, uint8_t START, uint8_t SIZE>
+struct BitField
+{   
+    /**
+     * @brief Construct a new Bit Field object
+     * 
+     */
+    BitField()
+    {
+        static_assert(SIZE != 0, "Bitfield SIZE must be > 0!");
+		static_assert(START < sizeof(T) * 8, "START exceeds number of bits of the chosen typename T!");
+    }
+    
+    /**
+     * @brief assignment operator
+     * 
+     * @param v value to be written in the bitfield
+     * @return BitField&
+     */
+    BitField& operator =(T v)
+    {
+
+#if 0
+        _raw = ((v & ((1ULL << SIZE)-1)) << START);
+        return *this;
+#else
+        //_raw & ~(((1ULL << SIZE)-1) << START);
+        
+        // use bit band alias if system permits
+        _raw = ((v & ((1ULL << SIZE)-1)) << START) | (_raw & ~(((1ULL << SIZE)-1) << START));
+        return *this;
+        //#endif
+#endif
+    }
+    
+    /**
+     * @brief return the value inside the bitfield
+     * 
+     * @return T 
+     */
+    operator T() const
+    {
+        return _raw >> START;
+    }
+    
+    /**
+     * @brief return the raw value
+     * 
+     * @return T 
+     */
+    T operator ()() const
+    {
+        return _raw;
+    }
+    
+    private:
+    T _raw;
+};
+
+union Reg_Control
+{
+    // bit 4
+    struct POWER_DEV{
+        typedef BitField<uint8_t, 7, 1> Bits;
+        enum{TURN_OFF = 0, TURN_ON = 1};
+    };
+    // bits 2-3
+    struct SPEED{
+        typedef BitField<uint8_t, 0, 2> Bits;
+        enum{STAND_STILL = 0,
+             SLOW = 1,
+             NORMAL = 2,
+             FAST = 3};
+    };
+    union Bits{
+        Reg_Control::POWER_DEV::Bits POWER_DEV;
+        Reg_Control::SPEED::Bits SPEED;
+    } bits;
+    // raw value. all bitfields will be "unified" here ;)
+    uint8_t raw;
+    // union Ctor with default value set to 0x00
+    Reg_Control(uint8_t v = 0x00) : raw(v) {}
+};
+
+
+
+int main()
+{
+    Reg_Control reg;
+    
+    //reg.bits.SPEED = Reg_Control::SPEED::FAST;
+    reg.bits.POWER_DEV = Reg_Control::POWER_DEV::TURN_ON;
+    
+    
+    std::cout << +reg.raw << std::endl;
+    
+    reg.bits.POWER_DEV = Reg_Control::POWER_DEV::TURN_OFF;
+    
+    std::cout << +reg.raw << std::endl;
+    
+    reg.bits.POWER_DEV = Reg_Control::POWER_DEV::TURN_ON;
+    reg.bits.SPEED = Reg_Control::SPEED::SLOW;
+    
+    std::cout << +reg.raw << std::endl;
+    
+    reg.bits.POWER_DEV = Reg_Control::POWER_DEV::TURN_OFF;
+    reg.bits.SPEED = Reg_Control::SPEED::FAST;
+    
+    std::cout << +reg.raw << std::endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/driver_dev/max31865_dev/runtest b/driver_dev/max31865_dev/runtest
new file mode 100755
index 0000000000000000000000000000000000000000..5dfe56ac4a5ada646d73cc2aabe71c5377db931f
GIT binary patch
literal 18376
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
Kaws^8;(r0Z>0VR-

literal 0
HcmV?d00001

diff --git a/driver_dev/max31865_dev/utils/BitField.hpp b/driver_dev/max31865_dev/utils/BitField.hpp
new file mode 100644
index 0000000..7b36c16
--- /dev/null
+++ b/driver_dev/max31865_dev/utils/BitField.hpp
@@ -0,0 +1,79 @@
+/**
+ * @file BitField.h
+ * @author Edwin Koch (eddyed.k@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2020-12-19
+ * 
+ * @copyright Copyright (c) 2020
+ * 
+ */
+
+// Based on:
+// https://www.youtube.com/watch?v=TYqbgvHfxjM
+// https://stackoverflow.com/questions/31726191/is-there-a-portable-alternative-to-c-bitfields
+// https://stackoverflow.com/questions/1392059/algorithm-to-generate-bit-mask
+
+#ifndef _BITFIELDS_HPP_
+#define _BITFIELDS_HPP_
+
+#include <stdint.h>
+
+/**
+ * @brief Template class for portable Bitfields
+ * 
+ * @tparam T type of variable in which the bitfield resides
+ * @tparam START bit index starting from LSB where the bitfield starts
+ * @tparam SIZE number of bits
+ */
+template<typename T, uint8_t START, uint8_t SIZE>
+struct BitField
+{   
+    /**
+     * @brief Construct a new Bit Field object
+     * 
+     */
+    BitField()
+    {
+        static_assert(SIZE != 0, "Bitfield SIZE must be > 0!");
+		static_assert(START < sizeof(T) * 8, "START exceeds number of bits of the chosen typename T!");
+    }
+    
+    /**
+     * @brief assignment operator
+     * 
+     * @param v value to be written in the bitfield
+     * @return BitField&
+     */
+    BitField& operator =(T v)
+    {
+        // use bit band alias if system permits
+        _raw = ((v & ((1ULL << SIZE)-1)) << START) | (_raw & ~(((1ULL << SIZE)-1) << START));
+        return *this;
+    }
+    
+    /**
+     * @brief return the value inside the bitfield
+     * 
+     * @return T 
+     */
+    operator T() const
+    {
+        return (_raw >> START) & ((1ULL << SIZE) - 1);
+    }
+    
+    /**
+     * @brief return the raw value
+     * 
+     * @return T 
+     */
+    T operator ()() const
+    {
+        return (_raw >> START) & ((1ULL << SIZE) - 1);
+    }
+    
+    private:
+    T _raw;
+};
+
+#endif // _BITFIELDS_HPP_
\ No newline at end of file