void GetValues(ref float p, ref float r)
 {
     float []valores;
     FlightPlanUSB ikarus = new FlightPlanUSB();
     if (ikarus.IsOpen())
     {
         valores = ikarus.ReadADCs();
         ikarus.Close();
         p = valores[(int)FlightPlanUSB.ADC_VALUES.CO_X];
         r = valores[(int)FlightPlanUSB.ADC_VALUES.CO_Y];
     }
     else
     {
         p = 1.66f;
         r = 1.66f;
         //MessageBox.Show("No esta conectado!");
     }
  }
 float GetValue(FlightPlanUSB.ADC_VALUES canal)
 {
     float valor;
     FlightPlanUSB ikarus = new FlightPlanUSB();
     if (ikarus.IsOpen())
     {
         valor = ikarus.ReadADCs(canal);
         ikarus.Close();
     }
     else
     {
         if (me.Idioma == 0)
             MessageBox.Show("No esta conectado!");
         else
             MessageBox.Show("Not connected!");
         valor = 0.0f;
     }
     return valor;
 }
        private void timer1_Tick(object sender, EventArgs e)
        {
            while (!planUSB.IsOpen())
            {
                planUSB = new FlightPlanUSB();
                Thread.Sleep(100);
            }
            if (planUSB.IsOpen())
            {
                labelStatus.Text = "Connected!";
                labelStatus.ForeColor = Color.Green;
                sconfig = planUSB.ReadConfig();
                //sconfig.offsetX = 0x2C;// &0x3f;
                //sconfig.offsetY = 0x15;//&0x1f;
                try
                {
                    numericUpDownOffsetX.Value = sconfig.offsetX;
                    numericUpDownOffsetY.Value = sconfig.offsetY;
                    numericUpDownBattCapacity.Value = (decimal)sconfig.total_mAh;

                    numericUpDownHomeAltitude.Value = (decimal)sconfig.HomeAltitude;
                    textBoxHomeLat.Text = sconfig.HomeLat.ToString();
                    textBoxHomeLon.Text = sconfig.HomeLon.ToString();

                    numericUpDownCellsBatt1.Value = sconfig.cellsBatt1;
                    numericUpDownCellsBatt2.Value = sconfig.cellsBatt2;
                    if (sconfig.cellAlarm < 3.0f)
                        sconfig.cellAlarm = 3.0f;
                    numericUpDownCellAlarm.Value = (decimal)sconfig.cellAlarm;

                    numericUpDownAlarmAltitude.Value = (decimal)sconfig.altitudeAlarm;
                    numericUpDownAlarmDistance.Value = (decimal)sconfig.distanceAlarm;
                    numericUpDownAlarmLowSpeed.Value = (decimal)sconfig.lowSpeedAlarm;
                    numericUpDownWptRange.Value = (decimal)sconfig.WptRange;
            
                    updateForm();
                } catch (Exception){}
                timer1.Enabled = false;
                panel1.Enabled = true;
            }
        }
        private void buttonFIN_Click(object sender, EventArgs e)
        {
            FlightPlanUSB ikarus = new FlightPlanUSB();
            if (ikarus.IsOpen())
            {
                IkarusBasicConfig cfg = ikarus.ReadConfig();
                cfg.rssi_min = (float)numericUpDownRSSImin.Value;
                cfg.rssi_max = (float)numericUpDownRSSImax.Value;
                ikarus.WriteConfig(cfg);

                ikarus.Close();
            }
            else if (me.Idioma == 0)
            {
                MessageBox.Show("Error abriendo disp USB");
            }
            else
            {
                MessageBox.Show("Error opening USB device!");
            }
            this.Close();
        }
        private void button9_Click(object sender, EventArgs e)
        {
            FlightPlanUSB fp = new FlightPlanUSB();
            if (fp.IsOpen())
            {
                IkarusCompleteConfig full = new IkarusCompleteConfig();

                full.IkarusBasicConfig = fp.ReadConfig();
                full.IkarusAutopilotConfig = fp.ReadConfigAutopilot();
                full.IkarusScreenConfig1 = fp.ReadScreen(0);
                full.IkarusScreenConfig2 = fp.ReadScreen(1);
                full.IkarusScreenConfig3 = fp.ReadScreen(2);
                full.IkarusScreenConfigFailSafe = fp.ReadScreen(3);
                full.IkarusScreenConfigResumen = fp.ReadScreen(4);
                fp.Close();

                SaveFileDialog dlg = new SaveFileDialog();
                dlg.ShowDialog();
                if (dlg.FileName != "")
                {
                    full.SaveToXml(dlg.FileName);
                    if (me.Idioma == 0)
                        MessageBox.Show("Guardado con exito!");
                    else
                        MessageBox.Show("Saved Succesful!");

                }
                else
                    if (me.Idioma == 0)
                        MessageBox.Show("No se ha salvado!");
                    else
                        MessageBox.Show("Not saved!");
            }
            else
                if (me.Idioma == 0)
                    MessageBox.Show("No esta conectado!");
                else
                    MessageBox.Show("Not connected!");
        }
Exemple #6
0
        private void button8_Click(object sender, EventArgs e)
        {
            FlightPlanUSB planUSB = new FlightPlanUSB();
            if (planUSB.IsOpen())
            {
                int[] servos = planUSB.ReadServosRAW();

                if (comboAilCH.SelectedIndex > 0)
                {
                    numericUpDownServoAILcenter.Value =servos[comboAilCH.SelectedIndex - 1];
                }
                if (comboEleCH.SelectedIndex > 0)
                {
                    numericUpDownServoELEcenter.Value = servos[comboEleCH.SelectedIndex - 1];
                }
                /*
                if (comboThrCH.SelectedIndex > 0)
                {
                    numericUpDownServoTHRcenter.Value = servos[comboThrCH.SelectedIndex - 1];
                }
                */
                if (comboTailCH.SelectedIndex > 0)
                {
                    numericUpDownServoTAILcenter.Value = servos[comboTailCH.SelectedIndex - 1];
                }

                if (comboPanCH.SelectedIndex > 0)
                {
                    numericUpDownServoPANcenter.Value = servos[comboPanCH.SelectedIndex - 1];
                }
                if (comboTiltCH.SelectedIndex > 0)
                {
                    numericUpDownServoTILTcenter.Value = servos[comboTiltCH.SelectedIndex - 1];
                }

                if (comboAil2CH.SelectedIndex > 0)
                {
                    numericUpDownServoAIL2center.Value = servos[comboAil2CH.SelectedIndex - 1];
                }
                planUSB.Close();
            }
            else if (me.Idioma == 0)
            {
                MessageBox.Show("No se puede abrir dispositivo Ikarus OSD");
            }
            else
            {
                MessageBox.Show("Cannot open Ikarus OSD device");
            }

        }
 private void timer1_Tick(object sender, EventArgs e)
 {
     if (!ikarus.IsOpen())
     {
         ikarus = new FlightPlanUSB();
     }
     else
     {
         valores = ikarus.ReadServosRAW();
         UpdateValues();
     }
     
 }
 private void button5_Click(object sender, EventArgs e)
 {
     FlightPlanUSB ikarus = new FlightPlanUSB();
     if (ikarus.IsOpen())
     {
         float v1, v2;
         if (float.TryParse(textBoxMotorI1.Text, out v1) && float.TryParse(textBoxMotorI2.Text, out v2))
         {
             float gain = (float)(numericUpDownMotorI1.Value - numericUpDownMotorI2.Value) / (v1 - v2);
             //float offset = -(float)numericUpDownMotorI1.Value - gain * float.Parse(textBoxMotorI1.Text);
             float offset = float.Parse(textBoxMotorI1.Text) - (float)numericUpDownMotorI1.Value/ gain;
             IkarusBasicConfig cfg = ikarus.ReadConfig();
             cfg.sensorI_gain = gain;
             cfg.sensorI_offset = offset;
             ikarus.WriteConfig(cfg);
             if (me.Idioma == 0)
             {
                 MessageBox.Show("Valores guardados correctamente");
             }
             else
             {
                 MessageBox.Show("Values saved sucesfully");
             }
         }
         else if (me.Idioma == 0)
         {
             MessageBox.Show("Error en los valores capturados");
         }
         else
         {
             MessageBox.Show("Error in captured values");
         }
         ikarus.Close();
     }
     else if (me.Idioma == 0)
     {
         MessageBox.Show("Error abriendo disp USB");
     }
     else
     {
         MessageBox.Show("Error opening USB device!");
     }
     ikarus.Close();
 }
Exemple #9
0
 private void button2_Click(object sender, EventArgs e)
 {
     FlightPlanUSB fp = new FlightPlanUSB();
     if (fp.IsOpen())
     {
         hud = fp.ReadScreen(comboBoxScreenSlot.SelectedIndex);
         fp.Close();
         UpdateTextBoxes();
         pictureBox1.Invalidate();
     }
     else
         MessageBox.Show("Not conected!");
    
 }
Exemple #10
0
        private void button5_Click(object sender, EventArgs e)
        {
            try
            {
                fc = new FileCharset(textBox1.Text);
            }
            catch (Exception)
            {
                MessageBox.Show("Error abriendo fichero. Usando buildin");
                MemoryStream stream = new MemoryStream(global::UAVConsole.Properties.Resources.Ikarus);
                fc= new FileCharset(new StreamReader(stream));
            }

            fp = new FlightPlanUSB();
            timer1.Interval = 200;
            t_i = 0;
            if (fp.IsOpen())
                timer1.Enabled = true;
            else
                MessageBox.Show("Not conected!");
        }
        private void button2_Click(object sender, EventArgs e)
        {
            if (device == Devices.OSD)
            {
                FlightPlanUSB dev = new FlightPlanUSB();
                if (dev.IsOpen())
                {
                    dev.FirmwareUpdate();
                    dev.Close();
                }
                else
                {
                    if (me.Idioma == 0)
                        MessageBox.Show("Error abriendo USB");
                    else
                        MessageBox.Show("Error opening USB");
                }
            }
            else if (device == Devices.Uplink)
            {
                EmisoraUSB dev = new EmisoraUSB();
                if (dev.IsOpen())
                {
                    dev.UpdateFirmware();
                    dev.Close();
                }
                else
                {
                    if (me.Idioma == 0)
                        MessageBox.Show("Error abriendo USB");
                    else
                        MessageBox.Show("Error opening USB");
                }
            }
            else if (device == Devices.AntTracker)
            {
                AntenaTracker dev = new AntenaTracker();
                if (dev.IsOpen())
                {
                    dev.UpdateFirmware();
                    dev.Close();
                }
                else
                {
                    if (me.Idioma == 0)
                        MessageBox.Show("Error abriendo USB");
                    else
                        MessageBox.Show("Error opening USB");
                }

            }
        }
Exemple #12
0
 private void button1_Click(object sender, EventArgs e)
 {
     FlightPlanUSB fp = new FlightPlanUSB();
     if (fp.IsOpen())
     {
         fp.WriteScreen(comboBoxScreenSlot.SelectedIndex,hud);
         fp.Close();
     }
     else
         MessageBox.Show("Not conected!");
 }
        private void button6_Click(object sender, EventArgs e)
        {
            List<WayPoint> miRuta = mapControl1.ruta;
            FlightPlanUSB fp = new FlightPlanUSB();
            if (fp.IsOpen())
            {
                int max = fp.ReadMaxWpts();
                miRuta.Clear();

                for (int i = 0; i < max && max < 0xff; i++)
                {
                    miRuta.Add(fp.ReadWpt(i));
                }
                mapControl1.Refresh();
                fp.Close();
                listBoxUpdate();
            }
        }
        private void button3_Click(object sender, EventArgs e)
        {
            FlightPlanUSB ikarus = new FlightPlanUSB();
            if (ikarus.IsOpen())
            {
                IkarusAutopilotConfig autocfg = ikarus.ReadConfigAutopilot();
                
                float total;
                float co_x = Math.Abs(x_max - x_offset);
                float co_y = Math.Abs(y_max - y_offset);
                
                autocfg.x_off = x_offset;
                autocfg.y_off = y_offset;

                if (autocfg.IR_cross_sensor == 0)
                {
                    if (autocfg.IR_cross_rev == 0)
                        total = co_x;
                    else
                        total = co_y;
                }
                else
                {
                    total = co_x + co_y;
                }
                autocfg.IR_max = total;
                ikarus.WriteConfigAutopilot(autocfg);
                ikarus.Close();
            }
            else
                MessageBox.Show("No conectado!");
            this.Close();
        }
Exemple #15
0
        private void button7_Click(object sender, EventArgs e)
        {
            FlightPlanUSB planUSB = new FlightPlanUSB();
            IkarusAutopilotConfig config_autopilot = planUSB.ReadConfigAutopilot();


            //config.PPM_Channel = comboBoxCtrlCH.SelectedIndex + 4;

            config_autopilot.ail_ch = (byte)(comboAilCH.SelectedIndex - 1);
            config_autopilot.ele_ch = (byte)(comboEleCH.SelectedIndex- 1);
            config_autopilot.thr_ch = (byte)(comboThrCH.SelectedIndex - 1);
            config_autopilot.tail_ch = (byte)(comboTailCH.SelectedIndex - 1);
            config_autopilot.pan_ch = (byte)(comboPanCH.SelectedIndex - 1);

            // SERVO CTRL
            //config_autopilot.servo_ctrl.min = (Int16)numericUpDownServoCTRLmin.Value;
            //config_autopilot.servo_ctrl.center = (Int16)numericUpDownServoCTRLcenter.Value;
            //config_autopilot.servo_ctrl.max = (Int16)numericUpDownServoCTRLmax.Value;
            //config_autopilot.servo_ctrl.reverse = checkBoxServoCTRLrev.Checked ? (byte)1 : (byte)0;

            // SERVO AIL
            config_autopilot.servo_ail.min = (Int16)numericUpDownServoAILmin.Value;
            config_autopilot.servo_ail.center = (Int16)numericUpDownServoAILcenter.Value;
            config_autopilot.servo_ail.max = (Int16)numericUpDownServoAILmax.Value;
            config_autopilot.servo_ail.reverse = checkBoxServoAILrev.Checked ? (byte)1 : (byte)0;

            // SERVO ELE
            config_autopilot.servo_ele.min = (Int16)numericUpDownServoELEmin.Value;
            config_autopilot.servo_ele.center = (Int16)numericUpDownServoELEcenter.Value;
            config_autopilot.servo_ele.max = (Int16)numericUpDownServoELEmax.Value;
            config_autopilot.servo_ele.reverse = checkBoxServoELErev.Checked ? (byte)1 : (byte)0;

            // SERVO THR
            config_autopilot.servo_thr.min = (Int16)numericUpDownServoTHRmin.Value;
            config_autopilot.servo_thr.center = (Int16)numericUpDownServoTHRcenter.Value;
            config_autopilot.servo_thr.max = (Int16)numericUpDownServoTHRmax.Value;
            config_autopilot.servo_thr.reverse = checkBoxServoTHRrev.Checked ? (byte)1 : (byte)0;

            // SERVO TAIL
            config_autopilot.servo_tail.min = (Int16)numericUpDownServoTAILmin.Value;
            config_autopilot.servo_tail.center = (Int16)numericUpDownServoTAILcenter.Value;
            config_autopilot.servo_tail.max = (Int16)numericUpDownServoTAILmax.Value;
            config_autopilot.servo_tail.reverse = checkBoxServoTAILrev.Checked ? (byte)1 : (byte)0;

            // SERVO PAN
            config_autopilot.servo_pan.min = (Int16)numericUpDownServoPANmin.Value;
            config_autopilot.servo_pan.center = (Int16)numericUpDownServoPANcenter.Value;
            config_autopilot.servo_pan.max = (Int16)numericUpDownServoPANmax.Value;
            config_autopilot.servo_pan.reverse = checkBoxServoPANrev.Checked ? (byte)1 : (byte)0;

            config_autopilot.rev_mezcla = checkBoxMix1.Checked ? (byte)1 : (byte)0;

            switch (comboBoxTipoMezcla.SelectedIndex)
            {
                case (int)Singleton.Mezclas.Normal:
                    if (comboTiltCH.SelectedIndex > 0)
                    {
                        config_autopilot.tipo_mezcla = (byte)Singleton.Mezclas.Normal;
                        config_autopilot.aux_ch = (byte)(comboTiltCH.SelectedIndex - 1);
                        config_autopilot.servo_aux.min = (Int16)numericUpDownServoTILTmin.Value;
                        config_autopilot.servo_aux.center = (Int16)numericUpDownServoTILTcenter.Value;
                        config_autopilot.servo_aux.max = (Int16)numericUpDownServoTILTmax.Value;
                        config_autopilot.servo_aux.reverse = checkBoxServoTILTrev.Checked ? (byte)1 : (byte)0;
                    }
                    else
                    {
                    }
                    break;

                case (int)Singleton.Mezclas.Elevon:
                    if (comboTiltCH.SelectedIndex > 0)
                    {
                        config_autopilot.tipo_mezcla = (byte)Singleton.Mezclas.Elevon;
                        config_autopilot.aux_ch = (byte)(comboTiltCH.SelectedIndex - 1);
                        config_autopilot.servo_aux.min = (Int16)numericUpDownServoTILTmin.Value;
                        config_autopilot.servo_aux.center = (Int16)numericUpDownServoTILTcenter.Value;
                        config_autopilot.servo_aux.max = (Int16)numericUpDownServoTILTmax.Value;
                        config_autopilot.servo_aux.reverse = checkBoxServoTILTrev.Checked ? (byte)1 : (byte)0;
                    }
                    else
                    {
                    }
                    break;

                case (int)Singleton.Mezclas.V_Tail:
                    if (comboTiltCH.SelectedIndex > 0)
                    {
                        config_autopilot.tipo_mezcla = (byte)Singleton.Mezclas.V_Tail;
                    
                        config_autopilot.aux_ch = (byte)(comboTiltCH.SelectedIndex - 1);
                        config_autopilot.servo_aux.min = (Int16)numericUpDownServoTILTmin.Value;
                        config_autopilot.servo_aux.center = (Int16)numericUpDownServoTILTcenter.Value;
                        config_autopilot.servo_aux.max = (Int16)numericUpDownServoTILTmax.Value;
                        config_autopilot.servo_aux.reverse = checkBoxServoTILTrev.Checked ? (byte)1 : (byte)0;
                    }
                    else
                    {
                    }
                    break;

                case (int)Singleton.Mezclas.Flaperon:
                    config_autopilot.tipo_mezcla = (byte)Singleton.Mezclas.Normal;
                    config_autopilot.CanalAuxMode = (byte)Singleton.ModoCanalAux.AIL2;
                    
                    config_autopilot.aux_ch = (byte)(comboAil2CH.SelectedIndex - 1);
                    config_autopilot.servo_aux.min = (Int16)numericUpDownServoAIL2min.Value;
                    config_autopilot.servo_aux.center = (Int16)numericUpDownServoAIL2center.Value;
                    config_autopilot.servo_aux.max = (Int16)numericUpDownServoAIL2max.Value;
                    config_autopilot.servo_aux.reverse = checkBoxServoAIL2rev.Checked ? (byte)1 : (byte)0;
                    
                    
                    break;

                case (int)Singleton.Mezclas.Flaperon_Vtail:
                    config_autopilot.tipo_mezcla = (byte)Singleton.Mezclas.V_Tail;
                    config_autopilot.CanalAuxMode = (byte)Singleton.ModoCanalAux.AIL2;
                    
                    config_autopilot.aux_ch = (byte)(comboAil2CH.SelectedIndex - 1);
                    config_autopilot.servo_aux.min = (Int16)numericUpDownServoAIL2min.Value;
                    config_autopilot.servo_aux.center = (Int16)numericUpDownServoAIL2center.Value;
                    config_autopilot.servo_aux.max = (Int16)numericUpDownServoAIL2max.Value;
                    config_autopilot.servo_aux.reverse = checkBoxServoAIL2rev.Checked ? (byte)1 : (byte)0;
                    
                    break;

            }
 /*
            switch (config_autopilot.tipo_mezcla)
            {
                case (byte)Singleton.Mezclas.Elevon:
                    checkBoxMix1.Checked = config_autopilot.pidRoll.rev != 0;
                    checkBoxMix2.Checked = config_autopilot.pidPitch.rev != 0;
                    break;
                case (byte)Singleton.Mezclas.V_Tail:
                    checkBoxMix1.Checked = config_autopilot.pidPitch.rev != 0;
                    checkBoxMix2.Checked = config_autopilot.pidTail.rev != 0;
                    break;
            }
            * */
            planUSB.WriteConfigAutopilot(config_autopilot);
            planUSB.Close();
            
        }
Exemple #16
0
        private void button5_Click(object sender, EventArgs e)
        {
            FlightPlanUSB planUSB = new FlightPlanUSB();
            IkarusAutopilotConfig config_autopilot = planUSB.ReadConfigAutopilot();
            IkarusBasicConfig config = planUSB.ReadConfig();
            planUSB.Close();
            try
            {

                comboBoxCtrlCH.SelectedIndex = (byte)(config.PPM_Channel +1);

                comboAilCH.SelectedIndex = (byte)(config_autopilot.ail_ch+1);
                comboEleCH.SelectedIndex = (byte)(config_autopilot.ele_ch+1);
                comboThrCH.SelectedIndex = (byte)(config_autopilot.thr_ch+1);
                comboTailCH.SelectedIndex = (byte)(config_autopilot.tail_ch+1);
                comboPanCH.SelectedIndex = (byte)(config_autopilot.pan_ch +1);
          
                // SERVO CTRL
                numericUpDownServoCTRLmin.Value = (decimal)config_autopilot.servo_ctrl.min;
                numericUpDownServoCTRLcenter.Value = (decimal)config_autopilot.servo_ctrl.center;
                numericUpDownServoCTRLmax.Value = (decimal)config_autopilot.servo_ctrl.max;
                checkBoxServoCTRLrev.Checked = config_autopilot.servo_ctrl.reverse != 0;

                // SERVO AIL
                numericUpDownServoAILmin.Value = (decimal)config_autopilot.servo_ail.min;
                numericUpDownServoAILcenter.Value = (decimal)config_autopilot.servo_ail.center;
                numericUpDownServoAILmax.Value = (decimal)config_autopilot.servo_ail.max;
                checkBoxServoAILrev.Checked = config_autopilot.servo_ail.reverse != 0;

                // SERVO ELE
                numericUpDownServoELEmin.Value = (decimal)config_autopilot.servo_ele.min;
                numericUpDownServoELEcenter.Value = (decimal)config_autopilot.servo_ele.center;
                numericUpDownServoELEmax.Value = (decimal)config_autopilot.servo_ele.max;
                checkBoxServoELErev.Checked = config_autopilot.servo_ele.reverse != 0;

                // SERVO THR
                numericUpDownServoTHRmin.Value = (decimal)config_autopilot.servo_thr.min;
                numericUpDownServoTHRcenter.Value = (decimal)config_autopilot.servo_thr.center;
                numericUpDownServoTHRmax.Value = (decimal)config_autopilot.servo_thr.max;
                checkBoxServoTHRrev.Checked = config_autopilot.servo_thr.reverse != 0;

                // SERVO TAIL
                numericUpDownServoTAILmin.Value = (decimal)config_autopilot.servo_tail.min;
                numericUpDownServoTAILcenter.Value = (decimal)config_autopilot.servo_tail.center;
                numericUpDownServoTAILmax.Value = (decimal)config_autopilot.servo_tail.max;
                checkBoxServoTAILrev.Checked = config_autopilot.servo_tail.reverse != 0;

                // SERVO PAN
                numericUpDownServoPANmin.Value = (decimal)config_autopilot.servo_pan.min;
                numericUpDownServoPANcenter.Value = (decimal)config_autopilot.servo_pan.center;
                numericUpDownServoPANmax.Value = (decimal)config_autopilot.servo_pan.max;
                checkBoxServoPANrev.Checked = config_autopilot.servo_pan.reverse != 0;


                // Mezclas...

                checkBoxMix1.Checked = (config_autopilot.rev_mezcla != 0);
                        
                
                 
                switch (config_autopilot.tipo_mezcla)
                {
                    case (byte) Singleton.Mezclas.Normal:
                        if (config_autopilot.CanalAuxMode == (int)Singleton.ModoCanalAux.AIL2)
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.Flaperon;
                            
                            comboAil2CH.SelectedIndex = (byte)(config_autopilot.aux_ch + 1);
                            numericUpDownServoAIL2min.Value = (decimal)config_autopilot.servo_aux.min;
                            numericUpDownServoAIL2center.Value = (decimal)config_autopilot.servo_aux.center;
                            numericUpDownServoAIL2max.Value = (decimal)config_autopilot.servo_aux.max;
                            checkBoxServoAIL2rev.Checked = config_autopilot.servo_aux.reverse != 0;
                        }
                        else if (config_autopilot.CanalAuxMode == (int)Singleton.ModoCanalAux.TILT)
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.Normal;
                            
                            comboTiltCH.SelectedIndex = (byte)(config_autopilot.aux_ch + 1);
                            numericUpDownServoTILTmin.Value = (decimal)config_autopilot.servo_aux.min;
                            numericUpDownServoTILTcenter.Value = (decimal)config_autopilot.servo_aux.center;
                            numericUpDownServoTILTmax.Value = (decimal)config_autopilot.servo_aux.max;
                            checkBoxServoTILTrev.Checked = config_autopilot.servo_aux.reverse != 0;
                         }
                        else 
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.Normal;
                        }
                        break;
                    
                    case (byte)Singleton.Mezclas.Elevon:

                        if (config_autopilot.CanalAuxMode == (int)Singleton.ModoCanalAux.AIL2)
                        {
                            MessageBox.Show("Elevon & Flaperon???");
                            //comboAil2CH.SelectedIndex = (byte)(config_autopilot.aux_ch + 1);
                        }
                        else if (config_autopilot.CanalAuxMode == (int)Singleton.ModoCanalAux.TILT)
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.Elevon;
                            
                            comboTiltCH.SelectedIndex = (byte)(config_autopilot.aux_ch + 1);
                            numericUpDownServoTILTmin.Value = (decimal)config_autopilot.servo_aux.min;
                            numericUpDownServoTILTcenter.Value = (decimal)config_autopilot.servo_aux.center;
                            numericUpDownServoTILTmax.Value = (decimal)config_autopilot.servo_aux.max;
                            checkBoxServoTILTrev.Checked = config_autopilot.servo_aux.reverse != 0;
                        
                        }
                        else 
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.Elevon;
                        }
                        break;
                    
                    case (byte)Singleton.Mezclas.V_Tail:

                        if (config_autopilot.CanalAuxMode == (int)Singleton.ModoCanalAux.AIL2)
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.Flaperon_Vtail;
                        
                            comboAil2CH.SelectedIndex = (byte)(config_autopilot.aux_ch + 1);
                            numericUpDownServoAIL2min.Value = (decimal)config_autopilot.servo_aux.min;
                            numericUpDownServoAIL2center.Value = (decimal)config_autopilot.servo_aux.center;
                            numericUpDownServoAIL2max.Value = (decimal)config_autopilot.servo_aux.max;
                            checkBoxServoAIL2rev.Checked = config_autopilot.servo_aux.reverse != 0;

                        }
                        else if (config_autopilot.CanalAuxMode == (int)Singleton.ModoCanalAux.TILT)
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.V_Tail;
                            
                            comboTiltCH.SelectedIndex = (byte)(config_autopilot.aux_ch + 1);
                            numericUpDownServoTILTmin.Value = (decimal)config_autopilot.servo_aux.min;
                            numericUpDownServoTILTcenter.Value = (decimal)config_autopilot.servo_aux.center;
                            numericUpDownServoTILTmax.Value = (decimal)config_autopilot.servo_aux.max;
                            checkBoxServoTILTrev.Checked = config_autopilot.servo_aux.reverse != 0;
                        }
                        else
                        {
                            comboBoxTipoMezcla.SelectedIndex = (int)Singleton.Mezclas.V_Tail;
                        }
                       
                        break;
                }
            }
            catch (Exception) { }

            // Valores de los PID a memorizar....
            try
            {
                me.uplink_pid_ail_P = config_autopilot.pidRoll.P;
                me.uplink_pid_ail_I = config_autopilot.pidRoll.I;
                me.uplink_pid_ail_D = config_autopilot.pidRoll.D;
                me.uplink_pid_ail_IL = config_autopilot.pidRoll.ILim;
                me.uplink_pid_ail_DL = config_autopilot.pidRoll.DriveLim;

                me.uplink_pid_ele_P = config_autopilot.pidPitch.P;
                me.uplink_pid_ele_I = config_autopilot.pidPitch.I;
                me.uplink_pid_ele_D = config_autopilot.pidPitch.D;
                me.uplink_pid_ele_IL = config_autopilot.pidPitch.ILim;
                me.uplink_pid_ele_DL = config_autopilot.pidPitch.DriveLim;

                me.uplink_pid_thr_P = config_autopilot.pidMotor.P;
                me.uplink_pid_thr_I = config_autopilot.pidMotor.I;
                me.uplink_pid_thr_D = config_autopilot.pidMotor.D;
                me.uplink_pid_thr_IL = config_autopilot.pidMotor.ILim;
                me.uplink_pid_thr_DL = config_autopilot.pidMotor.DriveLim;

                me.uplink_pid_tail_P = config_autopilot.pidTail.P;
                me.uplink_pid_tail_I = config_autopilot.pidTail.I;
                me.uplink_pid_tail_D = config_autopilot.pidTail.D;
                me.uplink_pid_tail_IL = config_autopilot.pidTail.ILim;
                me.uplink_pid_tail_DL = config_autopilot.pidTail.DriveLim;

                me.uplink_IR_offX = config_autopilot.x_off;
                me.uplink_IR_offY = config_autopilot.y_off;
                me.uplink_IR_gain = config_autopilot.IR_max;
                me.uplink_rumbo_ail = config_autopilot.Rumbo_Ail;
                me.uplink_altura_ele = config_autopilot.Altitud_Ele;

                me.uplink_IR_rev_P = config_autopilot.IR_pitch_rev != 0;
                me.uplink_IR_rev_R = config_autopilot.IR_roll_rev != 0;
                me.uplink_IR_cross = config_autopilot.IR_cross_sensor != 0;
                me.uplink_IR_rev_cross = config_autopilot.IR_cross_rev != 0;
            }
            catch (Exception) { }

        }
        private void button1_Click(object sender, EventArgs e)
        {
             FlightPlanUSB fp = new FlightPlanUSB();
             if (fp.IsOpen())
             {
                 IkarusBasicConfig basiccfg = new IkarusBasicConfig();
                 basiccfg.LoadDefaults();

                 basiccfg.LoadFromXmlString(global::UAVConsole.Properties.Resources.osd_config);
                 
                 basiccfg.videoPAL = (byte)(1 - comboBoxVideoSystem.SelectedIndex);
                 basiccfg.BaudRate = (byte)comboBoxGPSBaudRate.SelectedIndex;
                 basiccfg.Modo_PPM = (byte)comboBoxModoPPM.SelectedIndex;
                 basiccfg.PPM_Channel = (byte)(comboBoxCanalPPM.SelectedIndex+4);

                 TimeSpan rafa=TimeZone.CurrentTimeZone.GetUtcOffset(new DateTime());
                 basiccfg.TimeZone = (sbyte)rafa.Hours;
              
                 fp.WriteConfig(basiccfg);

                 IkarusAutopilotConfig autocfg = new IkarusAutopilotConfig();
                 autocfg.LoadDefaults();
                 
                 autocfg.LoadFromXmlString(global::UAVConsole.Properties.Resources.autopilot_config);
                 
                 autocfg.tipo_mezcla = (byte)comboBoxTipoMezcla.SelectedIndex;
                 fp.WriteConfigAutopilot(autocfg);

                 
                 if (checkBoxActualizarHUDs.Checked)
                 {
                     IkarusScreenConfig scr = new IkarusScreenConfig();
                     scr.LoadFromXmlString(global::UAVConsole.Properties.Resources.HUD1);
                     fp.WriteScreen(0, scr);    // HUD 0
                     scr.LoadFromXmlString(global::UAVConsole.Properties.Resources.HUD2);
                     fp.WriteScreen(1, scr);    // HUD 1
                     scr.LoadFromXmlString(global::UAVConsole.Properties.Resources.HUD3);
                     fp.WriteScreen(2, scr);    // HUD 2
                     scr.LoadFromXmlString(global::UAVConsole.Properties.Resources.Failsafe);
                     fp.WriteScreen(3, scr);    // FailSafe
                     scr.LoadFromXmlString(global::UAVConsole.Properties.Resources.Resumen);
                     fp.WriteScreen(4, scr);    // Resumen
                 }

                 if (checkBoxActualizarCharSet.Checked)
                 {
                     MemoryStream stream = new MemoryStream(global::UAVConsole.Properties.Resources.Ikarus);
                     FileCharset fc = new FileCharset(new StreamReader(stream));
                     byte[] buff;

                     for(int i=0;i<256;i++)
                     {
                         buff = fc.getChar((byte)i);
                         fp.WriteCharSet(i, buff);
                     }
                 }
                 
                 fp.Close();

                 if (me.Idioma == 0)
                     MessageBox.Show("Realizado!");
                 else
                     MessageBox.Show("Done!");
                 this.Close();
             }
             else
                 if (me.Idioma == 0)
                     MessageBox.Show("No esta conectado!");
                 else
                     MessageBox.Show("Not connected!");
        }
 private void button4_Click(object sender, EventArgs e)
 {
     List<WayPoint> miRuta = mapControl1.ruta;
     FlightPlanUSB fp = new FlightPlanUSB();
     if (fp.IsOpen())
     {
         if (miRuta.Count >= 0)
         {
             Thread.Sleep(500);
             for (int i = 0; i < miRuta.Count; i++)
             {
                 WayPoint wpt = miRuta[i];
                 fp.WriteWpt(i, wpt.name, (float)wpt.Longitude, (float)wpt.Latitude, wpt.Altitude);
                 Thread.Sleep(500);
             }
             fp.WriteMaxWpt(miRuta.Count);
             fp.Flush();
         }
         fp.Close();
     }
 }
Exemple #19
0
        private void button8_Click(object sender, EventArgs e)
        {
            FlightPlanUSB fp = new FlightPlanUSB();
            if (fp.IsOpen())
            {

                OpenFileDialog dlg = new OpenFileDialog();
                dlg.ShowDialog();
                if (dlg.FileName != "")
                {
                    IkarusCompleteConfig full = new IkarusCompleteConfig();

                    full.LoadFromXml(dlg.FileName);

                    fp.WriteConfig(full.IkarusBasicConfig);
                    fp.WriteConfigAutopilot(full.IkarusAutopilotConfig);
                    fp.WriteScreen(0, full.IkarusScreenConfig1);
                    fp.WriteScreen(1, full.IkarusScreenConfig2);
                    fp.WriteScreen(2, full.IkarusScreenConfig3);
                    fp.WriteScreen(3, full.IkarusScreenConfigFailSafe);
                    fp.WriteScreen(4, full.IkarusScreenConfigResumen);

                    fp.Close();
                    if (me.Idioma == 0)
                        MessageBox.Show("Restaurado con exito!");
                    else
                        MessageBox.Show("Succesfully restored!");

                }
                else
                    if (me.Idioma == 0)
                        MessageBox.Show("No se ha especificado nombre de fichero");
                    else
                        MessageBox.Show("File Name not specified!");
                    
            }
            else
                if (me.Idioma == 0)
                    MessageBox.Show("No esta conectado!");
                else
                    MessageBox.Show("Not connected!");
        }
        private void button12_Click(object sender, EventArgs e)
        {
            FlightPlanUSB planUSB = new FlightPlanUSB();
            if (planUSB.IsOpen())
            {
                WayPoint wpt = planUSB.ReadGPS();
                if (wpt != null)
                {
                    Singleton.GetInstance().HomeLat = (float)wpt.Latitude;
                    Singleton.GetInstance().HomeLon = (float)wpt.Longitude;
                    Singleton.GetInstance().HomeAlt = (float)wpt.Altitude;

                    mapControl1.home.Latitude = wpt.Latitude;
                    mapControl1.home.Longitude = wpt.Longitude;
                    mapControl1.Invalidate();
                }
                else
                {
                    IkarusBasicConfig cfg = planUSB.ReadConfig();

                    Singleton.GetInstance().HomeLat = (float)cfg.HomeLat;
                    Singleton.GetInstance().HomeLon = (float)cfg.HomeLon;
                    Singleton.GetInstance().HomeAlt = (float)cfg.HomeAltitude;

                    mapControl1.home.Latitude = cfg.HomeLat;
                    mapControl1.home.Longitude = cfg.HomeLon;
                    mapControl1.Invalidate();

                }
                planUSB.Close();
            }
            else if (me.Idioma == 0)
            {
                MessageBox.Show("No se puede conectar!");
            }
            else
            {
                MessageBox.Show("Cannot connect!");
            }

        }
        private void buttonFIN_Click(object sender, EventArgs e)
        {
            timer1.Enabled = false;
            FlightPlanUSB ikarus = new FlightPlanUSB();
            if (ikarus.IsOpen())
            {
                IkarusAutopilotConfig autocfg = ikarus.ReadConfigAutopilot();
                autocfg.x_off = off_r;
                autocfg.y_off = off_p;

                switch (position)
                {
                    case 0: 
                        autocfg.IR_cross_sensor = 0;
                        autocfg.IR_cross_rev = 0;
                        autocfg.IR_pitch_rev = 1;
                        autocfg.IR_roll_rev = (byte)((position2 == 2) ? 0 : 1);
                        break;

                    case 1:
                        autocfg.IR_cross_sensor = 1;
                        autocfg.IR_cross_rev = 0;
                        autocfg.IR_pitch_rev = 1;
                        autocfg.IR_roll_rev = (byte)((position2 == 3) ? 1 : 0);
                        break;
                    
                    case 2:
                        autocfg.IR_cross_sensor = 0;
                        autocfg.IR_cross_rev = 1;
                        autocfg.IR_pitch_rev = 1;
                        autocfg.IR_roll_rev = (byte)((position2 == 4) ? 1 : 0);
                        break;
                    
                    case 3:
                        autocfg.IR_cross_sensor = 1;
                        autocfg.IR_cross_rev = 1;
                        autocfg.IR_pitch_rev = 0;
                        autocfg.IR_roll_rev = (byte)((position2 == 5) ? 1 : 0);
                        break;
                    
                    case 4:
                        autocfg.IR_cross_sensor = 0;
                        autocfg.IR_cross_rev = 0;
                        autocfg.IR_pitch_rev = 0;
                        autocfg.IR_roll_rev = (byte)((position2 == 6) ? 1 : 0);
                        break;
                    
                    case 5:
                        autocfg.IR_cross_sensor = 1;
                        autocfg.IR_cross_rev = 0;
                        autocfg.IR_pitch_rev = 0;
                        autocfg.IR_roll_rev = (byte)((position2 == 7) ? 0 : 1);
                        break;
                    
                    case 6:
                        autocfg.IR_cross_sensor = 0;
                        autocfg.IR_cross_rev = 1;
                        autocfg.IR_pitch_rev = 0;
                        autocfg.IR_roll_rev = (byte)((position2 == 0) ? 0 : 1);
                        break;
                    
                    case 7:
                        autocfg.IR_cross_sensor = 1;
                        autocfg.IR_cross_rev = 1;
                        autocfg.IR_pitch_rev = 1;
                        autocfg.IR_roll_rev = (byte)((position2 == 1) ? 0 : 1);
                        break;
                }

                ikarus.WriteConfigAutopilot(autocfg);
                ikarus.Close();
            }           
            this.Close();
        }