private static void CanController_DataReceived(object sender, CanMessageReceivedEventArgs e) { CanController canCtl = (CanController)sender; while (true) { // try get the next message var msg = canCtl.GetMessage(); if (msg == null) { Debug.WriteLine("*** No more message available!!!"); break; } // new message available, output message if (msg.Message != null) { Debug.Write($"Message on {canCtl.ControllerId}: "); for (int i = 0; i < msg.Message.Length; i++) { Debug.Write(msg.Message[i].ToString("X2")); } new Thread(BlinkLED).Start(); } Debug.WriteLine(""); } }
private void ThreadTest() { this.isRunning = true; var canController = CanController.FromName(SC20260.CanBus.Can1); canController.SetNominalBitTiming(new GHIElectronics.TinyCLR.Devices.Can.CanBitTiming(15 + 8, 8, 6, 8, false)); // 250Kbit/s canController.SetDataBitTiming(new GHIElectronics.TinyCLR.Devices.Can.CanBitTiming(15 + 8, 8, 3, 8, false)); //500kbit/s canController.Filter.AddRangeFilter(Filter.IdType.Standard, 0x100, 0x7FF); canController.Filter.AddRangeFilter(Filter.IdType.Extended, 0x100, 0x999); canController.MessageReceived += this.CanController_MessageReceived; canController.ErrorReceived += this.CanController_ErrorReceived; canController.Enable(); while (this.isRunning) { Thread.Sleep(100); } this.isRunning = false; canController.Disable(); }
public static void Main() { // PJ5 is LD2 in STM32F769I_DISCO //_led = GpioController.GetDefault().OpenPin(PinNumber('J', 5)); // PG14 is LEDLD4 in F429I_DISCO //_led = GpioController.GetDefault().OpenPin(PinNumber('G', 14)); // PD13 is LED3 in DISCOVERY4 _led = GpioController.GetDefault().OpenPin(PinNumber('D', 13)); _led.SetDriveMode(GpioPinDriveMode.Output); // set settings for CAN controller CanSettings canSettings = new CanSettings(6, 8, 1, 0); // get controller for CAN1 CanController1 = CanController.FromId("CAN1", canSettings); // get controller for CAN2 CanController2 = CanController.FromId("CAN2", canSettings); //CanController1.MessageReceived += CanController_DataReceived; CanController2.MessageReceived += CanController_DataReceived; while (true) { CanController1.WriteMessage(new CanMessage(0x01234567, CanMessageIdType.EID, CanMessageFrameType.Data, new byte[] { 0xCA, 0xFE })); //CanController2.WriteMessage(new CanMessage(0x01234567, false, true, new byte[] { 0xFE, 0xCA })); Thread.Sleep(2000); } }
internal static CanNodeSession GetNewCanSession() { var canController = new CanController(); var microController = new MockMicroControllerImpl(canController); var transceiver = new CanTransceiver(canController); canController.SetControllerProperties(transceiver, microController, new FrameBuilder()); return(new CanNodeSession(new CanNode(microController, transceiver))); }
private void CanController_ErrorReceived(CanController sender, ErrorReceivedEventArgs e) { try { // Reset CAN sender.Disable(); Thread.Sleep(10); sender.Enable(); } catch { } }
public CanNodeSession CreateCanNodeSession(Type microcontrollerType) { var canController = new CanController(); IMicrocontroller microController = (IMicrocontroller)Activator.CreateInstance(microcontrollerType); microController.CanController = canController; var transceiver = new CanTransceiver(canController); canController.SetControllerProperties(transceiver, microController, new FrameBuilder()); return(new CanNodeSession(new CanNode(microController, transceiver))); }
private static void Can_MessageReceived(CanController sender, MessageReceivedEventArgs e) { sender.ReadMessage(out CanMessage message); var str = Encoding.UTF8.GetString(message.Data); Debug.WriteLine("---> Onbard CAN receiving data"); Debug.WriteLine($"\tArbitration ID : 0x{message.ArbitrationId:X3}"); Debug.WriteLine($"\tTimestamp : {e.Timestamp.Ticks} ticks"); Debug.WriteLine($"\tData : {str}"); Debug.WriteLine("************"); }
public void Get_UserNotFound_ReturnsUnauthorized() { var mockUserCache = MockRepository.GenerateStub<IUserCache>(); mockUserCache.Expect(x => x.GetUsers()) .Return(new Dictionary<string, User>()); var controller = new CanController(mockUserCache); var user = "******"; var action = "testAction"; var actual = controller.Get(user, action); Assert.That(actual.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized)); }
private static void Can_MessageReceived(CanController sender, MessageReceivedEventArgs e) { sender.ReadMessage(out var message); Debug.WriteLine("Arbitration ID: 0x" + message.ArbitrationId.ToString("X8")); Debug.WriteLine("Is extended ID: " + message.IsExtendedId.ToString()); Debug.WriteLine("Is remote transmission request: " + message.IsRemoteTransmissionRequest.ToString()); Debug.WriteLine("Time stamp: " + message.Timestamp.ToString()); var data = ""; for (var i = 0; i < message.Length; i++) { data += Convert.ToChar(message.Data[i]); } Debug.WriteLine("Data: " + data); }
private static void Main() { var btn1 = GpioController.GetDefault().OpenPin(G80.GpioPin.PE0); btn1.SetDriveMode(GpioPinDriveMode.InputPullUp); var can = CanController.FromName(G80.CanBus.Can1); // Settings for 500kbps var propagation = 1; var phase1 = 12; var phase2 = 2; var baudratePrescaler = 6; var synchronizationJumpWidth = 1; var useMultiBitSampling = false; can.SetBitTiming(new CanBitTiming(propagation, phase1, phase2, baudratePrescaler, synchronizationJumpWidth, useMultiBitSampling)); can.Enable(); var message = new CanMessage() { Data = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 }, ArbitrationId = 0x99, Length = 6, IsRemoteTransmissionRequest = false, IsExtendedId = false }; can.MessageReceived += Can_MessageReceived; can.ErrorReceived += Can_ErrorReceived; while (true) { if (btn1.Read() == GpioPinValue.Low) { can.WriteMessage(message); } Thread.Sleep(100); } }
private void CanController_MessageReceived(CanController sender, MessageReceivedEventArgs e) { var msgs = new GHIElectronics.TinyCLR.Devices.Can.CanMessage[e.Count]; for (var i = 0; i < msgs.Length; i++) { msgs[i] = new GHIElectronics.TinyCLR.Devices.Can.CanMessage(); } this.messageReceiveCount += sender.ReadMessages(msgs, 0, msgs.Length); for (var i = 0; i < msgs.Length; i++) { this.UpdateStatusText(ArbitrationId + msgs[i].ArbitrationId, true); this.UpdateStatusText(FdCanMode + msgs[i].FdCan, false); this.UpdateStatusText(ExtendedId + msgs[i].ExtendedId, false); this.UpdateStatusText(RTR + msgs[i].RemoteTransmissionRequest, false); this.UpdateStatusText(BitRateSwitch + msgs[i].BitRateSwitch, false); var dataText = string.Empty; for (var ii = 0; ii < 8; ii++) { dataText += msgs[i].Data[ii] + " "; } this.UpdateStatusText(Data + dataText, false); this.UpdateStatusText(TotalReceived + this.messageReceiveCount, false); try { msgs[i].ArbitrationId += 1; sender.WriteMessage(msgs[i]); } catch { } } }
public void Get_UserAuthorized_ReturnsOk() { var mockUserCache = MockRepository.GenerateStub<IUserCache>(); mockUserCache.Expect(x => x.GetUsers()) .Return(new Dictionary<string, User> { { "testUser", new User { Name = "testUser", Actions = new[] {"testAction"} } } }); var controller = new CanController(mockUserCache); var user = "******"; var action = "testAction"; var actual = controller.Get(user, action); Assert.That(actual.StatusCode, Is.EqualTo(HttpStatusCode.OK)); }
public static void TestCanSpi() { // Initialize CanSpi Click module on SC20260D socket #2 _canSpi = new CanSpiClick(Hardware.SC20260_2); if (_canSpi.Init("CAN#1", CanSpiClick.Baudrate500k, CanSpiClick.normalMode)) { Debug.WriteLine("CAN#1 @ 500kbps"); } else { throw new NotImplementedException("CanSpiClick initialization failed!"); } _canSpi.MessageReceived += CAN1_MessageReceived; // Initialize SC20260D onboard Can _onboardCan = CanController.FromName(STM32H7.CanBus.Can1); _onboardCan.SetNominalBitTiming(new CanBitTiming(propagationPhase1: 13, phase2: 2, baudratePrescaler: 6, synchronizationJumpWidth: 1, useMultiBitSampling: false)); _onboardCan.Enable(); _onboardCan.MessageReceived += Can_MessageReceived; _onboardCan.ErrorReceived += Can_ErrorReceived; CanSpiToOnboardCan(); OnboardCanToCanSpi(); }
static void Main() { //Instantiate the network class Network = new Network("192.168.181.210", "255.255.255.0", "192.168.181.1", "192.168.181.1", new byte[] { 0xA1, 0xA6, 0xB9, 0x3E, 0xD0, 0x1F }); //Initialize the network Network.InitializeNetwork(); //Create a UDP socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); //Start the CAN at 250kbps can = CanController.FromName(SC20100.CanBus.Can1); can.SetNominalBitTiming(new CanBitTiming(13, 2, 12, 1, false)); can.ErrorReceived += Can_ErrorReceived; //Attach to the error event can.Enable(); //Enable the CAN peripheral new Thread(Print).Start(); //Start a thread that will print how many messages we processed last second //A byte array used in the loop byte[] data = new byte[8]; while (true) { //If we have messages to read if (can.MessagesToRead > 0) { //Read the message can.ReadMessage(out msg); msgCount++; //Increment the count Array.Copy(msg.Data, data, 8); //Copy the data so we only take the first 8 received bytes instead of all 64 //sock.SendTo(data, endPoint); //Send the data to the endpoint over the socket. REMOVE THIS LINE TO BE ABLE TO PROCESS AS MUCH MESSAGES AS CAN ALLOWS } } }
private static void Can_ErrorReceived(CanController sender, ErrorReceivedEventArgs e) => Debug.WriteLine("Onboard Can error : " + e.ToString());
public MockMicroControllerImpl(CanController canController) : this() { CanController = canController; }
private bool DoTestCan() { this.AddNextButton(); this.UpdateStatusText("Testing CAN1.", true); this.UpdateStatusText("- Open PCAN-View application.", false); this.UpdateStatusText("- Nominal speed: 250Kbit/s.", false); this.UpdateStatusText("- Data speed: 500Kbit/.", false); this.UpdateStatusText("- The test is waiting for any msg with arbitrationId 0x1234.", false); var canController = CanController.FromName(SC20260.CanBus.Can1); canController.SetNominalBitTiming(new GHIElectronics.TinyCLR.Devices.Can.CanBitTiming(15 + 8, 8, 6, 8, false)); // 250Kbit/s canController.SetDataBitTiming(new GHIElectronics.TinyCLR.Devices.Can.CanBitTiming(15 + 8, 8, 3, 8, false)); //500kbit/s canController.Enable(); var message = new CanMessage() { ArbitrationId = 0x1234, ExtendedId = true, FdCan = true, BitRateSwitch = true, Data = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 }, Length = 8 }; var result = false; while (this.doNext == false && this.isRunning) { if (canController.MessagesToRead == 0) { try { canController.WriteMessage(message); } catch { canController.Disable(); Thread.Sleep(100); canController.Enable(); } Thread.Sleep(1000); continue; } var msgs = new GHIElectronics.TinyCLR.Devices.Can.CanMessage[canController.MessagesToRead]; for (var i = 0; i < msgs.Length; i++) { msgs[i] = new GHIElectronics.TinyCLR.Devices.Can.CanMessage(); } for (var i = 0; i < msgs.Length; i++) { canController.ReadMessages(msgs, 0, msgs.Length); if (msgs[i].ArbitrationId == message.ArbitrationId) { this.doNext = true; result = true; break; } } if (result) { break; } } canController.Disable(); this.RemoveNextButton(); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="SaciaBoard"/> class. /// </summary> /// <param name="sequenceNumber"> /// The CAN board sequence number as an integer /// representation of its binary dip switch position /// </param> /// <param name="controller"> /// The <see cref="CanController"/> associated with this board. /// </param> public SaciaBoard(int sequenceNumber, CanController controller) : base(sequenceNumber, controller) { Inputs = new SaciaInputs(); Outputs = new SaciaOutputs(); }
/// <summary> /// Initializes a new instance of the <see cref="DynamicSaciaBoard"/> class. /// </summary> /// <param name="defaultSequenceNumber"> /// The initial CAN board sequence number as an integer /// representation of its binary dip switch position to /// listen for. /// </param> /// <param name="listenForSequenceNumbers"> /// The sequence numbers to listen for. /// </param> /// <param name="controller"> /// The <see cref="CanController"/> associated with this board. /// </param> public DynamicSaciaBoard(int defaultSequenceNumber, int[] listenForSequenceNumbers, CanController controller) : base(defaultSequenceNumber, controller) { PotentialSequenceNumbers = listenForSequenceNumbers; controller.CanMessageRecieved += (sender, args) => { if (args.Message.Address == ((Range | (SequenceNumber << 4)) | 8)) { Parse(args.Message.Data); } else { if (PotentialSequenceNumbers.Any(i => args.Message.Address == ((Range | (i << 4)) | 8))) { int oldNumber = SequenceNumber; SequenceNumber = PotentialSequenceNumbers.First(i => args.Message.Address == ((Range | (i << 4)) | 8)); SequenceNumberChanged?.Invoke(this, new SequenceNumberChangedEventArgs(oldNumber, SequenceNumber)); Parse(args.Message.Data); } } }; }
//Triggered when an error on the CAN bus occurs private static void Can_ErrorReceived(CanController sender, ErrorReceivedEventArgs e) => System.Diagnostics.Debug.WriteLine("error " + ((object)e.Error).ToString());