Esempio n. 1
0
        // ####################################################################
        // called from the timer service on the CANForm every 10ms
        private void CANService()
        {
            CheckForIncomingCANMessages();

            if (--CANStatus <= 0)
            {
                CANCheckStatus(false);
                CANStatus = 100;        // every second
            }
            if (CANSendQueue.Count > 0) // send any messages in the queue
            {
                int error             = 0;
                C4UFX.CANMessage mess = CANSendQueue.Dequeue();
                C4UFX.SendCANMess(0, 0, mess, out error);
                DisplayCANData(mess);
            }
        }
Esempio n. 2
0
        // ########################################################################################
        private void CANCheckStatus(bool ForceErr)
        {
            int Result;

            if ((CANInterfaceStatus != CANSTAT.OK) | (ForceErr == true))
            {
                C4UFX.CANMessage CANMess = new C4UFX.CANMessage();
                int Error;

                CANMess.ID  = 0;
                CANMess.DLC = 0;
                for (int c = 0; c < 8; c++)
                {
                    CANMess.Data[c] = 0;
                }
                CANMess.EID        = true;
                CANMess.RTR        = false;
                CANMess.MO         = 0;
                CANMess.SendOption = 7;

                Result = C4UFX.SendCANMess(0, 0, CANMess, out Error);

                if (Result != C4UFX.Resp_Ack)
                {
                    switch (Result)
                    {
                    case C4UFX.Resp_NAck:                       // message was transmitted but there was an error, so reset
                        CANInit();
                        SetCANInterfaceError(CANSTAT.SENDERR);
                        break;

                    case C4UFX.Resp_ErrImproperResponse:
                        SetCANInterfaceError(CANSTAT.NOINT);
                        break;

                    default:
                        SetCANInterfaceError(CANSTAT.ERROR);
                        break;
                    }
                }
                else
                {
                    SetCANInterfaceError(CANSTAT.OK);
                }
            }
            else                           // we're connected and working so display status register
            {
                byte[] DataBuf = new byte[10];

                Result = C4UFX.ReadReg(0, 0, 0x2D, 1, ref DataBuf);       // EFLG
                if (Result == C4UFX.Resp_Ack)
                {
                    if (DataBuf[0] == 0)
                    {
                        SetInterfaceStatusLabelVisible(0, true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(0, false);
                    }

                    if ((DataBuf[0] & 0x80) > 0)
                    {
                        SetInterfaceStatusLabelVisible(7, true);
                        SetCANErrorTimerState(true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(7, false);
                    }

                    if ((DataBuf[0] & 0x40) > 0)
                    {
                        SetInterfaceStatusLabelVisible(6, true);
                        SetCANErrorTimerState(true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(6, false);
                    }

                    if ((DataBuf[0] & 0x20) > 0)
                    {
                        SetInterfaceStatusLabelVisible(5, true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(5, false);
                    }

                    if ((DataBuf[0] & 0x10) > 0)
                    {
                        SetInterfaceStatusLabelVisible(4, true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(4, false);
                    }

                    if ((DataBuf[0] & 0x08) > 0)
                    {
                        SetInterfaceStatusLabelVisible(3, true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(3, false);
                    }

                    if ((DataBuf[0] & 0x04) > 0)
                    {
                        SetInterfaceStatusLabelVisible(2, true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(2, false);
                    }

                    if ((DataBuf[0] & 0x02) > 0)
                    {
                        SetInterfaceStatusLabelVisible(1, true);
                    }
                    else
                    {
                        SetInterfaceStatusLabelVisible(1, false);
                    }
                }
                else
                {
                }
            }
        }