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());
