Diff: Serial_Writer.h

Revision:

6:ef64b02d2ff5

Parent:

5:47cf103f9223

diff -r 47cf103f9223 -r ef64b02d2ff5 Serial_Writer.h
--- a/Serial_Writer.h	Fri May 14 10:31:01 2021 +0000
+++ b/Serial_Writer.h	Thu May 20 15:23:17 2021 +0000
@@ -6,97 +6,105 @@
 class Serial_Writer
 {
 public:
-    Serial_Writer(PinName TxPin,PinName RxPin,int baudrate);
+    Serial_Writer(PinName txPin,PinName rxPin,int baudrate);
     
-    template<typename T,std::size_t N>void write(T (&send)[N],int delay){
-        writer<T,N>::write(send,delay,_Serial);
+    int readable();
+    void attach(void (*fptr)());
+    
+    template<typename T,std::size_t N>void write(T (&send)[N]){
+        writer<T,N>::write(send,_Serial);
     }
     
-    template <typename R,std::size_t S>int receive(R (&get)[S]){
-        return receiver<R,S>::receive(get,_Serial);
+    template <typename T,std::size_t N>int receive(T (&get)[N]){
+        return receiver<T,N>::receive(get,_Serial);
     }
     
     Serial _Serial;
     
 private:
 //--------------------------------------write--------------------------------------//
+
+    //下記の型以外の型のときの処理
     template <typename T,std::size_t N>
     struct writer{
-        static void write(T (&send)[N],int delay,Serial &_Serial){
-            int num=sizeof(send);
-            char buffer[num+2];
-            for (int i=1,k=0;i<=num;k++){
-                for(int _bitNum=sizeof(send[0])-1;_bitNum>=0;i++,_bitNum--)buffer[i]=(send[k]>>(8*_bitNum))&0xFF;
+        static void write(T (&send)[N],Serial &_Serial){
+            const int byte=sizeof(send);
+            char buffer[byte+2];
+            for (int i=1,k=0;i<=byte;k++){
+                for(int byte_shift=sizeof(send[0])-1;byte_shift>=0;i++,byte_shift--)buffer[i]=(send[k]>>(8*byte_shift))&0xFF;
             }
             buffer[0]='[';
-            buffer[num+1]=']';
+            buffer[byte+1]=']';
             for (int p=0;p<sizeof(buffer);p++)_Serial.putc(buffer[p]);
-            wait_ms(delay);
         }
     };
     
+    //doubleのときの処理
     template<std::size_t N>
     struct writer<double,N>{
-        static void write(double (&send)[N],int delay,Serial &_Serial){
-            int numer=sizeof(send)/sizeof(send[0]);
-            int send_c[numer];
-            for(int _n=0;_n<numer;_n++)send_c[_n]=int(send[_n]*100);
-            writer<int,N>::write(send_c,delay,_Serial);
+        static void write(double (&send)[N],Serial &_Serial){
+            const int arrays_num=sizeof(send)/sizeof(send[0]);
+            long long send_long[arrays_num];
+            for(int j=0;j<arrays_num;j++)send_long[j]=send[j]*10000000;//小数点以下7桁、最大11桁(指数部4095)まで対応(doubleの有効桁数を参照)
+            writer<long long,N>::write(send_long,_Serial);
         }
     };
     
+    //floatのときの処理
     template<std::size_t N>
     struct writer<float,N>{
-        static void write(float (&send)[N],int delay,Serial &_Serial){
-            int numer=sizeof(send)/sizeof(send[0]);
-            int send_c[numer];
-            for(int _n=0;_n<numer;_n++)send_c[_n]=int(send[_n]*100);
-            writer<int,N>::write(send_c,delay,_Serial);
+        static void write(float (&send)[N],Serial &_Serial){
+            const int arrays_num=sizeof(send)/sizeof(send[0]);
+            long long send_long[arrays_num];
+            for(int j=0;j<arrays_num;j++)send_long[j]=send[j]*10000000;//小数点以下7桁、最大10桁(指数部255)まで対応(floatの有効桁数を参照)
+            writer<long long,N>::write(send_long,_Serial);
         }
     };
     
+    
 //--------------------------------------end--------------------------------------//
 
 //------------------------------------receive------------------------------------//
     
-    template <typename R,std::size_t S>
+    //下記の型以外の型のときの処理
+    template <typename T,std::size_t N>
     struct receiver{
-        static int receive(R (&get)[S],Serial &_Serial){
-            int num=sizeof(get);
-            int num_0=sizeof(get[0]);
-            char buffer[num+2];
-            if (_Serial.readable()){
-                for(int i=0;i<sizeof(buffer);i++){
-                    buffer[i]=_Serial.getc();
-                    if(buffer[0]!='[')return -1;
+        static int receive(T (&get)[N],Serial &_Serial){
+            const int byte=sizeof(get);
+            const int byte_0=sizeof(get[0]);
+            char buffer[byte+2];
+            for(int i=0;i<sizeof(buffer);i++){
+                buffer[i]=_Serial.getc();
+                if(buffer[0]!='[')return -1;
+            }
+            if(buffer[byte+1]==']'){
+                for (int j=0;j<(byte/byte_0);j++)get[j]=0x0;
+                for (int p=1,k=0;p<=byte;k++){
+                    for (int byte_shift=byte_0-1;byte_shift>=0;p++,byte_shift--)get[k]|=buffer[p]<<(8*byte_shift);
                 }
-                if(buffer[num+1]==']'){
-                    for (int s=0;s<(num/num_0);s++)get[s]=0x0;
-                    for (int p=1,k=0;p<=num;k++){
-                        for (int _byte=num_0-1;_byte>=0;p++,_byte--)get[k]|=buffer[p]<<(8*_byte);
-                    }
-                    return 0;//正常終了
-                }else return -1;//異常終了1(正しく受信できていない)
-            }else return -2;//異常終了2(受信するものがない)
+                return 0;//正常終了
+            }else return -1;//異常終了1(正しく受信できていない)
         }
     };
     
-    template <std::size_t S>
-    struct receiver<double,S>{
-        static int receive(double (&get)[S],Serial &_Serial){
-            int geter[S];
-            int _return=receiver<int,S>::receive(geter,_Serial);
-            for (int _g_=0;_g_<sizeof(geter)/sizeof(geter[0]);_g_++)get[_g_]=double(geter[_g_])/100.0;
+    //doubleのときの処理
+    template <std::size_t N>
+    struct receiver<double,N>{
+        static int receive(double (&get)[N],Serial &_Serial){
+            long long arrays[N];
+            int _return=receiver<long long,N>::receive(arrays,_Serial);
+            for (int l=0;l<sizeof(arrays)/sizeof(arrays[0]);l++)get[l]=double(arrays[l])/10000000.0;
             return _return;
         }
     };
     
-    template <std::size_t S>
-    struct receiver<float,S>{
-        static int receive(float (&get)[S],Serial &_Serial){
-            int geter[S];
-            int _return=receiver<int,S>::receive(geter,_Serial);
-            for (int _g_=0;_g_<sizeof(geter)/sizeof(geter[0]);_g_++)get[_g_]=double(geter[_g_])/100.0;
+    //floatのときの処理
+    template <std::size_t N>
+    struct receiver<float,N>{
+        static int receive(float (&get)[N],Serial &_Serial){
+            long long arrays[N];
+            int _return=receiver<long long,N>::receive(arrays,_Serial);
+            for (int l=0;l<sizeof(arrays)/sizeof(arrays[0]);l++)get[l]=double(arrays[l])/10000000.0;
             return _return;
         }
     };