public static bool GroupFlashMemory(KuscMessageParams.MESSAGE_REQUEST request, string data)
        {
            switch (request)
            {
            case KuscMessageParams.MESSAGE_REQUEST.FLASH_EREASE_MEMORY:
                statusMsg = "MCU: Erease flash memory ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.FLASH_READ_CONDITION:
                KuscUtil.UpdateFlashCondition(data);
                statusMsg = "MCU: Read flash status ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.FLASH_REQUEST_RAW_DATA:
                statusMsg = "MCU: Request flash raw packet ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.FLASH_SEND_RAW_DATA:
                KuscUtil.UpdateAdcTable(data);
                statusMsg = "MCU: Receive flash raw data packet ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.FLASH_NO_SAMPLE_YET:
                statusMsg = "MCU: You request number of samples that are bigger then actually MCU have";
                break;
            }

            // Update status log and field:
            KuscUtil.UpdateStatusOk(statusMsg);

            return(true);
        }
        public static bool GroupControlMcu(KuscMessageParams.MESSAGE_REQUEST request, string data)
        {
            switch (request)
            {
            case KuscMessageParams.MESSAGE_REQUEST.CONTROL_SYSTEM_START:
                KuscUtil.UpdateSystemRegisters();
                statusMsg = "MCU: System init and start ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.CONTROL_TEST_LEDS:
                statusMsg = "MCU: Turn leds ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.CONTROL_RESET_MCU:
                statusMsg = "MCU: Reset MCU ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.CONTROL_PA1_SET:
                statusMsg = "MCU: Set PA1 ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.CONTROL_PA2_SET:
                statusMsg = "MCU: Set PA2 ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.CONTROL_KEEP_ALIVE:
                statusMsg = "MCU: System is running";
                break;
            }
            KuscUtil.UpdateStatusOk(statusMsg);

            //KuscLogs.LogPrintCommand(statusMsg);

            return(true);
        }
        public KuscSerial()
        {
            _rxMsgBuffer     = new List <char>();
            _txMessageBuffer = new List <char>();
            _rxDataArray     = new List <char>();
            _KuscUtil        = new KuscUtil();
            cRxState         = UART_READ_STATE.FIND_MAGIC;

            _serialSem = new Semaphore(1, 1);
        }
 public void SerialWriteChar(char charData)
 {
     if (true == _serialPort.IsOpen)
     {
         _serialPort.Write(charData.ToString());
     }
     else
     {
         KuscUtil.UpdateStatusFail("Port is not open, please open it");
     }
 }
示例#5
0
 private void CalcSynthParams(double fRF, double fIF)
 {
     regData.fVco     = Math.Abs(fRF - fIF) / 2.0;
     regData.fVco     = Math.Round(regData.fVco, 3);
     regData.fPFD     = KuscCommon.SYNTH_F_PFD;
     regData.INT      = (int)(regData.fVco / regData.fPFD);
     regData.Mod1     = KuscCommon.SYNTH_MOD1;
     regData.Fraq     = KuscUtil.GetFractionOfDouble(regData.fVco / regData.fPFD);
     regData.Fraq1    = (int)(regData.Fraq * KuscCommon.SYNTH_MOD1);
     regData.remFraq1 = KuscUtil.GetFractionOfDouble(regData.Fraq * KuscCommon.SYNTH_MOD1);
     regData.Mod2     = KuscCommon.SYNTH_MOD2; //(int)((regData.fPFD*10e6) / KuscUtil.GCD(regData.fPFD*10e6, KuscCommon.FREQ_STEP_KHZ * 10e3));
     regData.Fraq2    = (int)(regData.remFraq1 * regData.Mod2);
 }
        public static bool GroupDAC(KuscMessageParams.MESSAGE_REQUEST request, string data)
        {
            switch (request)
            {
            case KuscMessageParams.MESSAGE_REQUEST.DAC_SET_VALUE:
                statusMsg = "MCU: Set DAC value";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.DAC_READ_VALUE:
                KuscUtil.DacReadValue(data);
                break;
            }

            // Update status log and field:
            KuscUtil.UpdateStatusOk(statusMsg);

            return(true);
        }
        public static bool GroupSynthesizers(KuscMessageParams.MESSAGE_REQUEST request, string data)
        {
            switch (request)
            {
            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_DOWN_SET:
                statusMsg = "System: Send syntesizer TX (Down) setting serial packet";
                KuscUtil.clear_cnt();
                break;

            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_UP_SET:
                statusMsg = "System: Send syntesizer RX (Up) setting serial packet";
                KuscUtil.clear_cnt();
                break;

            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_UP_OPER:
                KuscUtil.UpdateSynthUpOper();
                break;

            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_DOWN_OPER:
                KuscUtil.UpdateSynthDownOper();
                break;

            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_UP_READ_DATA:
                KuscUtil.ReadSynthUp(data);
                break;

            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_DOWN_READ_DATA:
                KuscUtil.ReadSynthDown(data);
                break;

            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_REQ_ANTHER_TX_REG:
                KuscUtil.ReqAntherTxRegister();
                break;

            case KuscMessageParams.MESSAGE_REQUEST.SYNTH_REQ_ANTHER_RX_REG:
                KuscUtil.ReqAntherRxRegister();
                break;
            }

            // Update status log and field:
            KuscUtil.UpdateStatusOk(statusMsg);

            return(true);
        }
示例#8
0
        private void btnSetSyntUp_Click(object sender, EventArgs e)
        {
            if ((tbxSynthRxRf.Text != string.Empty) && (tbxSynthRxIf.Text != string.Empty) && (tbxSynthRxRf.Text.Length == 8) && (tbxSynthRxIf.Text.Length == 8) && (tbxSynthRxIf.Text[5] == '.') && (tbxSynthRxRf.Text[5] == '.'))
            {
                double fRf = KuscUtil.ParseDoubleFromString(tbxSynthRxRf.Text);
                double fIf = KuscUtil.ParseDoubleFromString(tbxSynthRxIf.Text);
                tbxSynthVcoOutRxPre.Text    = Math.Abs(fRf - fIf).ToString();
                tbxSynthVcoOutTRxAfter.Text = (Math.Abs(fRf - fIf) / 2).ToString("F2");

                WriteStatusOk(KuscCommon.MSG_SYNTH_OK_RX_FREQ_SENT);
                KuscUtil.clear_cnt();    ////yehuda
                if (fRf >= KuscCommon.SYNTH_RX_FRF_MIN_VALUE_MHZ && fRf <= KuscCommon.SYNTH_RX_FRF_MAX_VALUE_MHZ)
                {
                    if (fIf >= KuscCommon.SYNTH_RX_FIF_MIN_VALUE_MHZ && fIf <= KuscCommon.SYNTH_RX_FIF_MAX_VALUE_MHZ)
                    {
                        // Calc CP value and config synth TX register
                        Int32 cpVal = SetSynthCp(KuscCommon.SYNTH_TYPE.SYNTH_RX);

                        // Add info to system log
                        _kuscLogs.WriteLogMsgOk("MCU set synthesizer up (RX) vales");
                        if (cpVal > 0)
                        {
                            _kuscLogs.WriteLogMsgOk(string.Format("F_IF: {0} [MHz] \tF_RF: {1} [MHz] \tCP {2} [mA]", fRf, fIf, cbxSynthRxSetCp.Items[cpVal]));
                        }


                        dataList = _kuscSynth.GetDataRegisters(KuscCommon.SYNTH_TYPE.SYNTH_RX, fRf, fIf);
                        SendSynthRegisters(KuscCommon.SYNTH_TYPE.SYNTH_RX);
                    }
                    else
                    {
                        WriteStatusFail(string.Format("Please insert RX synthesizer F-IF between {0} and {1}", KuscCommon.SYNTH_RX_FIF_MIN_VALUE_MHZ, KuscCommon.SYNTH_RX_FIF_MAX_VALUE_MHZ));
                    }
                }
                else
                {
                    WriteStatusFail(string.Format("Please insert RX synthesizer F-RF between {0} and {1}", KuscCommon.SYNTH_RX_FRF_MIN_VALUE_MHZ, KuscCommon.SYNTH_RX_FRF_MAX_VALUE_MHZ));
                }
            }
            else
            {
                WriteStatusFail(KuscCommon.MSG_SYNTH_ERR_RX_INPUT_WRONG_FORMAT);
            }
        }
        public static bool GroupStatusAndVersion(KuscMessageParams.MESSAGE_REQUEST request, string data)
        {
            switch (request)
            {
            case KuscMessageParams.MESSAGE_REQUEST.STATUS_GET_MCU_FW_VERSION:
                KuscUtil.UpdateMcuFwVersion(data);
                statusMsg = "MCU: Read MCU FW Version";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.STATUS_MCU_RUN_TIME:
                KuscUtil.UpdateRunTime(data);
                statusMsg = "MCU: Read MCU run-time OK";
                break;
            }

            // Update status log and field:
            KuscUtil.UpdateStatusOk(statusMsg);

            return(true);
        }
        public static bool GroupAdc(KuscMessageParams.MESSAGE_REQUEST request, string data)
        {
            switch (request)
            {
            case KuscMessageParams.MESSAGE_REQUEST.ADC_OPERATION:
                statusMsg = "MCU: Turn ADC ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.ADC_CHANNEL_MODE:
                statusMsg = "MCU: Set ADC set channel mode ok";
                break;

            case KuscMessageParams.MESSAGE_REQUEST.ADC_CONVERSION_MODE:
                statusMsg = "MCU: Set ADC conversion mode ok";
                break;
            }

            // Update status log and field:
            KuscUtil.UpdateStatusOk(statusMsg);

            return(true);
        }
        public bool SerialWriteMessage(KuscMessageParams.MESSAGE_GROUP group, KuscMessageParams.MESSAGE_REQUEST request, string data)
        {
            _serialSem.WaitOne();
            _txMessageBuffer.Clear();                            // Prepere sending list to contain new frame

            _txMessageBuffer.Add(KuscMessageParams.MSG_MAGIC_A); // First frame char contain magic.
            _txMessageBuffer.Add(Convert.ToChar(group));         // Second frame char contain group.
            _txMessageBuffer.Add(Convert.ToChar(request));       // Second frame char contain message request.
            _txMessageBuffer.Add(Convert.ToChar(data.Length));   // Third frame contain number of bytes of data.
            if (data != string.Empty)
            {
                foreach (char dataItem in data)
                {
                    if (dataItem >= 0x30) // Dont convert special sings.
                    {
                        char c = Convert.ToChar(Convert.ToInt32(dataItem) - 0x30);
                        _txMessageBuffer.Add(c);
                    }
                    else
                    {
                        _txMessageBuffer.Add(dataItem);
                    }
                }
            }

            // Calc CRC-8:
            char crc = KuscUtil.CalcCrc8(_txMessageBuffer.ToArray());

            _txMessageBuffer.Add(crc);

            // Now send the frame
            foreach (var item in _txMessageBuffer)
            {
                SerialWriteChar(item);
            }
            _serialSem.Release();
            return(true);
        }
示例#12
0
        public KuscForm()
        {
            InitializeComponent();
            _kuscSerial = new KuscSerial();
            _KuscUtil   = new KuscUtil();
            _kuscSynth  = new KuscSynth();
            _kuscExtDac = new KuscExtDac();
            _kuscLogs   = new KuscLogs();

            // Set Synthesizers init values
            dataList             = new List <string>();
            cbxSynthTxSetCp.Text = "Choose";
            cbxSynthRxSetCp.Text = "Choose";

            // Set DAC init value
            rdbDacA.Checked = true;

            // Set UI Vref
            lblAdcVreTechUi.Text = string.Format("Vref= {0} [mVdc]", KuscCommon.DAC_VSOURCEPLUS_MILI.ToString());
            lblAdcVreUserUi.Text = string.Format("Vref= {0} [mVdc]", KuscCommon.DAC_VSOURCEPLUS_MILI.ToString());
            _KuscUtil.UpdateStatusObject(this);
            _kuscLogs.StoreFormArguments(rtbLogRunWindow, sfdLogFileSaver, fbdLoggerSearcherOpen, dgvLogsFilesList, rtbLogViewer);

            // Set ADC table
            _adcTable = new List <RichTextBox>();
            _adcTable.Add(rtbAdc_REV_PWR);
            _adcTable.Add(rtbAdc_FWD_PWR2);
            _adcTable.Add(rtbAdc_FWD_PWR1);
            _adcTable.Add(rtbAdc_FWD_IN_POWER);
            _adcTable.Add(rtbAdc_P7_SENSE);
            _adcTable.Add(rtbAdc_28V_SENSE);
            _adcTable.Add(rtbAdc_UP_TMP_SNS);
            _adcTable.Add(rtbAdc_DOWN_TMP_SNS);
            _adcTable.Add(rtbAdc_PA_TMP);
            _adcTable.Add(rtbAdc_LD_SYNTH_RX);
            _adcTable.Add(rtbAdc_LD_SYNTH_TX);
            _adcTable.Add(rtbAdc_Flash_Row_data);
        }
        private static int ParseMessage(string msg)
        {
            int _rxReadByte = 0;

            cRxState = UART_READ_STATE.START_RX_MESSAGE_READ;

            while (true)
            {
                try
                {
                    switch (cRxState)
                    {
                    case UART_READ_STATE.START_RX_MESSAGE_READ:
                        _rxMsgBuffer.Clear();
                        _rxDataArray.Clear();
                        _rxReadByte = 0;
                        cRxState    = UART_READ_STATE.FIND_MAGIC;
                        break;

                    case UART_READ_STATE.FIND_MAGIC:

                        _rxReadByte++;
                        if (msg[KuscMessageParams.MSG_MAGIC_LOCATION] == KuscMessageParams.MSG_MAGIC_A)
                        {
                            _rxMsgBuffer.Add(msg[KuscMessageParams.MSG_MAGIC_LOCATION]);
                            cRxState = UART_READ_STATE.READ_GROUP;
                        }
                        else
                        {
                            return(_rxReadByte);
                        }

                        cRxState = UART_READ_STATE.READ_GROUP;
                        break;

                    case UART_READ_STATE.READ_GROUP:

                        _rxMsgBuffer.Add(msg[KuscMessageParams.MSG_GROUP_LOCATION]);
                        _rxReadByte++;
                        cRxState = UART_READ_STATE.READ_REQUEST;
                        break;

                    case UART_READ_STATE.READ_REQUEST:

                        _rxMsgBuffer.Add(msg[KuscMessageParams.MSG_REQUEST_LOCATION]);
                        cRxState = UART_READ_STATE.READ_DATA_SIZE;
                        _rxReadByte++;
                        break;

                    case UART_READ_STATE.READ_DATA_SIZE:

                        _rxMsgBuffer.Add(msg[KuscMessageParams.MSG_REQUEST_DATA_SIZE_LOCATION]);
                        cRxState = UART_READ_STATE.READ_DATA_SIZE;
                        _rxReadByte++;
                        if (msg[KuscMessageParams.MSG_REQUEST_DATA_SIZE_LOCATION] == 0x0)      // check if there is data to read.
                        {
                            cRxState = UART_READ_STATE.CHECK_CRC;
                        }
                        else
                        {
                            cRxState = UART_READ_STATE.READ_DATA;
                        }
                        break;

                    case UART_READ_STATE.READ_DATA:

                        int dataSize = Convert.ToInt32(msg[KuscMessageParams.MSG_REQUEST_DATA_SIZE_LOCATION]);
                        if (dataSize > msg.Length)
                        {
                            return(0);
                        }
                        for (int idx = 0; idx <= dataSize; idx++)
                        {
                            _rxDataArray.Add(msg[KuscMessageParams.MSG_REQUEST_DATA_LOCATION + idx]);
                        }
                        _rxReadByte += dataSize;
                        cRxState     = UART_READ_STATE.CHECK_CRC;
                        break;

                    case UART_READ_STATE.CHECK_CRC:
                        int  crcLocation = KuscMessageParams.MSG_REQUEST_DATA_LOCATION + Convert.ToInt32(msg[KuscMessageParams.MSG_REQUEST_DATA_SIZE_LOCATION]);
                        char crcGiven    = msg[crcLocation];
                        char crcCalc     = KuscUtil.CalcCrc8(msg.ToArray());
                        cRxState = UART_READ_STATE.JUMP_FUNCTION;
                        break;

                    case UART_READ_STATE.JUMP_FUNCTION:

                        _groups[msg[KuscMessageParams.MSG_GROUP_LOCATION] - 1]((KuscMessageParams.MESSAGE_REQUEST)msg[KuscMessageParams.MSG_REQUEST_LOCATION], string.Join(",", _rxDataArray.ToArray()));
                        cRxState = UART_READ_STATE.FINISH_ROUND;
                        break;

                    case UART_READ_STATE.FINISH_ROUND:
                        return(_rxReadByte);
                    }
                }
                catch (Exception)
                {
                }
            }
        }