Example #1
0
        /// <summary>
        /// 启动所有任务
        /// </summary>
        /// <returns></returns>
        private API_RETURN_CODE StartAllTasks()
        {
            API_RETURN_CODE code = API_RETURN_CODE.API_SUCCESS;

            try
            {
                if (m_sysConfig.GetAcqDevice() == ACQ_DEVICE.PMT)
                {
                    m_aiTask.Start();
                }
                else
                {
                    for (int i = 0; i < m_ciTasks.Length; i++)
                    {
                        if (m_ciTasks[i] != null)
                        {
                            m_ciTasks[i].Start();
                        }
                    }
                }

                m_doTask.Start();
                m_aoTask.Start();
            }
            catch (DaqException e)
            {
                Logger.Error(string.Format("start ni tasks exception: [{0}].", e));
                code = API_RETURN_CODE.API_FAILED_NI_START_TASK_EXCEPTION;
            }

            return(code);
        }
Example #2
0
        private void btnLaserRelease_Click(object sender, EventArgs e)
        {
            if (LaserDevice.IsConnected())
            {
                for (int i = 0; i < m_config.GetChannelNum(); i++)
                {
                    CHAN_ID id = (CHAN_ID)Enum.ToObject(typeof(CHAN_ID), i);
                    if (m_config.GetLaserSwitch(id) == LASER_CHAN_SWITCH.ON)
                    {
                        LaserDevice.CloseChannel(id);
                        m_config.SetLaserSwitch(id, LASER_CHAN_SWITCH.OFF);
                    }
                }
            }

            API_RETURN_CODE code = LaserDevice.Release();

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("断开激光器连接失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
            }
            else
            {
                m_config.SetLaserPortName(null);
            }
            UpdateControlers();
        }
Example #3
0
        /// <summary>
        /// 配置CI采集任务
        /// </summary>
        /// <returns></returns>
        private API_RETURN_CODE ConfigCiTasks()
        {
            API_RETURN_CODE code = API_RETURN_CODE.API_SUCCESS;

            int channelNum = m_config.GetChannelNum();

            m_ciTasks          = new Task[channelNum];
            m_ciChannelReaders = new CounterSingleChannelReader[channelNum];
            for (int i = 0; i < channelNum; i++)
            {
                CHAN_ID id = (CHAN_ID)i;
                if (m_config.GetLaserSwitch(id) == LASER_CHAN_SWITCH.ON)
                {
                    code = ConfigCiTask(m_sysConfig.GetApdCiChannel(id), m_sysConfig.GetApdCiSrcPfi(id), m_sysConfig.GetApdTriggerInPfi(), ref m_ciTasks[i], ref m_ciChannelReaders[i]);
                    if (code != API_RETURN_CODE.API_SUCCESS)
                    {
                        return(code);
                    }
                }
                else
                {
                    m_ciTasks[i]          = null;
                    m_ciChannelReaders[i] = null;
                }
            }
            return(code);
        }
Example #4
0
        private void ConfigLaserDevice()
        {
            string          portName = cbxSelectLaser.SelectedItem.ToString();
            API_RETURN_CODE code     = LaserDevice.Connect(portName);

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("连接激光器端口[{0}]失败,请检查接线是否正常,端口号是否正确。", portName));
            }

            m_config.SetLaserPortName(portName);
            for (int i = 0; i < m_config.GetChannelNum(); i++)
            {
                CHAN_ID id = (CHAN_ID)i;
                if (m_config.GetLaserSwitch(id) != LASER_CHAN_SWITCH.ON)
                {
                    continue;
                }

                if (LaserDevice.OpenChannel(id) != API_RETURN_CODE.API_SUCCESS)
                {
                    m_config.SetLaserSwitch(id, LASER_CHAN_SWITCH.OFF);
                    continue;
                }

                LaserDevice.SetChannelPower(id, (float)m_config.GetLaserPower(id));
            }
        }
Example #5
0
        private void ConfigUsbDac()
        {
            API_RETURN_CODE code = UsbDac.Connect();

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("配置激光器增益失败,请联系厂家。"));
            }
        }
Example #6
0
        private void btnLaserRelease_Click(object sender, EventArgs e)
        {
            API_RETURN_CODE code = LaserDevice.Release();

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("断开激光器连接失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
            }
        }
Example #7
0
        public static API_RETURN_CODE Connect()
        {
            if (m_connected)
            {
                Logger.Info(string.Format("Usb Dac already connected."));
                return(API_RETURN_CODE.API_SUCCESS);
            }

            // 打开设备
            if (OpenUsbV40() != API_RETURN_SUCCESS)
            {
                Logger.Info(string.Format("Usb dac connect failed: [{0}].", API_RETURN_CODE.API_FAILED_USB_DAC_OPEN_FAILED));
                return(API_RETURN_CODE.API_FAILED_USB_DAC_OPEN_FAILED);
            }

            // 设置寄存器初始值
            // 量程: -15V/15V 不启动零点和满量程校准
            API_RETURN_CODE code = SetDacRegister(0, m_register);

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                return(code);
            }
            code = SetDacRegister(1, m_register);
            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                return(code);
            }

            // 设置被使用通道的零点 & 增益[不开启,不需要设置]
            //for (int i = 0; i < USB_DAC_CHANNEL_NUM_USED; i++)
            //{
            //    code |= SetZeroCalibration((uint)i, m_zeroList[i]);
            //    code |= SetGainCalibration((uint)i, m_gainList[i]);
            //}
            //if (code != API_RETURN_CODE.API_SUCCESS)
            //{
            //    return code;
            //}

            // 设置各通道电压输出值
            for (int i = 0; i < USB_DAC_CHANNEL_NUM_USED; i++)
            {
                short value = 0;
                VoutToWriteValue((uint)i, m_voutList[i], ref value);
                code |= SetDacOut((uint)i, value);
            }
            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                return(code);
            }

            m_connected = true;
            Logger.Info(string.Format("Usb dac connect success: [{0}].", API_RETURN_CODE.API_SUCCESS));
            return(API_RETURN_CODE.API_SUCCESS);
        }
Example #8
0
        private void btnLaserConnect_Click(object sender, EventArgs e)
        {
            string          portName = cbxLaser.SelectedItem.ToString();
            API_RETURN_CODE code     = LaserDevice.Connect(portName);

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("连接激光器失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
            }
        }
Example #9
0
        /// <summary>
        /// 配置Ao输出任务
        /// </summary>
        /// <returns></returns>
        private API_RETURN_CODE ConfigAoTask()
        {
            API_RETURN_CODE code = API_RETURN_CODE.API_SUCCESS;

            try
            {
                m_aoTask = new Task();

                m_aoTask.AOChannels.CreateVoltageChannel(GetAoPhysicalChannelName(), "", -10.0, 10.0, AOVoltageUnits.Volts);
                m_aoTask.Control(TaskAction.Verify);

                m_aoTask.Timing.SampleClockRate = m_params.AoSampleRate;
                m_aoTask.Timing.ConfigureSampleClock("",
                                                     m_aoTask.Timing.SampleClockRate,
                                                     SampleClockActiveEdge.Rising,
                                                     SampleQuantityMode.ContinuousSamples,
                                                     m_params.AoSampleCountPerFrame);

                // 路由Ao Sample Clcok到PFI0
                //if (m_config.Debugging)
                //{
                //    Logger.Info(string.Format("route ao sample clock to PFI0."));
                //    m_aoTask.ExportSignals.SampleClockOutputTerminal = string.Concat("/", NI_CARD_NAME_DEFAULT, "/", "PFI0");
                //}

                //string source = m_sysConfig.GetStartSyncSignal();
                //m_aoTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(source, DigitalEdgeStartTriggerEdge.Rising);

                // 写入波形
                AnalogMultiChannelWriter  writer = new AnalogMultiChannelWriter(m_aoTask.Stream);
                AnalogWaveform <double>[] waves;
                if (m_config.GetScanMirrorNum() == SCAN_MIRROR_NUM.THREEE)
                {
                    waves    = new AnalogWaveform <double> [3];
                    waves[2] = AnalogWaveform <double> .FromArray1D(m_waver.Y2Wave);
                }
                else
                {
                    waves = new AnalogWaveform <double> [2];
                }
                waves[0] = AnalogWaveform <double> .FromArray1D(m_waver.XWave);

                waves[1] = AnalogWaveform <double> .FromArray1D(m_waver.Y1Wave);

                writer.WriteWaveform(false, waves);
            }
            catch (Exception e)
            {
                Logger.Error(string.Format("config ao task exception: [{0}].", e));
                code = API_RETURN_CODE.API_FAILED_NI_CONFIG_AO_TASK_EXCEPTION;
            }
            return(code);
        }
Example #10
0
        /// <summary>
        /// 配置Ai采集任务
        /// </summary>
        /// <returns></returns>
        private API_RETURN_CODE ConfigAiTask()
        {
            API_RETURN_CODE code = API_RETURN_CODE.API_SUCCESS;

            try
            {
                m_aiTask = new Task();

                m_aiTask.AIChannels.CreateVoltageChannel(GetAiPhysicalChannelName(), "", AITerminalConfiguration.Differential, -5.0, 5.0, AIVoltageUnits.Volts);
                m_aiTask.Control(TaskAction.Verify);

                m_aiTask.Timing.SampleClockRate = m_params.AiSampleRate;
                m_aiTask.Timing.ConfigureSampleClock("",
                                                     m_aiTask.Timing.SampleClockRate,
                                                     SampleClockActiveEdge.Rising,
                                                     SampleQuantityMode.FiniteSamples,
                                                     m_params.ScanPixelsPerAcquisition);

                // 设置Ai Start Trigger源为PFIx,PFIx与Acq Trigger[一般是Do]物理直连,接收Do的输出信号,作为触发
                string source = m_sysConfig.GetPmtTriggerInPfi();
                m_aiTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(source, DigitalEdgeStartTriggerEdge.Rising);
                m_aiTask.Triggers.StartTrigger.Retriggerable = true;        // 设置为允许重触发

                // m_aiTask.AIChannels.All.DataTransferMechanism = AIDataTransferMechanism.Dma;

                // 路由AI Sample Clcok到PFI2, AI Convert Clock到PFI3
                //if (m_config.Debugging)
                //{
                //    Logger.Info(string.Format("route ai sample clock to FFI2, ai convert clock to PFI3."));
                //    m_aiTask.ExportSignals.SampleClockOutputTerminal = string.Concat("/" + NI_CARD_NAME_DEFAULT + "/PFI2"); ;
                //    m_aiTask.ExportSignals.AIConvertClockOutputTerminal = string.Concat("/" + NI_CARD_NAME_DEFAULT + "/PFI3"); ;
                //}

                m_aiTask.EveryNSamplesReadEventInterval = m_params.ScanPixelsPerAcquisition;
                m_aiTask.EveryNSamplesRead += new EveryNSamplesReadEventHandler(AiEveryNSamplesRead);

                m_aiUnscaledReader = new AnalogUnscaledReader(m_aiTask.Stream);
                m_aiUnscaledReader.SynchronizeCallbacks = false;
            }
            catch (Exception e)
            {
                Logger.Error(string.Format("config ai task exception: [{0}].", e));
                code = API_RETURN_CODE.API_FAILED_NI_CONFIG_AI_TASK_EXCEPTION;
            }

            return(code);
        }
Example #11
0
        private API_RETURN_CODE ConfigCiTask(string ciChannel, string ciSrc, string ciClock, ref Task ciTask, ref CounterSingleChannelReader ciMultiChannelReader)
        {
            API_RETURN_CODE code = API_RETURN_CODE.API_SUCCESS;

            try
            {
                ciTask = new Task();

                ciTask.CIChannels.CreateCountEdgesChannel(ciChannel, "", CICountEdgesActiveEdge.Rising, 0, CICountEdgesCountDirection.Up);
                ciTask.Control(TaskAction.Verify);

                ciTask.Timing.SampleClockRate = m_params.CtrSampleRate;
                ciTask.Timing.ConfigureSampleClock(ciClock,
                                                   ciTask.Timing.SampleClockRate,
                                                   SampleClockActiveEdge.Rising,
                                                   SampleQuantityMode.ContinuousSamples,
                                                   m_params.ValidScanPixelsPerFrame);

                ciTask.Stream.ConfigureInputBuffer(m_params.ValidScanPixelsPerFrame);

                // CIDataTransferMechanism x = ciTask.CIChannels.All.DataTransferMechanism;

                // 指定CI Channel使用的物理输入终端[APD的脉冲接收端]
                ciTask.CIChannels[0].CountEdgesTerminal = ciSrc;

                // 设置Ci Pause Trigger源为PFIx,PFIx与Acq Trigger[一般是Do]物理直连,接收Do的输出信号,作为触发
                // 低电平使能Pause Trigger,高电平禁能
                // ciTask.Triggers.PauseTrigger.ConfigureDigitalLevelTrigger(ciGate, DigitalLevelPauseTriggerCondition.Low);

                // 设置Arm Start Trigger,使CI与AO、DO同时启动工作
                string source = m_sysConfig.GetStartSyncSignal();
                ciTask.Triggers.ArmStartTrigger.ConfigureDigitalEdgeTrigger(source, DigitalEdgeArmStartTriggerEdge.Rising);

                ciTask.EveryNSamplesReadEventInterval = m_params.ScanPixelsPerAcquisition;
                ciTask.EveryNSamplesRead += new EveryNSamplesReadEventHandler(CiEveryNSamplesRead);

                ciMultiChannelReader = new CounterSingleChannelReader(ciTask.Stream);
                ciMultiChannelReader.SynchronizeCallbacks = false;
            }
            catch (Exception e)
            {
                Logger.Error(string.Format("config ci task[{0}] exception: [{1}].", ciChannel, e));
                code = API_RETURN_CODE.API_FAILED_NI_CONFIG_CI_TASK_EXCEPTION;
            }

            return(code);
        }
Example #12
0
        public API_RETURN_CODE ReleaseScanTask(ScanTask scanTask)
        {
            API_RETURN_CODE code = StopScanTask(scanTask);

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                return(code);
            }

            m_scanTasks.Remove(scanTask);

            if (ScanTaskReleased != null)
            {
                ScanTaskReleased.Invoke(scanTask, null);
            }
            return(API_RETURN_CODE.API_SUCCESS);
        }
Example #13
0
        /// <summary>
        /// 配置Do输出任务
        /// </summary>
        /// <returns></returns>
        private API_RETURN_CODE ConfigDoTask()
        {
            API_RETURN_CODE code = API_RETURN_CODE.API_SUCCESS;

            try
            {
                m_doTask = new Task();

                m_doTask.DOChannels.CreateChannel(GetDoPhysicalChannelName(), "", ChannelLineGrouping.OneChannelForEachLine);
                m_doTask.Control(TaskAction.Verify);

                m_doTask.Timing.SampleClockRate = m_params.DoSampleRate;
                m_doTask.Timing.ConfigureSampleClock("",
                                                     m_doTask.Timing.SampleClockRate,
                                                     SampleClockActiveEdge.Rising,
                                                     SampleQuantityMode.ContinuousSamples,
                                                     m_params.AoSampleCountPerFrame);

                // 设置Do Start Trigger源为Ao Start Trigger[默认],实现启动同步
                string source = m_sysConfig.GetStartSyncSignal();
                m_doTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(source, DigitalEdgeStartTriggerEdge.Rising);

                // 路由Do Sample Clcok到PFI1
                //if (m_config.Debugging)
                //{
                //    Logger.Info(string.Format("route do sample clock to PFI1."));
                //    m_doTask.ExportSignals.SampleClockOutputTerminal = string.Concat("/" + NI_CARD_NAME_DEFAULT + "/PFI1");
                //}

                m_doTask.Stream.WriteRegenerationMode = WriteRegenerationMode.AllowRegeneration;

                DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(m_doTask.Stream);
                DigitalWaveform            wave   = DigitalWaveform.FromPort(m_params.DigitalTriggerSamplesPerLine, 0x01);
                writer.WriteWaveform(false, wave);
            }
            catch (Exception e)
            {
                Logger.Error(string.Format("config do task exception: [{0}].", e));
                code = API_RETURN_CODE.API_FAILED_NI_CONFIG_DO_TASK_EXCEPTION;
            }
            return(code);
        }
Example #14
0
        /// <summary>
        /// 启动任务
        /// </summary>
        /// <returns></returns>
        public API_RETURN_CODE Start()
        {
            API_RETURN_CODE code = API_RETURN_CODE.API_SUCCESS;

            code = ConfigAoTask();
            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                Stop();
                return(code);
            }

            code = ConfigDoTask();
            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                Stop();
                return(code);
            }

            if (m_sysConfig.GetAcqDevice() == ACQ_DEVICE.PMT)
            {
                code = ConfigAiTask();
            }
            else
            {
                code = ConfigCiTasks();
            }
            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                Stop();
                return(code);
            }

            code = StartAllTasks();
            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                Stop();
                return(code);
            }

            return(code);
        }
Example #15
0
        private void cbxScanPixels_SelectedIndexChanged(object sender, EventArgs e)
        {
            int scanPixels = ((KeyValuePair <int, string>)cbxScanPixels.SelectedItem).Key;

            if (m_config.GetScanXPoints() == scanPixels && m_config.GetScanYPoints() == scanPixels)
            {
                return;
            }

            this.Cursor = System.Windows.Forms.Cursors.WaitCursor;

            // if task is not running, just update config
            if (m_scheduler.TaskScanning() == false)
            {
                m_config.SetScanXPoints(scanPixels);
                m_config.SetScanYPoints(scanPixels);
                m_scheduler.ConfigScanTask(m_scheduler.GetScanningTask());
                // UpdateControlers();

                this.Cursor = System.Windows.Forms.Cursors.Default;
                return;
            }

            // if task is already running, stop first
            m_scheduler.StopScanTask(m_scheduler.GetScanningTask());
            // update config
            m_config.SetScanXPoints(scanPixels);
            m_config.SetScanYPoints(scanPixels);
            // create & start task
            m_scheduler.CreateScanTask(0, "实时扫描", out ScanTask scanTask);
            API_RETURN_CODE code = m_scheduler.StartScanTask(scanTask);

            // UpdateControlers();
            this.Cursor = System.Windows.Forms.Cursors.Default;

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("启动扫描任务失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
            }
        }
Example #16
0
        private void btnScan_Click(object sender, EventArgs e)
        {
            //if (!LaserDevice.IsConnected())
            //{
            //    MessageBox.Show("激光器未连接,请先连接激光器.");
            //    return;
            //}

            if (m_scheduler.TaskScanning() == false)
            {
                if (m_config.GetActivatedChannelNum() == 0)
                {
                    MessageBox.Show("激光未打开,请至少打开一路激光通道.");
                    return;
                }

                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                m_scheduler.CreateScanTask(0, "实时扫描", out ScanTask scanTask);
                API_RETURN_CODE code = m_scheduler.StartScanTask(scanTask);
                this.Cursor = System.Windows.Forms.Cursors.Default;

                if (code != API_RETURN_CODE.API_SUCCESS)
                {
                    MessageBox.Show(string.Format("启动扫描任务失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
                }
            }
            else
            {
                this.Cursor = System.Windows.Forms.Cursors.WaitCursor;
                ScanTask        scanTask = m_scheduler.GetScanningTask();
                API_RETURN_CODE code     = m_scheduler.StopScanTask(scanTask);
                this.Cursor = System.Windows.Forms.Cursors.Default;

                if (code != API_RETURN_CODE.API_SUCCESS)
                {
                    MessageBox.Show(string.Format("停止扫描任务失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
                }
            }
        }
Example #17
0
        public API_RETURN_CODE StartScanTask(ScanTask scanTask)
        {
            if (scanTask == null)
            {
                return(API_RETURN_CODE.API_FAILED_SCAN_TASK_INVALID);
            }

            if (FindScanTask(scanTask.TaskId) == null)
            {
                return(API_RETURN_CODE.API_FAILED_SCAN_TASK_NOT_FOUND);
            }

            m_params.Calculate();                       // 计算参数
            m_params.GenerateColorMapping();            //
            m_params.GenerateAiChannelIndex();          // 计算使用PMT的情况下各个AI通道采集数据对应的Index
            m_waver.Generate();                         // 计算AO输出波形和触发信号
            scanTask.Config();                          // 配置扫描任务

            API_RETURN_CODE code = m_card.Start();      // 启动板卡

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                Logger.Info(string.Format("start scan task[{0}|{1}] failed: [{2}].", scanTask.TaskId, scanTask.TaskName, code));
                StopScanTask(scanTask);
                return(code);
            }

            scanTask.Start();                           // 启动扫描任务
            m_scanningTask = scanTask;

            if (ScanTaskStarted != null)
            {
                ScanTaskStarted.Invoke(scanTask, null);
            }

            Logger.Info(string.Format("start scan task[{0}|{1}] success.", scanTask.TaskId, scanTask.TaskName));
            return(code);
        }
Example #18
0
        private void cbxDwellTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            double dwellTime = double.Parse(cbxDwellTime.SelectedItem.ToString());

            if (m_config.GetScanDwellTime() == dwellTime)
            {
                return;
            }

            this.Cursor = System.Windows.Forms.Cursors.WaitCursor;

            // if task is not running, just update config
            if (m_scheduler.TaskScanning() == false)
            {
                m_config.SetScanDwellTime(dwellTime);
                m_scheduler.ConfigScanTask(m_scheduler.GetScanningTask());
                // UpdateControlers();

                this.Cursor = System.Windows.Forms.Cursors.Default;
                return;
            }

            // if task is already running, stop first
            m_scheduler.StopScanTask(m_scheduler.GetScanningTask());
            // update config
            m_config.SetScanDwellTime(dwellTime);
            // create & start task
            m_scheduler.CreateScanTask(0, "实时扫描", out ScanTask scanTask);
            API_RETURN_CODE code = m_scheduler.StartScanTask(scanTask);

            // UpdateControlers();
            this.Cursor = System.Windows.Forms.Cursors.Default;

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("启动扫描任务失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
            }
        }
Example #19
0
        private void rbtnTwo_CheckedChanged(object sender, EventArgs e)
        {
            SCAN_MIRROR_NUM mirrorNum = rbtnTwo.Checked ? SCAN_MIRROR_NUM.TWO : SCAN_MIRROR_NUM.THREEE;

            if (m_config.GetScanMirrorNum() == mirrorNum)
            {
                return;
            }

            this.Cursor = System.Windows.Forms.Cursors.WaitCursor;

            // if task is not running, just update config
            if (m_scheduler.TaskScanning() == false)
            {
                m_config.SetScanMirrorNum(mirrorNum);
                m_scheduler.ConfigScanTask(m_scheduler.GetScanningTask());

                // UpdateControlers();
                this.Cursor = System.Windows.Forms.Cursors.Default;
                return;
            }

            // if task is already running, stop first
            m_scheduler.StopScanTask(m_scheduler.GetScanningTask());
            // update config
            m_config.SetScanMirrorNum(mirrorNum);
            // create & start task
            m_scheduler.CreateScanTask(0, "实时扫描", out ScanTask scanTask);
            API_RETURN_CODE code = m_scheduler.StartScanTask(scanTask);

            // UpdateControlers();
            this.Cursor = System.Windows.Forms.Cursors.Default;

            if (code != API_RETURN_CODE.API_SUCCESS)
            {
                MessageBox.Show(string.Format("启动扫描任务失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
            }
        }
Example #20
0
        private void UpdateLaserSwitch(CheckBox chbx, CHAN_ID id)
        {
            LASER_CHAN_SWITCH status = chbx.Checked ? LASER_CHAN_SWITCH.ON : LASER_CHAN_SWITCH.OFF;

            this.Cursor = System.Windows.Forms.Cursors.WaitCursor;

            // if task is not running, just update config
            if (m_scheduler.TaskScanning() == false)
            {
                chbx.Checked = !chbx.Checked;
                status       = chbx.Checked ? LASER_CHAN_SWITCH.ON : LASER_CHAN_SWITCH.OFF;
                m_config.SetLaserSwitch(id, status);

                if (LaserDevice.IsConnected())
                {
                    if (status == LASER_CHAN_SWITCH.ON)
                    {
                        LaserDevice.OpenChannel(id);
                        LaserDevice.SetChannelPower(id, m_config.GetLaserPower(id));
                    }
                    else
                    {
                        LaserDevice.CloseChannel(id);
                    }
                }

                this.Cursor = System.Windows.Forms.Cursors.Default;
                return;
            }

            // task is already running
            if (status == LASER_CHAN_SWITCH.OFF)                         // 激光当前是OFF状态
            {
                m_scheduler.StopScanTask(m_scheduler.GetScanningTask()); // 先停止扫描

                chbx.Checked = true;                                     // 再更新配置,并打开激光,设置激光功率
                m_config.SetLaserSwitch(id, LASER_CHAN_SWITCH.ON);
                if (LaserDevice.IsConnected())
                {
                    LaserDevice.OpenChannel(id);
                    LaserDevice.SetChannelPower(id, m_config.GetLaserPower(id));
                }

                m_scheduler.CreateScanTask(0, "实时扫描", out ScanTask scanTask);   // 创建Task,并启动
                API_RETURN_CODE code = m_scheduler.StartScanTask(scanTask);

                this.Cursor = System.Windows.Forms.Cursors.Default;

                if (code != API_RETURN_CODE.API_SUCCESS)
                {
                    MessageBox.Show(string.Format("启动扫描任务失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
                }
            }
            else
            {
                // 激光当前是ON状态
                if (m_config.GetActivatedChannelNum() == 1)     // 该路激光是扫描状态下唯一开启的激光
                {
                    this.Cursor = System.Windows.Forms.Cursors.Default;
                    return;                                     // 作为扫描状态下唯一开启的激光,不允许关闭,直接返回
                }
                else
                {
                    m_scheduler.StopScanTask(m_scheduler.GetScanningTask());    // 先停止扫描

                    chbx.Checked = false;                                       // 再更新配置,并关闭激光
                    m_config.SetLaserSwitch(id, LASER_CHAN_SWITCH.OFF);
                    if (LaserDevice.IsConnected())
                    {
                        LaserDevice.CloseChannel(id);
                    }

                    m_scheduler.CreateScanTask(0, "实时扫描", out ScanTask scanTask);   // 创建Task,并启动
                    API_RETURN_CODE code = m_scheduler.StartScanTask(scanTask);

                    this.Cursor = System.Windows.Forms.Cursors.Default;

                    if (code != API_RETURN_CODE.API_SUCCESS)
                    {
                        MessageBox.Show(string.Format("启动扫描任务失败,失败码: [0x{0}][{1}].", ((int)code).ToString("X"), code));
                    }
                }
            }
        }