public Result Initialise(string serialPortId, int baudRate, UartParity serialParity, int dataBits, UartStopBitCount stopBitCount) { if ((serialPortId == null) || (serialPortId == "")) { throw new ArgumentException("Invalid SerialPortId", "serialPortId"); } if ((baudRate < BaudRateMinimum) || (baudRate > BaudRateMaximum)) { throw new ArgumentException("Invalid BaudRate", "baudRate"); } serialDevice = UartController.FromName(serialPortId); // set parameters serialDevice.SetActiveSettings(new UartSetting() { BaudRate = baudRate, Parity = serialParity, StopBits = stopBitCount, Handshaking = UartHandshake.None, DataBits = dataBits }); serialDevice.Enable(); atCommandExpectedResponse = string.Empty; serialDevice.DataReceived += SerialDevice_DataReceived; // Ignoring the return from this is intentional this.SendCommand("+LOWPOWER: WAKEUP", "AT+LOWPOWER: WAKEUP", SendTimeoutMinimum); return(Result.Success); }
/// <summary>Initializes a new instance of the <see cref="GPS2Click" /> class.</summary> /// <param name="socket">The socket on which the module is plugged</param> public GPS2Click(Hardware.Socket socket) { _sl = new SerialListener('$', '\n'); _sl.MessageAvailable += Sl_MessageAvailable; _wakeUp = GpioController.GetDefault().OpenPin(socket.AnPin); _wakeUp.SetDriveMode(GpioPinDriveMode.Input); _onOff = GpioController.GetDefault().OpenPin(socket.PwmPin); _onOff.SetDriveMode(GpioPinDriveMode.Output); // Force full mode _onOff.Write(GpioPinValue.Low); Thread.Sleep(100); _onOff.Write(GpioPinValue.High); Thread.Sleep(100); _onOff.Write(GpioPinValue.Low); Thread.Sleep(1); _onOff.Write(GpioPinValue.High); Thread.Sleep(100); _gps2 = UartController.FromName(socket.ComPort); // Socket #1 _gps2.SetActiveSettings(new UartSetting() { BaudRate = 4800, DataBits = 8, Parity = UartParity.None, StopBits = UartStopBitCount.One, Handshaking = UartHandshake.None }); _gps2.DataReceived += Gps2_DataReceived; _gps2.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(); }
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(); }
static void Main() { RtcController rtc = RtcController.GetDefault(); try { var t = rtc.GetTime(); if (t.Year == 1980) { rtc.SetTime(RtcDateTime.FromDateTime(new DateTime(2018, 10, 12, 17, 51, 00))); } } catch (Exception) { rtc.SetTime(RtcDateTime.FromDateTime(new DateTime(2018, 10, 11, 11, 51, 00))); } //string COM = "GHIElectronics.TinyCLR.NativeApis.STM32F7.UartController\\2"; UartController ser = UartController.FromName(STM32F7.UartPort.Usart1); // DISCO-F769 //UartController ser = UartController.FromName(STM32F7.UartPort.Usart3); // NUCLEO-F767 ser.SetActiveSettings(38400, 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); Debug.WriteLine("Starting Program ...."); BlinkLed blink = new BlinkLed(STM32F7.GpioPin.PJ5, 500); // Disco 769 //BlinkLed blink = new BlinkLed(STM32F7.GpioPin.PB7, 500); // Nucleo 144 - F767 Thread run = new Thread(blink.Blink); run.Start(); var r = new HeapAllocTest(10); r.Allocate(); //var d = new DisplayTest(); string sallocated = ""; //Debug.WriteLine("Allocated TOTAL Memory:" + GC.GetTotalMemory(false).ToString() + " bytes!"); //d.DrawSomething("Test String...", 50,50); int x = 10, y = 10; //SDTest sd = new SDTest(); sallocated = "Memory:" + GC.GetTotalMemory(true).ToString() + " bytes!"; while (true) { x += 2; y += 2; if (x > (800 - 160) || y > 480 - 160) { x = 10; y = 10; GC.Collect(); } Thread.Sleep(1000); //d.DrawSomething(sallocated, x, y); var dt = rtc.Now; byte[] b = System.Text.Encoding.UTF8.GetBytes("Program Running !! .." + dt.ToString("dd/MM/yyyy HH:mm:ss") + "\r\n"); ser.Write(b); ser.Flush(); } }
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 static void Main() { Debug.WriteLine("devMobile.IoT.Rak811.ShieldSerial starting"); try { serialDevice = UartController.FromName(SerialPortId); serialDevice.SetActiveSettings(new UartSetting() { BaudRate = 9600, Parity = UartParity.None, StopBits = UartStopBitCount.One, Handshaking = UartHandshake.None, DataBits = 8 }); serialDevice.Enable(); #if SERIAL_ASYNC_READ serialDevice.DataReceived += SerialDevice_DataReceived; #endif while (true) { byte[] txBuffer = UTF8Encoding.UTF8.GetBytes(ATCommand); int txByteCount = serialDevice.Write(txBuffer); Debug.WriteLine($"TX: {txByteCount} bytes"); #if SERIAL_SYNC_READ while (serialDevice.BytesToWrite > 0) { Debug.WriteLine($" BytesToWrite {serialDevice.BytesToWrite}"); Thread.Sleep(100); } int rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX sync:{rxByteCount} bytes read"); String response = UTF8Encoding.UTF8.GetString(rxBuffer); Debug.WriteLine($"RX sync:{response}"); } #endif Thread.Sleep(20000); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
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); }
/// <summary> /// Initializes a new instance of the <see cref="FTDIClick" /> class. /// </summary> /// <param name="socket">The socket on which the FTDIClick module is plugged on MikroBus.Net board</param> /// <param name="baudRate">The baud rate.</param> /// <param name="parity">The parity.</param> /// <param name="dataBits">The data bits.</param> /// <param name="stopBits">The stop bits.</param> public FTDIClick(Hardware.Socket socket, Int32 baudRate = 9600, UartParity parity = UartParity.None, Int32 dataBits = 8, UartStopBitCount stopBits = UartStopBitCount.One) { _sp = UartController.FromName(socket.ComPort); _sp.SetActiveSettings(new UartSetting() { BaudRate = baudRate, DataBits = dataBits, Parity = parity, StopBits = stopBits, Handshaking = UartHandshake.None }); _sp.Enable(); }
/// <summary> /// Initializes a new instance of the <see cref="SpeakUpClick"/> class. /// </summary> /// <param name="socket">The socket on which the SpeakUpClick module is plugged on MikroBus.Net board</param> public SpeakUpClick(Hardware.Socket socket) { _sp = UartController.FromName(socket.ComPort); _sp.SetActiveSettings(new UartSetting() { BaudRate = 115200, DataBits = 8, Parity = UartParity.None, StopBits = UartStopBitCount.One, Handshaking = UartHandshake.None }); _sp.Enable(); }
public MusicalInstrumentShield(string uart) { this.uart = UartController.FromName(uart); this.uart.SetActiveSettings((int)(31250), 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); this.uart.Enable(); }
/// <summary> /// Initializes a new instance of the <see cref="DevantechLcd03"/> class using serial communication (UART) /// </summary> /// <param name="socket">The socket on MBN board where the Lcd is connected</param> public DevantechLcd03(Hardware.Socket socket) { try { _lcdSerial = UartController.FromName(socket.ComPort); _lcdSerial.SetActiveSettings(9600, 8, UartParity.None, UartStopBitCount.Two, UartHandshake.None); _lcdSerial.Enable(); _isUart = true; Init(); } catch { } }
/// <summary>Initializes a new instance of the <see cref="GNSSClick" /> class.</summary> /// <param name="socket">The socket on which the module is plugged</param> public GNSSClick(Hardware.Socket socket) { _sl = new SerialListener('$', '\n'); _sl.MessageAvailable += Sl_MessageAvailable; _gnss = UartController.FromName(socket.ComPort); _gnss.SetActiveSettings(9600, 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); _gnss.DataReceived += Gnss_DataReceived; _gnss.Enable(); // It seems that we need to send a command so that the module starts sending its data. // So we send a command to request firmware version SendCommand("PMTK605"); }
/// <summary>Initializes a new instance of the <see cref="Gnss4Click" /> class.</summary> /// <param name="socket">The socket on which the module is plugged</param> public Gnss4Click(Hardware.Socket socket) { _sl = new SerialListener('$', '\n'); _sl.MessageAvailable += Sl_MessageAvailable; _gnss = UartController.FromName(socket.ComPort); _gnss.SetActiveSettings(new UartSetting() { BaudRate = 9600, DataBits = 8, Parity = UartParity.None, StopBits = UartStopBitCount.One, Handshaking = UartHandshake.None }); _gnss.DataReceived += Gnss_DataReceived; _gnss.Enable(); }
public CommunicationsBus(string uartPort, int baudRate = 115200) { this.disposed = false; this.commandFile = null; this.protocal = CommunicationsProtocal.Uart; this.serialPort = UartController.FromName(uartPort); this.serialPort.SetActiveSettings(baudRate, 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); this.serialPort.Enable(); this.serialPort.DataReceived += this.SerialPort_DataReceived; }
/// <summary> /// Initializes a new instance of the <see cref="DevantechLcd03"/> class using serial communication (UART) /// </summary> /// <param name="socket">The socket on MBN board where the Lcd is connected</param> public DevantechLcd03(Hardware.Socket socket) { try { _lcdSerial = UartController.FromName(socket.ComPort); _lcdSerial.SetActiveSettings(new UartSetting() { BaudRate = 9600, DataBits = 8, Parity = UartParity.None, StopBits = UartStopBitCount.Two, Handshaking = UartHandshake.None }); _lcdSerial.Enable(); _isUart = true; Init(); } catch { } }
public Result Initialise(string serialPortId, int baudRate, UartParity serialParity, int dataBits, UartStopBitCount stopBitCount) { Result result; if ((serialPortId == null) || (serialPortId == "")) { throw new ArgumentException("Invalid SerialPortId", "serialPortId"); } if ((baudRate < BaudRateMinimum) || (baudRate > BaudRateMaximum)) { throw new ArgumentException("Invalid BaudRate", "baudRate"); } serialDevice = UartController.FromName(serialPortId); // set parameters serialDevice.SetActiveSettings(new UartSetting() { BaudRate = baudRate, Parity = serialParity, StopBits = stopBitCount, Handshaking = UartHandshake.None, DataBits = dataBits }); serialDevice.Enable(); atCommandExpectedResponse = string.Empty; serialDevice.DataReceived += SerialDevice_DataReceived; // Set the Working mode to LoRaWAN #if DIAGNOSTICS Debug.WriteLine($" {DateTime.UtcNow:hh:mm:ss} lora:work_mode LoRaWAN"); #endif result = SendCommand("Initialization OK", "at+set_config=lora:work_mode:0", CommandTimeoutDefault); if (result != Result.Success) { #if DIAGNOSTICS Debug.WriteLine($" {DateTime.UtcNow:hh:mm:ss} lora:work_mode failed {result}"); #endif return(result); } return(Result.Success); }
/// <summary> /// Default constructor /// </summary> /// <param name="socket">The socket in which the USB UART click board is inserted into.</param> /// <param name="baudRate">The baud rate for serial commumications.</param> /// <param name="dataBits"></param> /// <param name="parity"></param> /// <param name="stopBitCount"></param> /// <param name="handShake"></param> public USBUARTClick(Hardware.Socket socket, BaudRate baudRate, Int32 dataBits = 8, UartParity parity = UartParity.None, UartStopBitCount stopBitCount = UartStopBitCount.One, UartHandshake handShake = UartHandshake.None) { _serial = UartController.FromName(socket.ComPort); _serial.SetActiveSettings((Int32)baudRate, dataBits, parity, stopBitCount, handShake); _serial.Enable(); _serial.DataReceived += Serial_DataReceived; _serial.ErrorReceived += Serial_ErrorReceived; _simpleSerial = new SimpleSerial(_serial); _powerPin = GpioController.GetDefault().OpenPin(socket.PwmPin); _powerPin.SetDriveMode(GpioPinDriveMode.InputPullUp); _powerPin.ValueChanged += PowerPin_ValueChanged; _sleepPin = GpioController.GetDefault().OpenPin(socket.Cs); _sleepPin.SetDriveMode(GpioPinDriveMode.Input); _sleepPin.ValueChanged += SleepPin_ValueChanged; }
/// <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)) }
static void Main() { var serial = UartController.FromName("GHIElectronics.TinyCLR.NativeApis.STM32H7.UartController\\2"); var resetPin = 3 * 16 + 15; var gps = new Gps(serial, resetPin); gps.InvalidPositionReceived += Gps_InvalidPositionReceived; gps.NmeaSentenceReceived += Gps_NmeaSentenceReceived; gps.PositionReceived += Gps_PositionReceived; Debug.WriteLine("staring"); gps.Enabled = true; // Start Gps Debug.WriteLine("Enabled"); Thread.Sleep(-1); }
/// <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; }
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; }
/// <summary> /// Construct Bluetooth module /// </summary> /// <param name="pinStatus">GpioPin Pin 3 of U Socket</param> /// <param name="pinReset">GpioPin Pin 6 of U Socket</param> /// <param name="uartId">Uart Id of U Socket</param> public Bluetooth(int pinStatus, int pinReset, string uartId) { // This finds the Socket instance from the user-specified socket number. This will generate user-friendly error messages if the socket is invalid. If there is more than one socket on this // module, then instead of "null" for the last parameter, put text that identifies the socket to the user (e.g. "S" if there is a socket type S) // Socket socket = Socket.GetSocket(socketNumber, true, this, null); rxBuffer = new byte[128]; //this.reset = GTI.DigitalOutputFactory.Create(socket, Socket.Pin.Six, false, this); _reset = GpioController.GetDefault().OpenPin(pinReset); _reset.SetDriveMode(GpioPinDriveMode.Output); _reset.Write(GpioPinValue.Low); // this.statusInt = GTI.InterruptInputFactory.Create(socket, Socket.Pin.Three, GTI.GlitchFilterMode.Off, GTI.ResistorMode.Disabled, GTI.InterruptMode.RisingAndFallingEdge, this); _statusInt = GpioController.GetDefault().OpenPin(pinStatus); _statusInt.SetDriveMode(GpioPinDriveMode.Input); _statusInt.DebounceTimeout = TimeSpan.FromMilliseconds(1); // this.serialPort = GTI.SerialFactory.Create(socket, 38400, GTI.SerialParity.None, GTI.SerialStopBits.One, 8, GTI.HardwareFlowControl.NotRequired, this); _serialPort = UartController.FromName(uartId); _serialPort.SetActiveSettings(38400, 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); _serialPort.Enable(); //_serialPort.DataReceived += _serialPort_DataReceived; //this.statusInt.Interrupt += GTI.InterruptInputFactory.Create.InterruptEventHandler(statusInt_Interrupt); // this.serialPort.ReadTimeout = Timeout.Infinite; // this.serialPort.Open(); //_dataReader = new DataReader(_serialPort.InputStream); //_dataWriter = new DataWriter(_serialPort.OutputStream); Thread.Sleep(5); _reset.Write(GpioPinValue.High); _readerThread = new Thread(RunReaderThread); _readerThread.Start(); Thread.Sleep(500); }
public static void Main() { // Get the display ready var spi = SpiController.FromName(G80.SpiBus.Spi2); var gpio = GpioController.GetDefault(); var st7735 = new ST7735Controller(spi.GetDevice(ST7735Controller.GetConnectionSettings(SpiChipSelectType.Gpio, G80.GpioPin.PD10)), gpio.OpenPin(G80.GpioPin.PE10), gpio.OpenPin(G80.GpioPin.PE12)); st7735.SetDataAccessControl(true, true, false, false); st7735.Enable(); var disp = DisplayController.FromProvider(st7735); disp.SetConfiguration(new SpiDisplayControllerSettings { Width = 160, Height = 128 }); var bl = gpio.OpenPin(G80.GpioPin.PC7); bl.Write(GpioPinValue.High); bl.SetDriveMode(GpioPinDriveMode.Output); var hdc = GraphicsManager.RegisterDrawTarget(new DrawTarget(disp)); screen = Graphics.FromHdc(hdc); screen.Clear(Color.Black); var btn1 = gpio.OpenPin(G80.GpioPin.PE0); btn1.SetDriveMode(GpioPinDriveMode.InputPullUp); btn1.ValueChanged += Btn1_ValueChanged; // Serial port serial = UartController.FromName(G80.UartPort.Usart1); serial.SetActiveSettings(9600, 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); serial.Enable(); serial.DataReceived += Serial_DataReceived; Thread.Sleep(Timeout.Infinite); }
/// <summary> /// Initializes a new instance of the <see cref="SpeakUpClick"/> class. /// </summary> /// <param name="socket">The socket on which the SpeakUpClick module is plugged on MikroBus.Net board</param> public SpeakUpClick(Hardware.Socket socket) { _sp = UartController.FromName(socket.ComPort); _sp.SetActiveSettings(115200, 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); _sp.Enable(); }
private const string payload = "01020304"; // AQIDBA== //private const string payload = "04030201"; // BAMCAQ== public static void Main() { UartController serialDevice; int txByteCount; int rxByteCount; Debug.WriteLine("devMobile.IoT.SeeedE5.NetworkJoinOTAA starting"); try { serialDevice = UartController.FromName(SerialPortId); serialDevice.SetActiveSettings(new UartSetting() { BaudRate = 9600, Parity = UartParity.None, StopBits = UartStopBitCount.One, Handshaking = UartHandshake.None, DataBits = 8 }); serialDevice.Enable(); // Set the Region to AS923 txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("AT+DR=AS923\r\n")); Debug.WriteLine($"TX: DR {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the Join mode txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("AT+MODE=LWOTAA\r\n")); Debug.WriteLine($"TX: MODE {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the appEUI txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"AT+ID=AppEui,\"{AppEui}\"\r\n")); Debug.WriteLine($"TX: ID=AppEui {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the appKey txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"AT+KEY=APPKEY,{AppKey}\r\n")); Debug.WriteLine($"TX: KEY=APPKEY {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the PORT txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"AT+PORT={messagePort}\r\n")); Debug.WriteLine($"TX: PORT {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Join the network txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("AT+JOIN\r\n")); Debug.WriteLine($"TX: JOIN {txByteCount} bytes"); Thread.Sleep(10000); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } while (true) { // Unconfirmed message txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"AT+MSGHEX=\"{payload}\"\r\n")); Debug.WriteLine($"TX: MSGHEX {txByteCount} bytes"); // Confirmed message //txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"AT+CMSGHEX=\"{payload}\"\r\n")); //Debug.WriteLine($"TX: CMSGHEX {txByteCount} bytes"); Thread.Sleep(10000); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } Thread.Sleep(30000); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
// In order to create a truly robust long-running solution, you must combine the code below // with proper use of a Watchdog Timer and exception handling on the wifi calls. // // Hardware note: It has been our experience that to work at 115200 with the ESP8266 and NETMF, you need a 1024 byte serial buffer. // Smaller serial buffers may result in portions of incoming TCP traffic being dropped, which can also break the protocol processing // and result in hangs. static void Main() { _rfPower = GpioController.GetDefault().OpenPin(5); _rfPower.SetDriveMode(GpioPinDriveMode.Output); _rfPower.Write(GpioPinValue.High); _userLed = GpioController.GetDefault().OpenPin(45); _userLed.SetDriveMode(GpioPinDriveMode.Output); var port = UartController.FromName(SC20100.UartPort.Uart8); port.SetActiveSettings(115200, 8, UartParity.None, UartStopBitCount.One, UartHandshake.None); var wifi = new Esp8266WifiDevice(port, _rfPower, null); // Enable echoing of commands wifi.EnableDebugOutput = false; Debug.WriteLine("--------------------------------"); Debug.WriteLine("----Esp 8266 Wifi TinyClr 2 ----"); Debug.WriteLine("--------------------------------"); wifi.Connect("valoninet", "valoni1234567"); Debug.WriteLine("Station IP address : " + wifi.StationIPAddress.ToString()); Debug.WriteLine("Station MAC address : " + wifi.StationMacAddress); Debug.WriteLine("Station Gateway address : " + wifi.StationGateway.ToString()); Debug.WriteLine("Station netmask : " + wifi.StationNetmask.ToString()); Debug.WriteLine("------------------------"); Thread.Sleep(1000); var sntp = new SntpClient(wifi, "time1.google.com"); sntp.SetTime(); int iCounter = 0; bool state = true; while (true) { state = !state; if (state) { _userLed.Write(GpioPinValue.High); } else { _userLed.Write(GpioPinValue.Low); } ++iCounter; if (iCounter % 10 == 0) { Debug.WriteLine("Current UTC time : " + DateTime.UtcNow); Debug.WriteLine("------------------------"); } // Every 15 seconds Thread.Sleep(500); } }
private const string payload = "48656c6c6f204c6f526157414e"; // Hello LoRaWAN public static void Main() { UartController serialDevice; int txByteCount; int rxByteCount; Debug.WriteLine("devMobile.IoT.Rak811.NetworkJoinOTAA starting"); try { serialDevice = UartController.FromName(SerialPortId); serialDevice.SetActiveSettings(new UartSetting() { BaudRate = 9600, Parity = UartParity.None, StopBits = UartStopBitCount.One, Handshaking = UartHandshake.None, DataBits = 8 }); serialDevice.Enable(); // clear out the RX buffer rxByteCount = serialDevice.BytesToRead; while (rxByteCount > 0) { byte[] rxBuffer0 = new byte[rxByteCount]; serialDevice.Read(rxBuffer0); if (rxByteCount > 0) { serialDevice.Read(rxBuffer0); Debug.WriteLine($"RX0 :{rxByteCount} bytes read"); String response = UTF8Encoding.UTF8.GetString(rxBuffer0); Debug.WriteLine($"RX0 :{response}"); } } // Set the Working mode to LoRaWAN txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("at+set_config=lora:work_mode:0\r\n")); Debug.WriteLine($"TX: work mode {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the Region to AS923 txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("at+set_config=lora:region:AS923\r\n")); Debug.WriteLine($"TX: region {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the JoinMode txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("at+set_config=lora:join_mode:0\r\n")); Debug.WriteLine($"TX: join_mode {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the appEUI txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"at+set_config=lora:app_eui:{AppEui}\r\n")); Debug.WriteLine($"TX: app_eui {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the appKey txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"at+set_config=lora:app_key:{AppKey}\r\n")); Debug.WriteLine($"TX: app_key {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Set the Confirm flag txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("at+set_config=lora:confirm:0\r\n")); Debug.WriteLine($"TX: confirm {txByteCount} bytes"); Thread.Sleep(500); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } // Join the network txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes("at+join\r\n")); Debug.WriteLine($"TX: join {txByteCount} bytes"); Thread.Sleep(10000); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } while (true) { txByteCount = serialDevice.Write(UTF8Encoding.UTF8.GetBytes($"at+send=lora:{messagePort}:{payload}\r\n")); Debug.WriteLine($"TX: send {txByteCount} bytes"); Thread.Sleep(5000); // Read the response rxByteCount = serialDevice.BytesToRead; if (rxByteCount > 0) { byte[] rxBuffer = new byte[rxByteCount]; serialDevice.Read(rxBuffer); Debug.WriteLine($"RX :{UTF8Encoding.UTF8.GetString(rxBuffer)}"); } Thread.Sleep(20000); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
/// <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); }