public CommunicationsBus(string uartPort, int baudRate = 9600)
{
this.disposed = false;
this.commandFile = null;
this.protocal = CommunicationsProtocal.Uart;
this.uartPort = uartPort;
this.serialPort = UartController.FromName(uartPort);
var uartSetting = new UartSetting()
{
BaudRate = baudRate,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None //UartHandshake.RequestToSend
};
this.serialPort.SetActiveSettings(uartSetting);
this.serialPort.WriteBufferSize = 16 * 1024;
this.serialPort.ReadBufferSize = 16 * 1024;
this.serialPort.Enable();
}
// TODO: if we want to make this public then we're going to have to add
// a bunch of checks around baud rate, 8n1, etc.
protected Mt3339(string serialPortControllerName)
{
serialPort = UartController.FromName(serialPortControllerName);
var uartSetting = new UartSetting()
{
BaudRate = 115200,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None,
};
serialPort.SetActiveSettings(uartSetting);
serialPort.Enable();
serialPort.DataReceived += SerialPort_DataReceived;
//this.serialPort = serialPort;
//this.serialPort.MessageReceived += SerialPort_MessageReceived;
Init();
}
protected void OpenComPort(string port = "COM1", int baudRate = 38400)
{
CloseComPort();
//ToDo serialPort = new SerialPort(port, baudRate, Parity.None, 8, StopBits.One);
//serialPort.ReadTimeout = 10 * 2;
vc0706.ReadTimeout = 10 * 2;
// serialPort.WriteTimeout = 10 * 2;
//serialPort.Enable();
serialPort = UartController.FromName(port);
var uartSetting = new UartSetting()
{
BaudRate = baudRate,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None,
};
vc0706.BaudRate = baudRate;
serialPort.SetActiveSettings(uartSetting);
serialPort.Enable();
}
static void StartMaster()
{//MASTER
var serial = GHIElectronics.TinyCLR.Devices.Uart.UartController.FromName
(GHIElectronics.TinyCLR.Pins.SC20260.UartPort.Uart5);
var setting = new UartSetting()
{
BaudRate = 19200,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None,
};
serial.SetActiveSettings(setting);
serial.Enable();
GHIElectronics.TinyCLR.Devices.Modbus.Interface.IModbusInterface mbInterface;
mbInterface = new GHIElectronics.TinyCLR.Devices.Modbus.Interface.ModbusRtuInterface(
serial,
19200,
8,
GHIElectronics.TinyCLR.Devices.Uart.UartStopBitCount.One,
GHIElectronics.TinyCLR.Devices.Uart.UartParity.None);
GHIElectronics.TinyCLR.Devices.Modbus.ModbusMaster mbMaster;
mbMaster = new GHIElectronics.TinyCLR.Devices.Modbus.ModbusMaster(mbInterface);
var mbTimeout = false;
ushort[] reply = null;
int count = 0;
while (true)
{
try
{
mbTimeout = false;
reply = mbMaster.ReadHoldingRegisters(11, 0, 1, 3333);
count++;
//if (count == 5)
// break;
}
catch (System.Exception error)
{
System.Diagnostics.Debug.WriteLine("Modbus Timeout");
mbTimeout = true;
}
if (!mbTimeout)
{
System.Diagnostics.Debug.WriteLine("Modbus : " + (object)reply[0].ToString());
}
System.Threading.Thread.Sleep(1000);
}
}
private bool DoTestUart()
{
this.UpdateStatusText("Testing VCOM Uart5.", true);
this.UpdateStatusText(" - Connect VCOM Uart5 to PC.", false);
this.UpdateStatusText(" - Open Tera Term. Baudrate: 9600, Data: 8, Parity: None, StopBit: One.", false);
this.UpdateStatusText(" - Type 'A' or 'a'", false);
this.UpdateStatusText(" - The test is waiting any character on Tera Term screen.", false);
var result = false;
using (var uart5 = UartController.FromName(SC20260.UartPort.Uart5)) {
var setting = new UartSetting()
{
BaudRate = 9600
};
uart5.SetActiveSettings(setting);
uart5.Enable();
this.AddNextButton();
while (this.doNext == false && this.isRunning)
{
if (uart5.BytesToRead == 0)
{
Thread.Sleep(100);
uart5.Write(new byte[] { (byte)('a') });
continue;
}
var byteToRead = uart5.BytesToRead > uart5.ReadBufferSize ? uart5.ReadBufferSize : uart5.BytesToRead;
var read = new byte[byteToRead];
uart5.Read(read);
for (var i = 0; i < read.Length; i++)
{
if (read[i] == 'a')
{
result = true;
break;
}
}
if (result == true)
{
break;
}
}
}
this.RemoveNextButton();
return(result);
}
private void ThreadTest()
{
this.isRuning = true;
using (var uart1 = UartController.FromName(SC20260.UartPort.Uart5)) {
var setting = new UartSetting()
{
BaudRate = 115200
};
uart1.SetActiveSettings(setting);
uart1.Enable();
var totalReceived = 0;
var totalSent = 0;
while (this.isRuning)
{
this.UpdateStatusText("Total received: " + totalReceived, true);
this.UpdateStatusText("Total sent: " + totalSent, false);
this.UpdateStatusText(WaitForMessage, false);
while (uart1.BytesToRead == 0)
{
Thread.Sleep(10);
}
var byteToRead = uart1.BytesToRead > uart1.ReadBufferSize ? uart1.ReadBufferSize : uart1.BytesToRead;
var read = new byte[byteToRead];
this.UpdateStatusText("Receiving... " + byteToRead + " byte(s)", false);
totalReceived += uart1.Read(read);
for (var i = 0; i < read.Length; i++)
{
var write = new byte[1] {
(byte)(read[i] + 1)
};
totalSent += uart1.Write(write);
uart1.Flush();
}
this.UpdateStatusText("Writing back... " + byteToRead + " byte(s)", false);
}
}
this.isRuning = false;
return;
}
public void SetBaudRate(int baudRate)
{
var uartSetting = new UartSetting()
{
BaudRate = baudRate,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None //UartHandshake.RequestToSend
};
this.serialPort.SetActiveSettings(uartSetting);
}
/// <summary>
/// Create a new SerialTextFile and attach the instance to the specfied serial port.
/// </summary>
/// <param name="port">Serial port name.</param>
/// <param name="baudRate">Baud rate.</param>
/// <param name="parity">Parity.</param>
/// <param name="dataBits">Data bits.</param>
/// <param name="stopBits">Stop bits.</param>
/// <param name="endOfLine">Text indicating the end of a line of text.</param>
public SerialTextFile(string UartControllerName, int baudRate, UartParity parity, int dataBits, UartStopBitCount stopBits,
string endOfLine)
{
serialPort = UartController.FromName(UartControllerName);
var uartSetting = new UartSetting()
{
BaudRate = baudRate,
DataBits = dataBits,
Parity = parity,
StopBits = stopBits,
Handshaking = UartHandshake.None,
};
serialPort.SetActiveSettings(uartSetting);
serialPort.Enable();
IsEnabled = true;
LINE_END = endOfLine;
serialPort.DataReceived += SerialPort_DataReceived;
}
/// <summary>
/// Create an IDxxLA RFID reader
/// </summary>
/// <param name="device">Device to use</param>
/// <param name="serialPortName">Port name to use</param>
public IDxxLA(string serialPortName)
{
var myUart = UartController.FromName(serialPortName);
var uartSetting = new UartSetting()
{
BaudRate = 115200,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None,
};
myUart.SetActiveSettings(uartSetting);
Setup(myUart);
//device.CreateSerialPort(serialPortName, BaudRate, DataBits))
}
public Vc0706(string serialPortName, int baudRate)
{
//serialPort = device.CreateSerialPort(serialPortName, baudRate);
serialPort = UartController.FromName(serialPortName);
var uartSetting = new UartSetting()
{
BaudRate = baudRate,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None,
};
serialPort.SetActiveSettings(uartSetting);
serialPort.Enable();
vc0706 = new Vc0706Core();
vc0706.BaudRate = baudRate;
vc0706.PortName = serialPortName;
}
static void StartSlave()
{
//SLAVE
var slavePort = GHIElectronics.TinyCLR.Devices.Uart.UartController.FromName
(GHIElectronics.TinyCLR.Pins.SC20260.UartPort.Uart5);
var setting = new UartSetting()
{
BaudRate = 19200,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None,
};
slavePort.SetActiveSettings(setting);
slavePort.Enable();
//new SerialPort("COM1", 19200, Parity.None, 8, StopBits.One);
var RtuInterface = new ModbusRtuInterface(slavePort, 19200, 8, UartStopBitCount.One, UartParity.None);
Debug.WriteLine("rtu open:" + RtuInterface.isOpen + ", rtu connection:" + RtuInterface.IsConnectionOk);
byte ModbusID = 5;
slave = new ModbusSlave(RtuInterface, ModbusID);
slave.CoilsChanged += Slave_CoilsChanged;
slave.RegistersChanged += Slave_RegistersChanged;
//
// Init the SLAVE REGISTERS
//
initSlave();
//
// Start the slave now
//
slave.Start();
Debug.WriteLine("running:" + slave.IsRunning);
}
public CommunicationsBus(string uartPort, int baudRate = 115200)
{
this.disposed = false;
this.commandFile = null;
this.protocal = CommunicationsProtocal.Uart;
this.serialPort = UartController.FromName(uartPort);
var uartSetting = new UartSetting()
{
BaudRate = baudRate,
DataBits = 8,
Parity = UartParity.None,
StopBits = UartStopBitCount.One,
Handshaking = UartHandshake.None
};
this.serialPort.SetActiveSettings(uartSetting);
this.serialPort.Enable();
this.serialPort.DataReceived += this.SerialPort_DataReceived;
}
/// <summary>
/// Create a new SerialLcd object.
/// </summary>
/// <param name="config">TextDisplayConfig object defining the Lcd dimension (null will default to 16x2).</param>
/// <param name="baudRate">Baud rate to use (default = 9600).</param>
/// <param name="parity">Parity to use (default is None).</param>
/// <param name="dataBits">Number of data bits (default is 8 data bits).</param>
/// <param name="stopBits">Number of stop bits (default is one stop bit).</param>
public SerialLcd(string portName, TextDisplayConfig config = null, int baudRate = 9600,
UartParity parity = UartParity.None, int dataBits = 8, UartStopBitCount stopBits = UartStopBitCount.One)
{
if (config == null)
{
// assume a 16x2 Lcd.
DisplayConfig = new TextDisplayConfig()
{
Height = 2, Width = 16
};
}
else
{
DisplayConfig = config;
}
var myUart = UartController.FromName(portName);
var uartSetting = new UartSetting()
{
BaudRate = baudRate,
DataBits = dataBits,
Parity = parity,
StopBits = stopBits,
Handshaking = UartHandshake.None,
};
myUart.SetActiveSettings(uartSetting);
myUart.Enable();
// configure the Lcd controller for the appropriate screen size
byte lines = 0;
byte characters = 0;
switch (DisplayConfig.Width)
{
case 16:
characters = (byte)LcdDimensions.Characters16Wide;
break;
case 20:
characters = (byte)LcdDimensions.Characters20Wide;
break;
default:
throw new ArgumentOutOfRangeException(nameof(config.Width), "Display width should be 16 or 20.");
}
switch (DisplayConfig.Height)
{
case 2:
lines = (byte)LcdDimensions.Lines2;
break;
case 4:
lines = (byte)LcdDimensions.Lines4;
break;
default:
throw new ArgumentOutOfRangeException(nameof(config.Height), "Display height should be 2 or 4 lines.");
}
Send(new[] { ConfigurationCommandCharacter, characters, ConfigurationCommandCharacter, lines });
Thread.Sleep(10);
}
