Revision 1:19c3a52c80c3, committed 2020-01-06

Comitter:

aktk

Date:

Mon Jan 06 20:26:53 2020 +0000

Parent:

0:6400e338266f

Child:

3:5e9675a0c08c

Child:

4:7d5afb2e3b79

Commit message:

Derived from DSinGenerator.lib

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AMPulseTrain.cpp	Mon Jan 06 20:26:53 2020 +0000
@@ -0,0 +1,84 @@
+#include "AMPulseTrain.h"
+
+AMPulseTrain::AMPulseTrain(
+    /// Carrier Pulse Train
+    PulseTrain  * const arg_carrier,
+    /// Initial AM Signal expression
+    AMSignal  * const arg_signal
+):
+    Carrier(arg_carrier),
+    Signal(arg_signal)
+{
+    setFrequency_Carrier(Carrier->getFrequency());
+}
+
+
+
+
+uint16_t
+AMPulseTrain::getClockperiod_us()
+{
+    return Carrier->getClockperiod_us();
+}
+
+void
+AMPulseTrain::incrementClock()
+{
+    Carrier->incrementClock();
+}
+
+
+
+
+void
+AMPulseTrain::attachCallback_asClock(
+    Callback<void(bool, AMPulseTrain*)> arg_callback
+)
+{
+    m_callback_asClock = arg_callback;
+    Carrier->attachCallback_asClock(callback(this, &AMPulseTrain::CallbackWrapper_asClock));
+}
+
+void
+AMPulseTrain::CallbackWrapper_asClock(bool arg_pulsestate)
+{
+    m_callback_asClock(arg_pulsestate, this);
+}
+
+
+
+
+void
+AMPulseTrain::attachCallback_asPulseEdge(
+    Callback<void(bool, AMPulseTrain*)> arg_callback
+)
+{
+    m_callback_asPulseEdge = arg_callback;
+    Carrier->attachCallback_asPulseEdge(callback(this, &AMPulseTrain::CallbackWrapper_asPulseEdge));
+}
+
+void
+AMPulseTrain::CallbackWrapper_asPulseEdge(bool arg_pulsestate)
+{
+    m_callback_asPulseEdge(arg_pulsestate, this);
+}
+
+
+
+
+void
+AMPulseTrain::attachAMSignalExpression(
+    Callback<uint16_t(AMPulseTrain*)> arg_callback
+)
+{
+    m_AMSignalExpression = arg_callback;
+    Signal->attachAMSignalExpression(
+        callback(this, &AMPulseTrain::CallbackWrapper_AMSignalExpression)
+    );
+}
+
+uint16_t
+AMPulseTrain::CallbackWrapper_AMSignalExpression(AMSignal* arg_signal)
+{
+    return m_AMSignalExpression(this);
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AMPulseTrain.h	Mon Jan 06 20:26:53 2020 +0000
@@ -0,0 +1,88 @@
+/** Defining Amplide Modulated Pulse Train Model
+ *
+ *  \file   AMPulseTrain.h
+ *  \author Akifumi Takahashi
+ *  \date   2019/12/02 -
+ *  \version 1.0.2019.Dec
+ */
+
+#ifndef AM_PULSE_TRAIN_H
+#define AM_PULSE_TRAIN_H
+
+
+#include "mbed.h"
+#include "AMSignal.h"
+#include "PulseTrain.h"
+
+/** \Class Amplide Modulated Pulse Train Model
+ *
+ *  Pulse Train Model which clock is defined in scale of us;
+ *  the model pulses' height can be modulated as a product with m_ampl and any function
+ *  returning a int as the coefficeincy.
+ *  You can define the carrier pulse train's freq and duty cycle like PWM.
+ *
+ */
+class AMPulseTrain
+{
+public:
+    /** Constractor
+     */
+    AMPulseTrain(
+        /// Carrier Pulse Train
+        PulseTrain  * const arg_carrier = new PulseTrain(),
+        /// Initial AM Signal expression
+        AMSignal  * const arg_signal = new AMSignal()
+    );
+
+    /// Carrier Pulse Train
+    PulseTrain  * const Carrier;
+
+    /// AM Signal
+    AMSignal  * const Signal;
+
+
+    void attachCallback_asClock(
+        Callback<void(bool,  AMPulseTrain*)> arg_callback
+    );
+
+    void attachCallback_asPulseEdge(
+        Callback<void(bool,  AMPulseTrain*)> arg_callback
+    );
+
+    void attachAMSignalExpression(
+        Callback<uint16_t(AMPulseTrain*)> arg_callback
+    );
+
+    void setFrequency_Carrier( uint32_t const arg_freq )
+    {
+        Carrier->setFrequency(arg_freq);
+        m_AMSIGNAL_PERIOD_PER_PULSE = Signal->getPeriod_us() / Carrier->getPeriod_us();
+        m_AMSIGNAL_PWIDTH_PER_PULSE = 500 / Carrier->getPeriod_us();
+    }
+    
+    uint32_t getFrequency_Carrier(){return Carrier->getFrequency();}
+    
+    uint16_t getClockperiod_us();
+    
+    void incrementClock();
+    
+    uint16_t getPeriod_pPulse_Signal(){return m_AMSIGNAL_PERIOD_PER_PULSE;}
+    
+    uint16_t getPWidth_pPulse_Signal(){return m_AMSIGNAL_PWIDTH_PER_PULSE;}
+    
+private:
+
+    Callback<void(bool,  AMPulseTrain*)> m_callback_asClock;
+    void CallbackWrapper_asClock(bool arg_pulsestate);
+
+    Callback<void(bool,  AMPulseTrain*)> m_callback_asPulseEdge;
+    void CallbackWrapper_asPulseEdge(bool arg_pulsestate);
+
+    Callback<uint16_t(AMPulseTrain*)>  m_AMSignalExpression;
+    uint16_t CallbackWrapper_AMSignalExpression(AMSignal* arg_signal);
+
+    uint16_t m_AMSIGNAL_PERIOD_PER_PULSE;
+    uint16_t m_AMSIGNAL_PWIDTH_PER_PULSE;
+};
+
+#endif
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AMSignal.cpp	Mon Jan 06 20:26:53 2020 +0000
@@ -0,0 +1,48 @@
+#include "AMSignal.h"
+
+void AMSignal::setFrequency(uint16_t const arg_freq)
+{
+    m_freq = velidateRange<uint16_t>(arg_freq, 1, FREQ_MAX);
+    m_period_us = 1000000 / m_freq;
+    if(1000000 % m_freq >= (m_freq/2)) m_period_us += 1;
+}
+
+void AMSignal::setAmplitude(float const arg_ampl)
+{
+    m_ampl_u16 = AMPL_MAX_u16 * velidateRange<float>(arg_ampl, 0.0, 1.0);
+}
+
+void AMSignal::setAmplitude(uint16_t const arg_ampl)
+{
+    m_ampl_u16 = arg_ampl;
+}
+
+/// Get a parameter which defines the size of pulse hight axis with in [0,1]
+float AMSignal::getAmplitude_uf()
+{
+    return (float) m_ampl_u16 / (float) AMPL_MAX_u16;
+}
+
+uint16_t AMSignal::getAmplitude_u16()
+{
+    return m_ampl_u16;
+}
+
+uint16_t AMSignal::getFrequency()
+{
+    return m_freq;
+}
+
+uint16_t AMSignal::getPeriod_us()
+{
+    return m_period_us;
+}
+
+
+template <typename T>
+T AMSignal::velidateRange(T const arg_val, T const arg_min, T const arg_max)
+{
+    if(arg_val < arg_min) return arg_min;
+    else if (arg_val <=  arg_max) return arg_val;
+    else return arg_max;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/AMSignal.h	Mon Jan 06 20:26:53 2020 +0000
@@ -0,0 +1,105 @@
+/** Defining Amplide Modulated Pulse Train Model
+ *
+ *  \file   AMSignal.h
+ *  \author Akifumi Takahashi
+ *  \date   2019/12/02 -
+ *  \version 1.0.2019.Dec
+ */
+
+#ifndef AM_SIGNAL_H
+#define AM_SIGNAL_H
+
+
+#include "mbed.h"
+
+/** \Class Amplide Modulated Signal Model for AM Pulse Train Model
+ *
+ *  All parameter data is dealed as unsigned 16 bit int.
+ *  \version alluint16
+ */
+class AMSignal
+{
+public:
+    /// Constructor
+    AMSignal(
+        uint16_t const arg_freq = 50,
+        uint16_t const arg_freq_max = 100,
+        uint16_t const arg_ampl_max_u16 = 4095
+    ):
+        FREQ_MAX(arg_freq_max),
+        AMPL_MAX_u16(arg_ampl_max_u16)
+    {
+        setFrequency(arg_freq);
+        attachAMSignalExpression(constantDC_defaltSignal);
+    }
+
+    /** Amplitude Modified Signal / Pulse Hight Writing Handler
+     *
+     *  For fast processing, no float culc nor div culc is recommended
+     */
+    void attachAMSignalExpression(
+        /** Callback
+         *
+         *  \arg AMSignal* contains parameters of this.
+         *  \retval is dealed as a factor the argument of Callback as Pulse rising.
+         */
+        Callback<uint16_t(AMSignal*)> arg_signal
+    )
+    {
+        m_AMSignalExpression = arg_signal;
+    }
+
+    uint16_t getAMSinalValue()
+    {
+        return m_AMSignalExpression(this);
+    }
+
+
+private:
+    uint16_t m_ampl_u16;
+    uint16_t m_freq;
+    uint16_t m_period_us;
+    template <typename T>
+    static T velidateRange(T const arg_val, T const arg_min, T const arg_max);
+
+    Callback<uint16_t(AMSignal*)> m_AMSignalExpression;
+
+    /// Default amplitude modulation signal
+    static uint16_t constantDC_defaltSignal (AMSignal* arg)
+    {
+        return 1;
+    }
+
+
+public:
+    //  constants
+    uint16_t const FREQ_MAX;
+    uint16_t const AMPL_MAX_u16;
+
+    /** Frequency could be slightly modulated because it depends on the carrier freq
+     */
+    void setFrequency(uint16_t const arg_freq);
+
+    /** Set Amplitude Paramiter
+     *
+     *  -   Crumping a value within [0f,1f], converted to [0, 0xFFFF]
+     *  -   Note that this is a parameter which affects a pulse hight,
+     *  but isn't the pulse hight itself
+     *  -   The Pulse hight is defined in callback attached with attachAMSignalExpression()
+     */
+    void setAmplitude(float const arg_ampl);
+
+    void setAmplitude(uint16_t const arg_ampl);
+
+    /// Get a parameter which defines the size of pulse hight axis with in [0,1]
+    float getAmplitude_uf();       //inline
+
+    /// Get a parameter which defines the size of pulse hight axis with in [0, 4096]
+    uint16_t getAmplitude_u16(); //inline
+
+    uint16_t getFrequency();    //inline
+
+    uint16_t getPeriod_us();    //inline
+
+};
+#endif
\ No newline at end of file

--- a/DSinGenerator.cpp	Wed Nov 27 23:03:42 2019 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,79 +0,0 @@
-#include "DSinGenerator.h"
-
-DSinGenerator::DSinGenerator(
-    uint16_t const arg_resolution_ofsin
-):
-    ampl_max(10),
-    freq_max(5000),
-    resolution_ofsin(arg_resolution_ofsin)
-{
-    init();
-    setParam(0, 4000);
-}
-
-DSinGenerator::DSinGenerator(
-    float const arg_ampl,
-    uint16_t const arg_freq,
-    uint16_t const arg_resolution_ofsin
-): 
-    ampl_max(10),
-    freq_max(5000),
-    resolution_ofsin(arg_resolution_ofsin)
-{
-    init();
-    setParam(arg_ampl, arg_freq);
-}
-
-void DSinGenerator::setParam(
-    float const arg_ampl,
-    uint16_t const arg_freq
-)
-{
-    setAmplitude(arg_ampl);
-    setFrequency(arg_freq);
-}
-
-void DSinGenerator::setAmplitude(
-    float const arg_ampl
-)
-{
-    ampl = arg_ampl;
-    for(int i = 0; i < resolution_ofsin; i++){
-        discretized_sin_p16m16[i] = static_cast<int32_t>(4095.0 / ampl_max * ampl * discretized_sin[i] );
-    }
-}
-
-void DSinGenerator::setFrequency(
-    uint16_t const arg_freq
-)
-{
-    freq = arg_freq;
-    pwth = 1000000 / freq / resolution_ofsin;
-}
-
-void DSinGenerator::init()
-{
-    discretized_sin = new float[resolution_ofsin];
-    discretized_sin_p16m16 = new int32_t[resolution_ofsin];
-    
-    for(int i = 0; i < resolution_ofsin; i++){
-        discretized_sin[i] = sin( 2.0 * M_PI * static_cast<float>(i) / static_cast<float>(resolution_ofsin));
-    }
-}
-
-float DSinGenerator::getValue()
-{
-    static int itr = 0;
-    return ampl * discretized_sin[itr++ % resolution_ofsin];
-}
-
-int32_t DSinGenerator::getValue_p16m16()
-{
-    static int itr = 0;
-    return discretized_sin_p16m16[itr++ % resolution_ofsin];
-}
-
-void DSinGenerator::getValueofSamplePoints(float arg_dsin[])
-{
-    memcpy(arg_dsin, discretized_sin, sizeof(float) * resolution_ofsin);
-}
\ No newline at end of file

--- a/DSinGenerator.h	Wed Nov 27 23:03:42 2019 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,96 +0,0 @@
-/** Defining Discretized Sinusoidal Wave Generator 
- *
- *  \file   DSinGenerator.h
- *  \author Akifumi Takahashi
- *  \date   2019/Nov/28 ver.1 publish
- *  \version 1.0.2019.Nov
- */
- 
-#ifndef DISCRETIZED_SINUSOIDAL_WAVE_GENERATOR_H
-#define DISCRETIZED_SINUSOIDAL_WAVE_GENERATOR_H
-#define _USE_MATH_DEFINES
-#include <cmath>
-
-#ifndef M_PI
-#define M_PI 3.141592
-#endif
-
-#include "mbed.h"
-/** \Class DISCRETIZED SINUSOIDAL WAVE GENERATOR
- *
- *  Generate a discretized sinusoidal wave whose value type is float, 
- *  and the range is from (-1.0f * ampl) to (1.0f * ampl).
- *
- */
-class DSinGenerator
-{
-private:
-    /// Amplitude of sinusoidal wave (mA)
-    float ampl;
-    
-    /// Frequency of the wave (Hz)
-    uint16_t freq;
-    
-    /// Pulse width fineness of dicretization (us) 
-    /// pwth = 1000000 / freq / resolution_ofsin;
-    uint16_t pwth;
-    
-    float*      discretized_sin;
-    int32_t*    discretized_sin_p16m16;
-    
-    void init();
-
-public:
-    float const ampl_max;
-    uint16_t const freq_max;
-    uint16_t const resolution_ofsin; // = arg_resolution_ofsin below
-    
-    DSinGenerator(
-        uint16_t const arg_resolution_ofsin = 20
-    );
-    DSinGenerator(
-        float const arg_ampl,
-        uint16_t const arg_freq,
-        uint16_t const arg_resolution_ofsin = 20
-    );
-    
-    void setParam(
-        float const arg_ampl,
-        uint16_t const arg_freq
-    );
-    
-    void setAmplitude(
-        float const arg_ampl
-    );
-    
-    void setFrequency(
-        uint16_t const arg_freq
-    );
-    
-    float getValue();
-    int32_t getValue_p16m16();
-    
-    void getValueofSamplePoints(float[]);
-    
-    float    getAmplitude();    //inline
-    uint16_t getFrequency();    //inline
-    uint16_t getPulseWidth(); //inline
-    
-};
-
-
-inline float DSinGenerator::getAmplitude()
-{
-    return ampl;
-}
-
-inline uint16_t DSinGenerator::getFrequency()
-{
-    return freq;
-}
-
-inline uint16_t DSinGenerator::getPulseWidth()
-{
-    return pwth;
-}
-#endif
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/PulseTrain.cpp	Mon Jan 06 20:26:53 2020 +0000
@@ -0,0 +1,109 @@
+#include "PulseTrain.h"
+
+PulseTrain::PulseTrain(
+    uint32_t const arg_freq,
+    float const arg_duty,
+    uint32_t const arg_freq_max
+):
+    FREQ_MAX(arg_freq_max),
+    m_freq(velidateRange<uint32_t>(arg_freq, 1, FREQ_MAX)),
+    m_duty(velidateRange<float>(arg_duty, 0.0, 1.0))
+{
+    m_period_us = 1000000 / m_freq + (1000000 % m_freq > m_freq /2 ? 1 : 0);
+    init();
+    m_callback_asClock = doNothing;
+    m_callback_asPulseEdge = doNothing;
+
+}
+
+void PulseTrain::attachCallback_asClock(Callback<void(bool)> arg_callback)
+{
+    m_callback_asClock = arg_callback;
+}
+
+void PulseTrain::attachCallback_asPulseEdge(Callback<void(bool)> arg_callback)
+{
+    m_callback_asPulseEdge = arg_callback;
+}
+
+void PulseTrain::setFrequency(uint32_t const arg_freq)
+{
+    m_freq = velidateRange<uint32_t>(arg_freq, 1, FREQ_MAX);
+    m_period_us = 1000000 / m_freq + (1000000 % m_freq > m_freq /2 ? 1 : 0);
+    init();
+}
+
+void PulseTrain::setDutycycle(float const arg_duty)
+{
+    m_duty = velidateRange<float>(arg_duty, 0.0, 1.0);
+    init();
+}
+
+template <typename T>
+T PulseTrain::velidateRange(T const arg_val, T const arg_min, T const arg_max)
+{
+    if(arg_val < arg_min) return arg_min;
+    else if (arg_val <=  arg_max) return arg_val;
+    else return arg_max;
+}
+
+void PulseTrain::init()
+{
+    int a, b, r;
+    a = m_period_us;
+    b = a * m_duty;
+    r = a % b;
+    while ( r != 0 ) {
+        a = b;
+        b = r;
+        r = a % b;
+    }
+    m_clock_period_us = b;
+    
+     m_period_pcp = m_period_us / m_clock_period_us;
+     m_falling = m_period_pcp * m_duty;
+}
+
+void PulseTrain::incrementClock()
+{
+    static unsigned int l_itr = 0;
+
+    if (l_itr == m_raising) {
+        m_pulsestate = true;
+        m_callback_asPulseEdge(m_pulsestate);
+    } else if (l_itr == m_falling) {
+        m_pulsestate = false;
+        m_callback_asPulseEdge(m_pulsestate);
+    }
+
+    l_itr = (l_itr + 1) % m_period_pcp;
+
+    m_callback_asClock(m_pulsestate);
+}
+
+
+bool PulseTrain::getState()
+{
+    return m_pulsestate;
+}
+
+uint32_t PulseTrain::getFrequency()
+{
+    return m_freq;
+}
+
+float PulseTrain::getDutycycle()
+{
+    return m_duty;
+}
+
+uint32_t
+PulseTrain::getPeriod_us()
+{
+    return m_period_us;
+}
+
+uint32_t PulseTrain::getClockperiod_us()
+{
+    return m_clock_period_us;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/PulseTrain.h	Mon Jan 06 20:26:53 2020 +0000
@@ -0,0 +1,132 @@
+/** Defining Amplide Modulated Pulse Train Model
+ *
+ *  \file   PulseTrain.h
+ *  \author Akifumi Takahashi
+ *  \date   2019/12/02 -
+ *  \version 1.0.2019.Dec
+ */
+
+#ifndef PULSE_TRAIN_H
+#define PULSE_TRAIN_H
+
+#include "mbed.h"
+/** \Class Pulse Train Model
+ *
+ *  Pulse Train Model which clock is defined in scale of [us];
+ *  You can define the carrier pulse train's freq and duty cycle like PWM.
+ *  Kinds of Frequency is dealed as unsigned 32bit int
+ *  For the other int vars, allocated is 32bit.
+ */
+class PulseTrain
+{
+public:
+    /** Constractor
+     */
+    PulseTrain(
+        /// Initial carrier pulse frequency
+        uint32_t const arg_freq = 4000,
+        /// Initial carrier pulse duty cycle
+        float const arg_duty = 0.5,
+        /// Initialize FREQ_MAX
+        uint32_t const arg_freq_max = 8000
+    );
+    /** Increment the clock to let go ahead the wave state
+     *
+     *  If callback as rising/falling is also called,
+     *  this "asClock" is called earlier
+     */
+    void incrementClock();
+
+    /** Executes a callback fanction called as clock is incremented
+     *
+     *  If callback as rising/falling is also called,
+     *  this "asClock" is called at the last.
+     */
+    void attachCallback_asClock(
+        /** Called back as clock incremented
+         *
+         *  \arg <pulsestate> indicate whther pulse
+         *  (not clock pulse but one of pulse train) has risen/fallen
+         */
+        Callback<void(bool)> arg_callback
+    );
+
+    void attachCallback_asPulseEdge(
+        /** Called back as a pulse rising/falling
+         *
+         *  \arg <pulsestate> indicate whther pulse has risen/fallen
+         */
+        Callback<void(bool)> arg_callback
+    );
+
+    void setFrequency(uint32_t const arg_freq);
+
+    void setDutycycle(float const arg_duty);
+
+    bool
+    getState();         //inline
+    uint32_t
+    getFrequency();     //inline
+    float
+    getDutycycle();     //inline
+    uint32_t
+    getPeriod_us();   //inline
+    uint32_t
+    getClockperiod_us();   //inline
+
+
+    uint32_t const FREQ_MAX;
+
+    template <typename T>
+    static T velidateRange(T const arg_val, T const arg_min, T const arg_max);
+
+private:
+    void init();
+    
+    /// Frequency of the Carrier Pulse (Hz)
+    uint32_t m_freq;
+
+    /// Duty cycle
+    float m_duty;
+    
+    /// Period
+    uint32_t m_period_us;
+
+    /// GCD of the pulse period and pulse width
+    uint32_t m_clock_period_us;
+    
+    /** Period per clock period
+     *
+     *  The unit is what times the clock tickes
+     */
+    uint32_t m_period_pcp;
+    
+    /// Timing [us] a pulse rising within a period [us]
+    static uint32_t const m_raising = 0;
+    
+    /** Timing [us] a pulse falling within a period [us]
+     *
+     *  Calculated in init()
+     */
+    uint32_t m_falling;
+
+    /// Flag if a palse is raised (High) or not (Low)
+    bool m_pulsestate;
+
+    /** Called back as clock incremented
+     *
+     *  \arg <pulsestate> indicate whther pulse
+     *  (not clock pulse but one of pulse train) has risen/fallen
+     */
+    Callback<void(bool)> m_callback_asClock;
+
+    /** Called back as a pulse rising/falling
+     *
+     *  \arg <pulsestate> indicate whther pulse has risen/fallen
+     */
+    Callback<void(bool)> m_callback_asPulseEdge;
+
+    static void doNothing(bool arg_b) {;}
+
+};
+#endif
\ No newline at end of file