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");
}
}
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);
}
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);
}
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)
{
}
}
}
