コード例 #1
0
 public void CalibrateBottomCamera()
 {
     AlignBottomCamera();
     _targetAngle    = 0;
     _mvLocatorState = MVLocatorState.NozzleCalibration;
     SelectMVProfile("nozzlecalibration");
     Machine.SendCommand($"G0 E0");
     _averagePoints = new List <Point2D <double> >();
 }
コード例 #2
0
        private void SetNewHome()
        {
            Machine.SendCommand($"G92 X{Machine.Settings.MachineFiducial.X} Y{Machine.Settings.MachineFiducial.Y}");
            Machine.SendCommand(SafeHeightGCodeGCode());
            var gcode = $"G1 X0 Y0 F{Machine.Settings.FastFeedRate}";

            Machine.SendCommand(gcode);

            ShowCircles = false;

            _mvLocatorState = MVLocatorState.Default;
        }
コード例 #3
0
        public void PerformMachineAlignment()
        {
            Machine.SendCommand(SafeHeightGCodeGCode());
            _mvLocatorState = MVLocatorState.Idle;

            Machine.ViewType   = ViewTypes.Camera;
            Machine.TopLightOn = true;

            Machine.GotoWorkspaceHome();

            SelectMVProfile("brdfiducual");

            Machine.SendCommand(DwellGCode(250));

            GoToFiducial(0);

            ShowCircles = true;

            _mvLocatorState = MVLocatorState.MachineFidicual;
        }
コード例 #4
0
        public override void CircleLocated(Point2D <double> point, double diameter, Point2D <double> stdDeviation)
        {
            switch (_mvLocatorState)
            {
            case MVLocatorState.MachineFidicual:
                JogToLocation(point);
                break;

            case MVLocatorState.BoardFidicual1:
                JogToLocation(point);
                break;

            case MVLocatorState.BoardFidicual2:
                JogToLocation(point);
                break;

            case MVLocatorState.NozzleCalibration:
                Debug.WriteLine($"Found Circle: {Machine.MachinePosition.X},{Machine.MachinePosition.Y} - {stdDeviation.X},{stdDeviation.Y}");

                if (_targetAngle == Convert.ToInt32(Machine.Tool2))
                {
                    samplesAtPoint++;

                    if (samplesAtPoint > 50)
                    {
                        var avgX = _averagePoints.Average(pt => pt.X);
                        var avgY = _averagePoints.Average(pt => pt.Y);
                        _nozzleCalibration.Add(Convert.ToInt32(Machine.Tool2), new Point2D <double>(avgX, avgY));
                        _targetAngle = Convert.ToInt32(Machine.Tool2 + 15.0);
                        Machine.SendCommand($"G0 E{_targetAngle}");
                        _averagePoints.Clear();
                        samplesAtPoint = 0;
                    }
                    else
                    {
                        _averagePoints.Add(new Point2D <double>(point.X, point.Y));
                    }

                    if (Machine.Tool2 >= 360)
                    {
                        _mvLocatorState = MVLocatorState.Idle;
                        foreach (var key in _nozzleCalibration.Keys)
                        {
                            Debug.WriteLine($"{key},{_nozzleCalibration[key].X},{_nozzleCalibration[key].Y}");
                        }

                        var maxX = _nozzleCalibration.Values.Max(ca => ca.X);
                        var maxY = _nozzleCalibration.Values.Max(ca => ca.Y);

                        var minX = _nozzleCalibration.Values.Min(ca => ca.X);
                        var minY = _nozzleCalibration.Values.Min(ca => ca.Y);

                        var preCalX = Machine.MachinePosition.X;
                        var preCalY = Machine.MachinePosition.Y;


                        var top = _nozzleCalibration.First(pt => pt.Value.Y == maxY);

                        var topAngle = top.Key;
                        var offsetX  = top.Value.X / 20.0;
                        var offsetY  = top.Value.Y / 20.0;

                        //var offsetX = ((maxX - minX) / 60.0);
                        //var offsetY = ((maxY - minY) / 60.0);

                        Machine.SendCommand("G91");
                        Machine.SendCommand($"G0 X-{offsetX} Y{+offsetY}");
                        Machine.SendCommand("G90");


                        Debug.WriteLine($"MIN: {minX},{minY} MAX: {maxX},{maxY}, Adjusting to offset: {offsetX},{offsetY} - Top Angle: {topAngle}");

                        Machine.SendCommand($"G0 E{topAngle}");
                        Machine.SendCommand($"G92 E0 X{preCalX} Y{preCalY}");
                    }
                }

                break;

            default:
                if (PartPackManagerVM.IsLocating)
                {
                    JogToLocation(point);
                }
                break;
            }
        }