Revision 2:d9f806076779, committed 2021-08-01

Comitter:

gagarinlg

Date:

Sun Aug 01 17:36:27 2021 +0000

Parent:

1:1ec4525ad0cf

Commit message:

done

Changed in this revision

--- a/PwmInRC.lib	Sun Jul 25 18:05:13 2021 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-https://os.mbed.com/users/pHysiX/code/PwmInRC/#2a58e3363242

--- a/USBJoystick.lib	Sun Jul 25 18:05:13 2021 +0000
+++ b/USBJoystick.lib	Sun Aug 01 17:36:27 2021 +0000
@@ -1,1 +1,1 @@
-https://os.mbed.com/users/gagarinlg/code/USBJoystick_/#f44ae6479bfe
+https://os.mbed.com/users/gagarinlg/code/USBJoystick_/#1f1c9178c55e

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/buffer_builder.hpp	Sun Aug 01 17:36:27 2021 +0000
@@ -0,0 +1,262 @@
+/*
+ * buffer_builder.hpp
+ *
+ *  Created on: Nov 25, 2011
+ *      Author: premmers
+ */
+
+#ifndef BUFFER_BUILDER_HPP_
+#define BUFFER_BUILDER_HPP_
+
+#include <vector>
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+//#include "utilities.h"
+
+class buffer_builder
+{
+public:
+    static inline void put(uint8_t *&p, uint8_t &bitoffset, uint8_t fieldlen, uint32_t value) {
+
+        assert(bitoffset < 8);
+        assert(fieldlen <= 32);
+
+        uint32_t mask = (1U<<fieldlen)-1;
+        value &= mask;
+
+        uint8_t b;
+
+        // first byte
+        if (bitoffset > 0)
+        {
+            uint8_t remaining_bits = 8-bitoffset;
+            int8_t unused_bits = int8_t(remaining_bits - fieldlen);
+            if (unused_bits > 0)
+            {
+                b = *p;
+                b &= ~(mask << unused_bits);
+                b |= value << unused_bits;
+                *p = b;
+                bitoffset += fieldlen;
+                return;
+            }
+
+            // all the remaining bits in first byte are in use
+            fieldlen -= remaining_bits;
+            b = *p;
+            b &= ~(mask >> fieldlen);
+            b |= value >> fieldlen;
+            *p++ = b;
+            bitoffset = 0;
+        }
+
+        // middle section (whole bytes)
+        while (fieldlen >= 8)
+        {
+            fieldlen -= 8;
+            *p++ = (value >> fieldlen) & 0xFF;
+        }
+
+        // last byte
+        if (fieldlen > 0)
+        {
+            b = *p;
+            b &= 0xFFU >> fieldlen;
+            b |= value << (8-fieldlen);
+            *p = b;
+            bitoffset = fieldlen;
+        }
+    }
+
+    static inline void put_u8(uint8_t *&p, uint8_t b)
+    {
+        *p++ = b;
+    }
+    static inline void put_u16(uint8_t *&p, uint16_t w)
+    {
+        *p++ = (uint8_t)(w>> 8);
+        *p++ = (uint8_t)(w);
+    }
+    static inline void put_u16le(uint8_t *&p, uint16_t w)
+    {
+        *p++ = (uint8_t)(w);
+        *p++ = (uint8_t)(w>> 8);
+    }
+    static inline void put_u32(uint8_t *&p, uint32_t d)
+    {
+        *p++ = (uint8_t)(d>>24);
+        *p++ = (uint8_t)(d>>16);
+        *p++ = (uint8_t)(d>> 8);
+        *p++ = (uint8_t)(d);
+    }
+    static inline void put_u32le(uint8_t *&p, uint32_t d)
+    {
+        *p++ = (uint8_t)(d);
+        *p++ = (uint8_t)(d>> 8);
+        *p++ = (uint8_t)(d>>16);
+        *p++ = (uint8_t)(d>>24);
+    }
+    static inline void put_u64(uint8_t *&p, uint64_t d)
+    {
+        *p++ = (uint8_t)(d>>56);
+        *p++ = (uint8_t)(d>>48);
+        *p++ = (uint8_t)(d>>40);
+        *p++ = (uint8_t)(d>>32);
+        *p++ = (uint8_t)(d>>24);
+        *p++ = (uint8_t)(d>>16);
+        *p++ = (uint8_t)(d>> 8);
+        *p++ = (uint8_t)(d);
+    }
+    static inline void put_u64le(uint8_t *&p, uint64_t d)
+    {
+        *p++ = (uint8_t)(d);
+        *p++ = (uint8_t)(d>> 8);
+        *p++ = (uint8_t)(d>>16);
+        *p++ = (uint8_t)(d>>24);
+        *p++ = (uint8_t)(d>>32);
+        *p++ = (uint8_t)(d>>40);
+        *p++ = (uint8_t)(d>>48);
+        *p++ = (uint8_t)(d>>56);
+    }
+    static inline void put(uint8_t *&p, const uint8_t *data, size_t len)
+    {
+        memcpy(p, data, len);
+        p += len;
+    }
+
+    static inline void put_u8(std::vector<uint8_t> &v, uint8_t b)
+    {
+        v.push_back(b);
+    }
+    static inline void put_u16(std::vector<uint8_t> &v, uint16_t w)
+    {
+        v.push_back((uint8_t)(w>> 8));
+        v.push_back((uint8_t)(w));
+    }
+    static inline void put_u16le(std::vector<uint8_t> &v, uint16_t w)
+    {
+        v.push_back((uint8_t)(w));
+        v.push_back((uint8_t)(w>> 8));
+    }
+    static inline void put_u32(std::vector<uint8_t> &v, uint32_t d)
+    {
+        v.push_back((uint8_t)(d>>24));
+        v.push_back((uint8_t)(d>>16));
+        v.push_back((uint8_t)(d>> 8));
+        v.push_back((uint8_t)(d));
+    }
+    static inline void put_u32le(std::vector<uint8_t> &v, uint32_t d)
+    {
+        v.push_back((uint8_t)(d));
+        v.push_back((uint8_t)(d>> 8));
+        v.push_back((uint8_t)(d>>16));
+        v.push_back((uint8_t)(d>>24));
+    }
+    static inline void put_u64(std::vector<uint8_t> &v, uint64_t d)
+    {
+        v.push_back((uint8_t)(d>>56));
+        v.push_back((uint8_t)(d>>48));
+        v.push_back((uint8_t)(d>>40));
+        v.push_back((uint8_t)(d>>32));
+        v.push_back((uint8_t)(d>>24));
+        v.push_back((uint8_t)(d>>16));
+        v.push_back((uint8_t)(d>> 8));
+        v.push_back((uint8_t)(d));
+    }
+    static inline void put_u64le(std::vector<uint8_t> &v, uint64_t d)
+    {
+        v.push_back((uint8_t)(d));
+        v.push_back((uint8_t)(d>> 8));
+        v.push_back((uint8_t)(d>>16));
+        v.push_back((uint8_t)(d>>24));
+        v.push_back((uint8_t)(d>>32));
+        v.push_back((uint8_t)(d>>40));
+        v.push_back((uint8_t)(d>>48));
+        v.push_back((uint8_t)(d>>56));
+    }
+    static inline void put(std::vector<uint8_t> &v, const uint8_t *data, size_t len)
+    {
+        v.insert(v.end(), data, data+len);
+    }
+
+    static inline void fill(std::vector<uint8_t> &v, uint8_t value, size_t len)
+    {
+        v.resize(v.size()+len, value);
+    }
+
+    explicit buffer_builder(std::vector<uint8_t> &v) : data(v), initial_size(v.size()) {}
+    buffer_builder(const buffer_builder& rhs) : data(rhs.data), initial_size(rhs.data.size()) {}
+
+    size_t written() const
+    {
+        return data.size() - initial_size;
+    }
+    void put_u8(uint8_t b)      { put_u8(data, b); }
+    void put_u16(uint16_t w)    { put_u16(data, w); }
+    void put_u16le(uint16_t w)  { put_u16le(data, w); }
+    void put_u32(uint32_t w)    { put_u32(data, w); }
+    void put_u32le(uint32_t w)  { put_u32le(data, w); }
+    void put_u64(uint64_t w)    { put_u64(data,w); }
+    void put_u64le(uint64_t w)  { put_u64le(data,w); }
+#ifdef __ADSPBLACKFIN__
+    void put_float(float f)     { put_u32(*(uint32_t*)&f); }
+    void put_floatle(float f)   { put_u32le(*(uint32_t*)&f); }
+    void put_double(double d)   { put_u64(*(uint64_t*)&d); }
+    void put_doublele(double d) { put_u64le(*(uint64_t*)&d); }
+    COMPILETIME_ASSERT(sizeof(double)==8);
+    COMPILETIME_ASSERT(sizeof(float)==4);
+#endif
+    void put(const uint8_t *p, size_t len) { put(data, p, len); }
+    void put(const void *p, size_t len) { put(data, (const uint8_t*)p, len); }
+    void fill(uint8_t v, size_t len) { fill(data, v, len); }
+    uint8_t* putptr(size_t len)
+    {
+        size_t s = data.size();
+        data.insert(data.end(), len, uint8_t());
+        return &data[s];
+    }
+
+    template<typename T, void (*F)(uint8_t *&, T)>
+    class ref
+    {
+    public:
+        void operator=(T d)
+        {
+            uint8_t* p = &data[index];
+            F(p, d);
+        }
+    private:
+        friend class buffer_builder;
+        ref(std::vector<uint8_t> &data, size_t index) : data(data), index(index) {}
+        std::vector<uint8_t> &data;
+        size_t index;
+    };
+
+    typedef ref<uint8_t,  &buffer_builder::put_u8>    ref_u8;
+    typedef ref<uint16_t, &buffer_builder::put_u16>   ref_u16;
+    typedef ref<uint16_t, &buffer_builder::put_u16le> ref_u16le;
+    typedef ref<uint32_t, &buffer_builder::put_u32>   ref_u32;
+    typedef ref<uint32_t, &buffer_builder::put_u32le> ref_u32le;
+    typedef ref<uint64_t, &buffer_builder::put_u64>   ref_u64;
+    typedef ref<uint64_t, &buffer_builder::put_u64le> ref_u64le;
+
+    ref_u8    put_ref_u8()    { ref_u8    r(data, data.size()); put_u8(0);    return r; }
+    ref_u16   put_ref_u16()   { ref_u16   r(data, data.size()); put_u16(0);   return r; }
+    ref_u16le put_ref_u16le() { ref_u16le r(data, data.size()); put_u16le(0); return r; }
+    ref_u32   put_ref_u32()   { ref_u32   r(data, data.size()); put_u32(0);   return r; }
+    ref_u32le put_ref_u32le() { ref_u32le r(data, data.size()); put_u32le(0); return r; }
+    ref_u64   put_ref_u64()   { ref_u64   r(data, data.size()); put_u64(0);   return r; }
+    ref_u64le put_ref_u64le() { ref_u64le r(data, data.size()); put_u64le(0); return r; }
+
+    std::vector<uint8_t> &getData() { return data; }
+private:
+    buffer_builder();
+    std::vector<uint8_t> &data;
+    size_t initial_size;
+};
+
+
+
+#endif /* BUFFER_BUILDER_HPP_ */

--- a/main.cpp	Sun Jul 25 18:05:13 2021 +0000
+++ b/main.cpp	Sun Aug 01 17:36:27 2021 +0000
@@ -6,7 +6,6 @@
 DigitalOut myled3(LED3);
 DigitalOut myled4(LED4);
 
-InterruptIn mybutton(USER_BUTTON);
 InterruptIn ppm(D7);
 USBJoystick joystick;
 double tempo = 0.3; // LED blinking delay
@@ -15,7 +14,7 @@
 
 volatile int period;
 
-int8_t channels[9] ={0,0,0,0,0,0,0,0,0};
+int16_t channels[9] ={0,0,0,0,0,0,0,0,0};
 uint8_t curChannel = 0;
 bool done=false;
 
@@ -27,82 +26,61 @@
     timer.reset();
     if(period > 3000)
     {
-        done = true;
         curChannel = 0;
+        done=true;
         return;
     }
     
-    period -= 1050;
-    if(period  < 0)
-        period = 0;
-    if(period > 1100)
-        period = 1100;
-        
-    period*=255;
-    period/=1100;
-    int buf = period;
+    period -= 1580;
+ /*   if(period  < -550)
+        period = -550;
+    if(period > 550)
+        period = 550;
+  */      
+ /*   period*=255;
+    period/=1100;*/
+/*    int buf = period;
     int val = buf-128;
     if(val < -127)
         val = -127;
     if(val > 128)
         val = 128;
     channels[curChannel] = -val;
+    */
+    if(curChannel < 9)
+        channels[curChannel] = -period; 
     curChannel++;
     myled1=1;
     myled2=0;
 }
 
-// Change LEDs blinking frequency
-void change_blinking_frequency() {
-    if (tempo == 0.3) // If leds have low frequency
-        tempo = 0.1;  // Set the fast frequency
-    else              // If leds have fast frequency
-        tempo = 0.3;  // Set the low frequency
-}
-
 int main() {
     // All LEDs are OFF
     myled1 = 0;
     myled2 = 0;
     myled3 = 0;
     myled4 = 0;
+    ppm.rise(&rise);
     timer.start();
-    ppm.rise(&rise);
 
-    // Change LEDs blinking frequency when button is pressed
-    mybutton.fall(&change_blinking_frequency);
-    ppm.rise(&rise);
-
-uint32_t count = 0;
-    int8_t thr = 0;
-    int8_t rudder = 0;
-    int8_t x=0;
-    int8_t y=0;
+    uint32_t count = 0;
+    int16_t thr = 0;
+    int16_t rudder = 0;
+    int16_t x=0;
+    int16_t y=0;
 
     while(1) {
-        wait(0.001);  // wait tempo
-
-     /**
-       * Write state of the joystick
-       *
-       * @param t throttle position
-       * @param r rudder position         
-       * @param x x-axis position
-       * @param y y-axis position
-       * @param buttons buttons state
-       * @param hat hat state 0 (up), 1 (right, 2 (down), 3 (left) or 4 (neutral)
-       * @returns true if there is no error, false otherwise
-       */
-
-    if(done)
-    {
-        thr = channels[0];
-        rudder = channels[1];
-        x = channels[2];
-        y = channels[3];
-        done = 0;
-    }
-    joystick.update(thr, rudder, x, y, count, 0);
+       // wait(1.000);  // wait tempo
+      
+        if(done)
+        {
+            thr = channels[0];
+            rudder = channels[1];
+            x = channels[2];
+            y = channels[3];
+            done = 0;
+            joystick.update(thr, rudder, x, y, channels[4], channels[5], channels[6], channels[7], count&0, 0);
+        }
 
         count++;
     }