518 lines
20 KiB
C#
518 lines
20 KiB
C#
//
|
||
// SJA1000 CAN 控制器外设实现（简化版，支持发送/接收队列，可配置长度）
|
||
// 仅支持 PeliCAN 模式的标准帧，不考虑 BasicCAN、扩展帧、错误处理、多帧、验收滤波和发送中断。
|
||
// 寄存器地址映射基于 PeliCAN 模式，包含 MOD, CMR, SR, IR, IER, BTR0, BTR1, OCR, RXERR, TXERR,
|
||
// 发送缓冲区（地址 16-26）、RBSA 和 CDR。命令寄存器位2=RRB，位3=CDO。
|
||
// 所有寄存器可随时读写，无复位模式限制。
|
||
//
|
||
// 队列长度可通过修改静态字段 MaxTxQueueSize 和 MaxRxQueueSize 调整。
|
||
// 发送队列满时，CPU 发送请求被忽略，并设置 TBS=0（发送缓冲区忙）；
|
||
// 接收队列满时，外部注入的新帧被丢弃。
|
||
//
|
||
// 日志开关：EnableVerboseLog = false 可关闭所有日志输出。
|
||
//
|
||
|
||
using System;
|
||
using System.Text;
|
||
using System.Collections.Generic;
|
||
using Antmicro.Renode.Core;
|
||
using Antmicro.Renode.Logging;
|
||
using Antmicro.Renode.Peripherals.Bus;
|
||
using Antmicro.Renode.Utilities;
|
||
using Antmicro.Renode.Time;
|
||
|
||
namespace Antmicro.Renode.Peripherals.CustomPeripherals
|
||
{
|
||
/// <summary>
|
||
/// 简化版 SJA1000 CAN 控制器（PeliCAN 模式，仅标准帧）
|
||
/// </summary>
|
||
public class SJA1000_CAN : IDoubleWordPeripheral, IBytePeripheral, IKnownSize
|
||
{
|
||
// 日志开关（设置为 false 可屏蔽所有日志）
|
||
public static bool EnableVerboseLog = false;
|
||
|
||
// 队列长度配置（可修改）
|
||
public static int MaxTxQueueSize = 64; // 发送队列最大帧数
|
||
public static int MaxRxQueueSize = 64; // 接收队列最大帧数
|
||
|
||
public SJA1000_CAN(IMachine machine)
|
||
{
|
||
this.machine = machine;
|
||
IRQ = new GPIO();
|
||
|
||
txBuffer = new byte[11];
|
||
rxBuffer = new byte[11];
|
||
txFrameQueue = new Queue<byte[]>(); // 发送队列
|
||
rxFrameQueue = new Queue<byte[]>(); // 接收队列
|
||
|
||
Reset();
|
||
}
|
||
|
||
public void Reset()
|
||
{
|
||
mod = 0;
|
||
ier = 0;
|
||
btr0 = 0;
|
||
btr1 = 0;
|
||
ocr = 0;
|
||
rxerr = 0;
|
||
txerr = 0;
|
||
rbsa = 0;
|
||
cdr = 0;
|
||
|
||
sr_tbs = 1; // 发送缓冲区初始为空闲
|
||
sr_rbs = 0; // 接收缓冲区初始为空
|
||
ir = 0;
|
||
|
||
Array.Clear(txBuffer, 0, txBuffer.Length);
|
||
Array.Clear(rxBuffer, 0, rxBuffer.Length);
|
||
txFrameQueue.Clear();
|
||
rxFrameQueue.Clear();
|
||
|
||
lastInterruptState = false; // 重置中断边沿状态
|
||
UpdateInterrupts();
|
||
|
||
if (EnableVerboseLog)
|
||
this.Log(LogLevel.Info, $"SJA1000 CAN controller reset (txQueueMax={MaxTxQueueSize}, rxQueueMax={MaxRxQueueSize})");
|
||
}
|
||
|
||
// ================ IBusPeripheral 接口实现 ================
|
||
|
||
public uint ReadDoubleWord(long offset)
|
||
{
|
||
return ReadByte(offset);
|
||
}
|
||
|
||
public void WriteDoubleWord(long offset, uint value)
|
||
{
|
||
WriteByte(offset, (byte)value);
|
||
}
|
||
|
||
public byte ReadByte(long offset)
|
||
{
|
||
byte value = 0;
|
||
lock (lockObject)
|
||
{
|
||
switch ((Registers)offset)
|
||
{
|
||
case Registers.MOD:
|
||
value = mod;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read MOD: 0x{0:X2}", value);
|
||
break;
|
||
|
||
case Registers.CMR:
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read CMR (always 0)");
|
||
value = 0;
|
||
break;
|
||
|
||
case Registers.SR:
|
||
value = (byte)((sr_tbs << 2) | sr_rbs); // BS 恒为0
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read SR: TBS={0}, RBS={1} -> 0x{2:X2}", sr_tbs, sr_rbs, value);
|
||
break;
|
||
|
||
case Registers.IR:
|
||
value = ir;
|
||
ir = 0;
|
||
UpdateIrFromRbs();
|
||
// 中断被软件清除，重置边沿检测状态，允许下次条件满足时再次触发中断
|
||
lastInterruptState = false;
|
||
UpdateInterrupts();
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read IR: 0x{0:X2}, cleared", value);
|
||
break;
|
||
|
||
case Registers.IER:
|
||
value = ier;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read IER: 0x{0:X2}", value);
|
||
break;
|
||
|
||
case Registers.BTR0:
|
||
value = btr0;
|
||
break;
|
||
case Registers.BTR1:
|
||
value = btr1;
|
||
break;
|
||
case Registers.OCR:
|
||
value = ocr;
|
||
break;
|
||
case Registers.RXERR:
|
||
value = rxerr;
|
||
break;
|
||
case Registers.TXERR:
|
||
value = txerr;
|
||
break;
|
||
case Registers.RBSA:
|
||
value = rbsa;
|
||
break;
|
||
case Registers.CDR:
|
||
value = cdr;
|
||
break;
|
||
|
||
// 发送/接收缓冲区地址 16-26
|
||
case Registers.TX_FRAME_INFO:
|
||
case Registers.TX_ID1:
|
||
case Registers.TX_ID2:
|
||
case Registers.TX_DATA1:
|
||
case Registers.TX_DATA2:
|
||
case Registers.TX_DATA3:
|
||
case Registers.TX_DATA4:
|
||
case Registers.TX_DATA5:
|
||
case Registers.TX_DATA6:
|
||
case Registers.TX_DATA7:
|
||
case Registers.TX_DATA8:
|
||
int bufIndex = (int)(offset - (long)Registers.TX_FRAME_INFO) / 4;
|
||
if (sr_rbs == 1)
|
||
{
|
||
value = rxBuffer[bufIndex];
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read RX buffer[{0}]: 0x{1:X2}", bufIndex, value);
|
||
}
|
||
else
|
||
{
|
||
value = txBuffer[bufIndex];
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read TX buffer[{0}]: 0x{1:X2}", bufIndex, value);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Read from unimplemented offset 0x{0:X}", offset);
|
||
value = 0;
|
||
break;
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
public void WriteByte(long offset, byte value)
|
||
{
|
||
lock (lockObject)
|
||
{
|
||
switch ((Registers)offset)
|
||
{
|
||
case Registers.MOD:
|
||
mod = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write MOD: 0x{0:X2}", value);
|
||
break;
|
||
|
||
case Registers.CMR:
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write CMR: 0x{0:X2}", value);
|
||
if ((value & CMR_TR) != 0)
|
||
{
|
||
// 发送请求
|
||
if (sr_tbs == 1)
|
||
{
|
||
var frame = new byte[11];
|
||
|
||
if (txFrameQueue.Count < (MaxTxQueueSize - 1))
|
||
{
|
||
Array.Copy(txBuffer, frame, 11);
|
||
txFrameQueue.Enqueue(frame);
|
||
Array.Clear(txBuffer, 0, txBuffer.Length);
|
||
sr_tbs = 1;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Frame enqueued for transmission, queue size: {0}", txFrameQueue.Count);
|
||
}
|
||
else if (txFrameQueue.Count == (MaxTxQueueSize - 1))
|
||
{
|
||
Array.Copy(txBuffer, frame, 11);
|
||
txFrameQueue.Enqueue(frame);
|
||
Array.Clear(txBuffer, 0, txBuffer.Length);
|
||
sr_tbs = 0;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Frame enqueued, TX queue now full, TBS cleared");
|
||
}
|
||
else
|
||
{
|
||
sr_tbs = 0;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Warning, "Send request while TBS=0 ignored");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (EnableVerboseLog) this.Log(LogLevel.Warning, "Send request while TBS=0 ignored");
|
||
}
|
||
}
|
||
if ((value & CMR_RRB) != 0)
|
||
{
|
||
LoadNextRxFrame();
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Receive buffer released");
|
||
}
|
||
if ((value & CMR_CDO) != 0)
|
||
{
|
||
// 清除数据溢出（无操作，但保留接口）
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Clear data overflow (no effect)");
|
||
}
|
||
break;
|
||
|
||
case Registers.SR:
|
||
if (EnableVerboseLog) this.Log(LogLevel.Warning, "Attempted write to read-only SR");
|
||
break;
|
||
|
||
case Registers.IR:
|
||
if (EnableVerboseLog) this.Log(LogLevel.Warning, "Attempted write to read-only IR");
|
||
break;
|
||
|
||
case Registers.IER:
|
||
ier = (byte)(value & 0x01);
|
||
UpdateIrFromRbs();
|
||
UpdateInterrupts();
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write IER: 0x{0:X2}", ier);
|
||
break;
|
||
|
||
case Registers.BTR0:
|
||
btr0 = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write BTR0: 0x{0:X2}", value);
|
||
break;
|
||
case Registers.BTR1:
|
||
btr1 = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write BTR1: 0x{0:X2}", value);
|
||
break;
|
||
case Registers.OCR:
|
||
ocr = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write OCR: 0x{0:X2}", value);
|
||
break;
|
||
case Registers.RXERR:
|
||
rxerr = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write RXERR: 0x{0:X2}", value);
|
||
break;
|
||
case Registers.TXERR:
|
||
txerr = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write TXERR: 0x{0:X2}", value);
|
||
break;
|
||
case Registers.RBSA:
|
||
rbsa = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write RBSA: 0x{0:X2}", value);
|
||
break;
|
||
case Registers.CDR:
|
||
cdr = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write CDR: 0x{0:X2}", value);
|
||
break;
|
||
|
||
// 发送缓冲区写入
|
||
case Registers.TX_FRAME_INFO:
|
||
case Registers.TX_ID1:
|
||
case Registers.TX_ID2:
|
||
case Registers.TX_DATA1:
|
||
case Registers.TX_DATA2:
|
||
case Registers.TX_DATA3:
|
||
case Registers.TX_DATA4:
|
||
case Registers.TX_DATA5:
|
||
case Registers.TX_DATA6:
|
||
case Registers.TX_DATA7:
|
||
case Registers.TX_DATA8:
|
||
int bufIndex = (int)(offset - (long)Registers.TX_FRAME_INFO) / 4;
|
||
if (sr_tbs == 1)
|
||
{
|
||
txBuffer[bufIndex] = value;
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write TX buffer[{0}]: 0x{1:X2}", bufIndex, value);
|
||
}
|
||
else
|
||
{
|
||
if (EnableVerboseLog) this.Log(LogLevel.Warning, "Write to TX buffer while TBS=0 ignored");
|
||
}
|
||
break;
|
||
|
||
default:
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Write to unimplemented offset 0x{0:X} = 0x{1:X2}", offset, value);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// ================ 内部辅助方法 ================
|
||
|
||
private void UpdateIrFromRbs()
|
||
{
|
||
if (sr_rbs == 1)
|
||
ir |= IR_RI;
|
||
else
|
||
ir = (byte)(ir & ~IR_RI);
|
||
}
|
||
|
||
private void UpdateInterrupts()
|
||
{
|
||
bool currentInterrupt = ((ir & IR_RI) != 0) && ((ier & IER_RIE) != 0);
|
||
if (currentInterrupt && !lastInterruptState)
|
||
{
|
||
IRQ.Set(true);
|
||
machine.ScheduleAction(TimeInterval.FromMicroseconds(1), _ =>
|
||
{
|
||
IRQ.Set(false);
|
||
});
|
||
if (EnableVerboseLog) this.Log(LogLevel.Info, "Interrupt pulse generated (RI)");
|
||
}
|
||
lastInterruptState = currentInterrupt;
|
||
}
|
||
|
||
private readonly object lockObject = new object();
|
||
|
||
/// <summary>
|
||
/// 获取发送队列中所有帧的字符串表示（每帧以空格分隔的十六进制字节，帧间用换行分隔）
|
||
/// 调用后清空发送队列，并恢复发送缓冲区状态（如果之前因队列满被锁定）。
|
||
/// </summary>
|
||
public string GetTxBufferDataString()
|
||
{
|
||
lock (lockObject)
|
||
{
|
||
if (txFrameQueue.Count == 0)
|
||
{
|
||
if (EnableVerboseLog) Console.WriteLine("GetTxBufferDataString: no frames in TX queue");
|
||
if (sr_tbs == 0) sr_tbs = 1;
|
||
return null;
|
||
}
|
||
var sb = new StringBuilder();
|
||
while (txFrameQueue.Count > 0)
|
||
{
|
||
var frame = txFrameQueue.Dequeue();
|
||
for (int i = 0; i < frame.Length; i++)
|
||
{
|
||
if (i > 0) sb.Append(" ");
|
||
sb.Append(frame[i].ToString("X2"));
|
||
}
|
||
sb.AppendLine();
|
||
}
|
||
string result = sb.ToString().TrimEnd();
|
||
sr_tbs = 1;
|
||
if (EnableVerboseLog) Console.WriteLine("GetTxBufferDataString returning: " + result);
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 外部接口注入一帧接收数据（11字节的十六进制字符串，空格分隔）
|
||
/// 可多次调用以注入多帧，帧将存入接收队列。
|
||
/// 若接收队列已满，则新帧被丢弃。
|
||
/// </summary>
|
||
public void SendRxBufferDataString(string frameString)
|
||
{
|
||
lock (lockObject)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(frameString))
|
||
{
|
||
if (EnableVerboseLog) Console.WriteLine("SendRxBufferDataString: empty string, ignored");
|
||
return;
|
||
}
|
||
string[] parts = frameString.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
|
||
if (parts.Length != 11)
|
||
{
|
||
if (EnableVerboseLog) Console.WriteLine($"SendRxBufferDataString: expected 11 bytes, got {parts.Length}, ignored");
|
||
return;
|
||
}
|
||
byte[] frame = new byte[11];
|
||
for (int i = 0; i < 11; i++)
|
||
{
|
||
string part = parts[i].Trim();
|
||
if (!byte.TryParse(part, System.Globalization.NumberStyles.HexNumber,
|
||
System.Globalization.CultureInfo.InvariantCulture, out byte b))
|
||
{
|
||
if (EnableVerboseLog) Console.WriteLine($"SendRxBufferDataString: invalid hex byte '{part}' at index {i}, set to 0");
|
||
b = 0;
|
||
}
|
||
frame[i] = b;
|
||
}
|
||
|
||
if (rxFrameQueue.Count >= MaxRxQueueSize)
|
||
{
|
||
if (EnableVerboseLog) Console.WriteLine($"SendRxBufferDataString: RX queue full (max={MaxRxQueueSize}), frame dropped");
|
||
return;
|
||
}
|
||
|
||
rxFrameQueue.Enqueue(frame);
|
||
if (EnableVerboseLog) Console.WriteLine($"Frame enqueued to RX queue, size: {rxFrameQueue.Count}");
|
||
|
||
if (sr_rbs == 0)
|
||
{
|
||
LoadNextRxFrame();
|
||
}
|
||
}
|
||
}
|
||
|
||
private void LoadNextRxFrame()
|
||
{
|
||
if (rxFrameQueue.Count > 0)
|
||
{
|
||
var frame = rxFrameQueue.Dequeue();
|
||
Array.Copy(frame, rxBuffer, 11);
|
||
sr_rbs = 1;
|
||
UpdateIrFromRbs();
|
||
UpdateInterrupts();
|
||
if (EnableVerboseLog) Console.WriteLine("Loaded next RX frame into buffer, queue remaining: {0}", rxFrameQueue.Count);
|
||
}
|
||
else
|
||
{
|
||
sr_rbs = 0;
|
||
UpdateIrFromRbs();
|
||
UpdateInterrupts();
|
||
if (EnableVerboseLog) Console.WriteLine("RX queue empty, buffer cleared");
|
||
}
|
||
}
|
||
|
||
// ================ 属性 ================
|
||
|
||
public long Size => 0x80;
|
||
|
||
public GPIO IRQ { get; }
|
||
|
||
// ================ 寄存器枚举 ================
|
||
|
||
private enum Registers : long
|
||
{
|
||
MOD = 0x00,
|
||
CMR = 0x04,
|
||
SR = 0x08,
|
||
IR = 0x0C,
|
||
IER = 0x10,
|
||
BTR0 = 0x18,
|
||
BTR1 = 0x1C,
|
||
OCR = 0x20,
|
||
RXERR = 0x38,
|
||
TXERR = 0x3C,
|
||
TX_FRAME_INFO = 0x40,
|
||
TX_ID1 = 0x44,
|
||
TX_ID2 = 0x48,
|
||
TX_DATA1 = 0x4C,
|
||
TX_DATA2 = 0x50,
|
||
TX_DATA3 = 0x54,
|
||
TX_DATA4 = 0x58,
|
||
TX_DATA5 = 0x5C,
|
||
TX_DATA6 = 0x60,
|
||
TX_DATA7 = 0x64,
|
||
TX_DATA8 = 0x68,
|
||
RBSA = 0x78,
|
||
CDR = 0x7C,
|
||
}
|
||
|
||
// ================ 常量位定义 ================
|
||
|
||
private const byte CMR_TR = 0x01;
|
||
private const byte CMR_RRB = 0x04;
|
||
private const byte CMR_CDO = 0x08;
|
||
|
||
private const byte SR_BS = 0x80;
|
||
private const byte SR_TBS = 0x04;
|
||
private const byte SR_RBS = 0x01;
|
||
|
||
private const byte IR_RI = 0x01;
|
||
private const byte IER_RIE = 0x01;
|
||
|
||
// ================ 私有字段 ================
|
||
|
||
private readonly IMachine machine;
|
||
|
||
private byte mod;
|
||
private byte ier;
|
||
private byte btr0, btr1;
|
||
private byte ocr;
|
||
private byte rxerr, txerr;
|
||
private byte rbsa;
|
||
private byte cdr;
|
||
|
||
private byte sr_tbs;
|
||
private byte sr_rbs;
|
||
private byte ir;
|
||
|
||
private bool lastInterruptState; // 用于中断边沿检测
|
||
|
||
private readonly byte[] txBuffer;
|
||
private readonly byte[] rxBuffer;
|
||
|
||
private readonly Queue<byte[]> txFrameQueue;
|
||
private readonly Queue<byte[]> rxFrameQueue;
|
||
}
|
||
} |