Example #1
0
        private void Button_Click_3(object sender, RoutedEventArgs e)
        {
            if (insert_id.Content == "")
            {
                MessageBox.Show("设备ID不可为空!");
                return;
            }
            if (insert_name.Content == "")
            {
                MessageBox.Show("绑定名称不可为空!");
                return;
            }

            // List<object[]> starsDatas = new List<object[]>();
            //starsDatas.Add(new object[] { bindid.Content, bindname.Text.Trim(remove).ToString().Trim() });


            SQLite_RW.SetData(new SQLite_DataStruct {
                DeviceID = insert_id.Content.ToString(), NickName = insert_name.Content.ToString()
            });
            List <SQLite_DataStruct> recv = SQLite_RW.GetData();

            sql_data.Items.Clear();
            for (int i = 0; i < recv.Count; i++)
            {
                sql_data.Items.Add(recv[i]);
            }
        }
Example #2
0
        public MainWindow()
        {
            InitializeComponent();
            //SoftID = SoftRandom.GetRandomString(8, true, false, true, false, "");
            //rand.Content = "ID:" + SoftID;
            //MessageBox.Show(System.AppDomain.CurrentDomain.BaseDirectory);
            Radio_Thread.Elapsed += Radio_Thread_Elapsed;
            Radio_ALLDevice_NickName_Thread.Elapsed += Radio_ALLDevice_NickName_Thread_Elapsed;
            Radio_ALLDevice_NickName_Thread.Start();
            UIthread.Start_UI_Refresh(this);
            SQLite_RW.Initial_SQLite("database");
            List <SQLite_DataStruct> recv = SQLite_RW.GetData();

            sql_data.Items.Clear();
            for (int i = 0; i < recv.Count; i++)
            {
                sql_data.Items.Add(recv[i]);
            }


            SQLite_InitData init = SQLite_RW.GetInitData();

            group.Text    = init.init_Group;
            wifi.Text     = init.init_WIFI;
            pass.Text     = init.init_PASS;
            ip.Text       = init.init_IP;
            port.Text     = init.init_port;
            serverip.Text = init.init_Server_IP;
            porttext.Text = init.init_Server_Port;
            //--------------------------------------------------------------------
            //SQLiteConnection cn = new SQLiteConnection("data source=" + "database" + ".sqlite");
            //if (cn.State != System.Data.ConnectionState.Open)
            //{
            //    cn.Open();
            //    SQLiteCommand cmd = new SQLiteCommand();
            //    cmd.Connection = cn;
            //    //cmd.CommandText = "drop TABLE system";
            //    cmd.CommandText = "INSERT INTO system VALUES('0','','','','','','','')";
            //    //cmd.CommandText = "CREATE TABLE system('ID' int,'group' string,'wifi' string,'pass' string,'ip' string,'port' string,'serverip' string,'serverport' string)";

            //    cmd.ExecuteNonQuery();



            //}
            //cn.Close();
            //-----------------------------------------------------------------------
            //errormessage.ItemsSource = lis.error_message;
            //Process.Start("speex_decoder.exe","D:\\github_project\\AncientProjects\\RadioRecoder\\WPF_Server\\RecoderServerApplication\\RecoderServerApplication\\bin\\Release\\20190623225152_HS6YX83M\\HQOBJSQZ_2019-06-23-22-52-33-000_REC.wzr");
        }
Example #3
0
 private void wificon_Click(object sender, RoutedEventArgs e)
 {
     iswifibutton = !iswifibutton;
     if (iswifibutton)
     {
         SQLite_InitData init = new SQLite_InitData();
         init.init_Group       = group.Text;
         init.init_WIFI        = wifi.Text;
         init.init_PASS        = pass.Text;
         init.init_IP          = ip.Text;
         init.init_port        = port.Text;
         init.init_Server_IP   = serverip.Text;
         init.init_Server_Port = porttext.Text;
         SQLite_RW.SetData(init);
         wificon.Content   = "Cancle..";
         calib.IsEnabled   = false;
         radiate.IsEnabled = false;
         bindb.IsEnabled   = false;
         bBegin.IsEnabled  = false;
         bEnd.IsEnabled    = false;
         bBlink.IsEnabled  = false;
         bInit.IsEnabled   = false;
         ip.IsEnabled      = false;
         port.IsEnabled    = false;
         wifi.IsEnabled    = false;
         pass.IsEnabled    = false;
         RF_DataAnalysis.Begin_RadioSend_WIFI(SoftID, wifi.Text, pass.Text, ip.Text, port.Text);
     }
     else
     {
         wificon.Content   = "Server";
         calib.IsEnabled   = true;
         radiate.IsEnabled = true;
         bindb.IsEnabled   = true;
         bBegin.IsEnabled  = true;
         bEnd.IsEnabled    = true;
         bBlink.IsEnabled  = true;
         bInit.IsEnabled   = true;
         ip.IsEnabled      = true;
         port.IsEnabled    = true;
         wifi.IsEnabled    = true;
         pass.IsEnabled    = true;
         RF_DataAnalysis.Stop_RadioSend();
     }
 }
Example #4
0
        private void Button_Click_5(object sender, RoutedEventArgs e)
        {
            for (int i = 0; i < ListeningThread.DeviceList_Thread.Count; i++)
            {
                string ID       = ListeningThread.DeviceList_Thread[i].Device_Recv_Struct.Device_ID;
                string Nickname = ListeningThread.DeviceList_Thread[i].Device_Recv_Struct.Bind_User;
                SQLite_RW.SetData(new SQLite_DataStruct {
                    DeviceID = ID, NickName = Nickname
                });
            }
            List <SQLite_DataStruct> recv = SQLite_RW.GetData();

            sql_data.Items.Clear();
            for (int i = 0; i < recv.Count; i++)
            {
                sql_data.Items.Add(recv[i]);
            }
        }
Example #5
0
        private void Button_Click_4(object sender, RoutedEventArgs e)
        {
            if (deleteid.Content == "")
            {
                MessageBox.Show("设备ID不可为空!");
                return;
            }


            SQLite_RW.DeleteData(new SQLite_DataStruct {
                DeviceID = deleteid.Content.ToString()
            });
            List <SQLite_DataStruct> recv = SQLite_RW.GetData();

            sql_data.Items.Clear();
            for (int i = 0; i < recv.Count; i++)
            {
                sql_data.Items.Add(recv[i]);
            }
        }
Example #6
0
 private void button_Click_2(object sender, RoutedEventArgs e)
 {
     if (!isStartServer)
     {
         SQLite_InitData init = new SQLite_InitData();
         init.init_Group       = group.Text;
         init.init_WIFI        = wifi.Text;
         init.init_PASS        = pass.Text;
         init.init_IP          = ip.Text;
         init.init_port        = port.Text;
         init.init_Server_IP   = serverip.Text;
         init.init_Server_Port = porttext.Text;
         SQLite_RW.SetData(init);
         lis.StartListen(int.Parse(porttext.Text), serverip.Text, int.Parse(fstext.Text), int.Parse(packge.Text), DateTime.Now.ToString("yyyyMMddHHmmss") + "_" + SoftID);
         startbutton.Content = "StopServer";
     }
     else
     {
         lis.StopListen();
         startbutton.Content = "StartServer";
     }
     isStartServer = !isStartServer;
 }
Example #7
0
        private void Button_Click_11(object sender, RoutedEventArgs e)
        {
            List <SQLite_DataStruct> recv    = SQLite_RW.GetData();
            List <string>            offline = new List <string>();
            int k = 0;

            for (int i = 0; i < ListeningThread.DeviceList_Thread.Count; i++)
            {
                string ID = ListeningThread.DeviceList_Thread[i].Device_Recv_Struct.Device_ID;
                for (int j = 0; j < recv.Count; j++)
                {
                    if (ID == recv[j].DeviceID)
                    {
                        if (json.recv.users.Count > k)
                        {
                            SQLite_RW.SetData(new SQLite_DataStruct {
                                DeviceID = ID, NickName = json.recv.users[k].nickname, UserID = json.recv.users[k].user_id
                            });
                            k++;
                        }
                        break;
                    }
                }
            }

            for (int i = 0; i < recv.Count; i++)
            {
                bool flag = false;
                for (int j = 0; j < ListeningThread.DeviceList_Thread.Count; j++)
                {
                    string ID = ListeningThread.DeviceList_Thread[j].Device_Recv_Struct.Device_ID;
                    if (ID == recv[i].DeviceID)
                    {
                        flag = true;
                        break;
                    }
                }
                if (flag == false)
                {
                    offline.Add(recv[i].DeviceID);
                }
            }

            for (int i = 0; i < offline.Count; i++)
            {
                if (json.recv.users.Count > k)
                {
                    SQLite_RW.SetData(new SQLite_DataStruct {
                        DeviceID = offline[i], NickName = json.recv.users[k].nickname, UserID = json.recv.users[k].user_id
                    });
                    k++;
                }
            }

            recv = SQLite_RW.GetData();
            sql_data.Items.Clear();
            for (int i = 0; i < recv.Count; i++)
            {
                sql_data.Items.Add(recv[i]);
            }
        }
Example #8
0
        public void ServiceFunction()
        {
            dstate = Device_State.Online;
            Device_Recv_Struct.Device_State = "待机";
            while (Thread_Loop)
            {
                try
                {
                    if (RecvData_Location > RecvData.Length - 500)
                    {
                        RecvData_Location = 0;
                    }
                    int recv = Ser.Receive(RecvData, RecvData_Location, RecvData.Length - RecvData_Location, SocketFlags.None);
                    if (recv > 0)
                    {
                        RecvData_Location += recv;
                    }
                }
                catch (Exception e)
                {
                    dstate = Device_State.Offline;
                    Device_Recv_Struct.Device_State = "离线";
                    continue;
                }
                List <TransData_Struct> lis = new List <TransData_Struct>();
                AnalysisRawData(ref RecvData, ref lis);
                foreach (var item in lis)
                {
                    object recv = State_Response_Function(item);

                    //State_DeviceInfo_refData info = SqlData as State_DeviceInfo_refData;
                    //State_ReadyToStartRecoder_refData ready = SqlData as State_ReadyToStartRecoder_refData;
                    //State_TransData_refData tdata = SqlData as State_TransData_refData;
                    //State_TransRepairData_refData rdata = SqlData as State_TransRepairData_refData;

                    //Device_Recv_Struct.Device_ID = Encoding.ASCII.GetString(item.Device_ID);

                    if (recv is State_Idle_refData idle_refdata)
                    {
                        dstate = (Device_State)idle_refdata.State;
                        Device_Recv_Struct.Bind_User = idle_refdata.Binding_User;
                        switch (dstate)
                        {
                        case Device_State.Online:
                            Device_Recv_Struct.Device_State = "待机";
                            if (WavCreate != null)
                            {
                                WavCreate.CloseAllWavFile();
                                WavCreate = null;
                            }
                            break;

                        case Device_State.Recording:
                            Device_Recv_Struct.Device_State = "录音中";
                            break;

                        case Device_State.WaitingBinding:
                            Device_Recv_Struct.Device_State = "等待绑定";
                            break;

                        case Device_State.WaitingRecording:
                            Device_Recv_Struct.Device_State = "等待录音";
                            break;

                        case Device_State.ErrorCorrection:
                            Device_Recv_Struct.Device_State = "检查错误中";
                            break;
                        }
                    }
                    if (recv is State_Bingding_Check_refData bind_refdata)
                    {
                        Device_Recv_Struct.Bind_User = bind_refdata.Binding_User;
                        byte[] confirm = Construct_Data_Packet(new TransData_Struct(Protocol_Keyword.State_Binding_Check_Confirm, item.Device_ID, new byte[] { }));
                        Ser.Send(confirm);
                    }
                    if (recv is State_ReadyToStartRecoder_refData ready_refdata)
                    {
                        Device_Recv_Struct.Device_State = "等待录音";
                        dstate = Device_State.WaitingRecording;
                        if (WavCreate == null)
                        {
                            // Directory.CreateDirectory(Dir +"\\"+ Device_Recv_Struct.Device_ID);
                            Directory.CreateDirectory(Dir);
                            string userid = "";
                            List <SQLite_DataStruct> sqldata = SQLite_RW.GetData();
                            for (int i = 0; i < sqldata.Count; i++)
                            {
                                if (sqldata[i].DeviceID == Device_Recv_Struct.Device_ID)
                                {
                                    userid = sqldata[i].UserID;
                                    break;
                                }
                            }
                            WavCreate = new SrcDataCutApart(Fre, Sec, Dir + "\\" + userid + "_" + Device_Recv_Struct.Device_ID + "_");
                        }
                    }
                    if (recv is State_TransData_refData trans_refdata)
                    {
                        Device_Recv_Struct.Device_State = "录音中";
                        dstate = Device_State.Recording;
                        if (WavCreate != null && trans_refdata.wav_data != null)
                        {
                            WavCreate.WriteWavData(trans_refdata.wav_data, trans_refdata.Start_Index, trans_refdata.Init_Time);
                            Device_Recv_Struct.Error = WavCreate.DetailedErrorData();
                        }
                    }
                    if (recv is State_TransRepairData_refData repair_refdata)
                    {
                        if (WavCreate != null)
                        {
                            WavCreate.WriteWavData(repair_refdata.Repair_wav_data, repair_refdata.Repair_Start_Index, repair_refdata.Init_Time);
                            Device_Recv_Struct.Error = WavCreate.DetailedErrorData();
                        }
                    }
                    if (dstate == Device_State.Recording || dstate == Device_State.ErrorCorrection)
                    {
                        List <Error_Statistical> list_error = Device_Recv_Struct.Error;
                        if (list_error == null)
                        {
                            continue;
                        }
                        if (dstate == Device_State.ErrorCorrection && WavCreate.GetAllWav_ERROR_Number() == 0)
                        {
                            byte[] recvdata = Construct_Data_Packet(new TransData_Struct(Protocol_Keyword.State_Idle, item.Device_ID, new byte[] { }));
                            Ser.Send(recvdata);
                        }
                        for (int i = 0; i < list_error.Count; i++)
                        {
                            bool isloop = false;
                            for (int j = 0; j < list_error[i].errorlist.Count; j++)
                            {
                                uint   start   = list_error[i].errorlist[j].start_location;
                                uint   end     = list_error[i].errorlist[j].end_location;
                                byte[] confirm = Construct_Data_Packet(new TransData_Struct(Protocol_Keyword.State_FixDataRequest, item.Device_ID,
                                                                                            new byte[]
                                {
                                    (byte)(start >> 24),
                                    (byte)(start >> 16),
                                    (byte)(start >> 8),
                                    (byte)(start),
                                    (byte)(end >> 24),
                                    (byte)(end >> 16),
                                    (byte)(end >> 8),
                                    (byte)(end),
                                }));
                                Ser.Send(confirm);
                                isloop = true;
                                break;
                            }
                            if (isloop)
                            {
                                break;
                            }
                        }
                    }
                }
            }
        }