static void Main(string[] args)
{
SerialPort ser = new SerialPort( "COM1", (int)BaudRate.Baudrate115200 );
byte[] buf = new byte[26];
byte[] ret = new byte[26];
ser.Handshake = Handshake.XOnXOff;
ser.DataReceived += new SerialDataReceivedEventHandler(ser_DataReceived);
ser.Open();
Debug.Print("Initializing Serial Test");
for (int i = 0;i < buf.Length;i++)
{
buf[i] = (byte)('a' + i);
}
ser.Write(buf, 0, buf.Length);
ser.Flush();
Thread.Sleep(1000);
ser.DataReceived -= new SerialDataReceivedEventHandler(ser_DataReceived);
ser.Write(buf, 0, buf.Length);
Thread.Sleep(1000);
ser.DataReceived += new SerialDataReceivedEventHandler(ser_DataReceived);
ser.ErrorReceived += new SerialErrorReceivedEventHandler(ser_ErrorReceived);
ser.Write(buf, 0, buf.Length);
Thread.Sleep(3000);
ser.Read(ret, 0, ret.Length);
Thread.Sleep(10000);
}
public static void Main()
{
int count = 0;
SerialPort SPort = new SerialPort(SerialPorts.COM2, 9600, Parity.None,8,StopBits.One);
SPort.ReadTimeout = 1000;
SPort.WriteTimeout = 1000;
byte[] buf = new byte[5];
string CardId = "";
SPort.Open();
byte[] readCommand = { 0x21, 0x52, 0x57, 0x01, 0x03 };
int numCodes = 0;
while (true)
{
//SPort.Write(new byte[] { 0xFF, 0xFF, 0X39, 0x44 }, 0, 4);
SPort.Write(readCommand, 0, 5);
SPort.Flush();
int readcnt = SPort.Read(buf, 0, SPort.BytesToRead);
SPort.Flush();
string s = "";
if (buf[0] == 0x01 && numCodes < 10)
{
foreach (byte b in buf)
{
s = s + b.ToString() + ",";
}
if (s[0] == '1')
{
count++;
Debug.Print(count.ToString() + ":" + s + "\n");
numCodes++;
}
}
}
}
public CSerializer(string com)
{
m_serial = new SerialPort(com, 19200, Parity.None, 8, StopBits.One);
m_serial.Open();
m_serial.Flush();
m_serial.DiscardInBuffer();
}
public SerialPortHelper(string portName = "COM1", int baudRate = 250000, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
{
serialPort = new SerialPort(portName, baudRate, parity, dataBits, stopBits);
//serialPort.ReadTimeout = 1; // Set to 10ms. Default is -1?!
serialPort.DataReceived += new SerialDataReceivedEventHandler(SerialPortDataReceived);
serialPort.Flush();
serialPort.Open();
}
private int _rx_buffer_pointer; // points to next available element in the rx buffer
//-------------------------------------------------------------------------------------------------------------------------------------------
public Amulet( string port, int baudrate, AmuletSlaveResponseType response_type, IAmuletClient client=null)
{
_client = client;
_response_type = response_type;
_response_event = new AutoResetEvent( false);
Debug.Print( "creating serial port");
_port = new SerialPort( port, baudrate, Parity.None, 8, StopBits.One);
Debug.Print( "setting serial port read timeout");
_port.ReadTimeout = 1000;
Debug.Print( "opening serial port");
_port.Open();
Debug.Print( "flushing serial port buffer");
_port.Flush();
Debug.Print( "registering serial port data event handler");
_port.DataReceived += new SerialDataReceivedEventHandler(serialPort_DataReceived);
Debug.Print( "RAM left: " + Debug.GC( true) + " bytes");
}
public static void Main()
{
Radio = new SerialPort("COM1", 9600);
Radio.Open();
// Radio.DataReceived += new SerialDataReceivedEventHandler(UART_DataReceived);
uint i = 0;
while (true)
{
if (leftPwr != 0)
leftMotor.SetPulse(100000, (uint)(((double)leftPwr / 100) * 90000.0));
else
leftMotor.SetPulse(100000, 0);
if (rightPwr != 0)
rightMotor.SetPulse(100000, (uint)(((double)rightPwr / 100) * 90000.0));
else
rightMotor.SetPulse(100000, 0);
//leftMotor.SetPulse(100000, 90000);
Thread.Sleep(1);
string input = "";
// read the data
try
{
read_count = Radio.Read(rx_data, 0, Radio.BytesToRead);
if (read_count > 0)
{
for (int k = 0; k < read_count; k++ )
{
if (rx_data[k] == '$')
i = 0;
else if (rx_data[k] == '*')
{
Radio.Flush();
for(int j = 0; j < i; j++)
{
input += (char)str[j];
}
ParseCommand(input);
i = 0;
read_count = 0;
}
else
{
str[i] = rx_data[k];
i++;
if (i > str.Length) i = 0;
}
}
}
}
catch
{
}
}
}
public override void Flush()
{
_port.Flush();
}
public MFTestResults DataRcdEvent()
{
if (!IsLoopback)
return MFTestResults.Skip;
// BUGBUG: 21216
result = MFTestResults.Fail;
try
{
eventCount = 0;
eventSerialPort = new SerialPort(Serial.COM1);
// register before open
eventSerialPort.DataReceived += new SerialDataReceivedEventHandler(eventserialPort_DataReceived_BeforeOpen);
eventSerialPort.Open();
eventSerialPort.DataReceived += new SerialDataReceivedEventHandler(eventSerialPort_DataReceived_AfterOpen);
eventSerialPort.DataReceived += new SerialDataReceivedEventHandler(eventSerialPort_DataReceived_AfterOpen2);
eventSerialPort.Write(sendbuff, 0, sendbuff.Length);
eventSerialPort.Flush();
for (int i = 0; i < 100; i++)
{
Thread.Sleep(100);
if (eventCount >= 3)
{
result = MFTestResults.Pass;
break;
}
}
Log.Comment(eventCount + " events fired");
eventSerialPort.Close();
}
catch (Exception ex)
{
Log.Exception(ex.Message);
}
finally
{
eventSerialPort.Dispose();
}
return result;
}
/// <summary>
/// Takes reading from Atlas Scientific ElectricalConductivity Stamp
/// </summary>
/// <returns></returns>
private float GetPPM()
{
float PPM = 0.0F;
SerialPort sp = new SerialPort(Serial.COM2, 38400, Parity.None, 8, StopBits.One);
sp.ReadTimeout = 1000;
try
{
string command = "";
string response = "";
char inChar;
// Send the temperature reading if available
if (m_Temperature > 0)
command = m_Temperature.ToString("F") + "\rR\r";
else
command = "R\r";
Debug.Print(command);
byte[] message = Encoding.UTF8.GetBytes(command);
sp.Open();
sp.Write(message, 0, message.Length);
sp.Flush();
Debug.Print("sending message");
// Now collect response
while ((inChar = (char)sp.ReadByte()) != '\r') { response += inChar; }
response = response.Split(',')[1];
// Stamp can return text if reading was not successful, so test before returning
double ppmReading;
if (Double.TryParse(response, out ppmReading)) PPM = (float)ppmReading;
}
catch (Exception e)
{
Debug.Print(e.StackTrace);
}
finally
{
sp.Close();
sp.Dispose();
}
return PPM;
}
public static void Start(Handshake handshake)
{
int nWritten;
// Note: zeros must be sent first to help the receiver sync after the noise generated
// by the port initialization - don't send the important stuff right away...!
byte[] start = { 0 };
if (handshake == Handshake.None)
{
Debug.Print("***** Testing No Flow Control *****");
start = new byte[] { 0, 0, 0, 0, 0, (byte)'X', (byte)'2', (byte)'3', (byte)'\r', (byte)'\n', 0 };
}
else if (handshake == Handshake.XOnXOff)
{
Debug.Print("***** Testing SW Flow Control *****");
start = new byte[] { 0, 0, 0, 0, 0, (byte)'X', (byte)'2', (byte)'4', (byte)'\r', (byte)'\n', 0 };
}
else if (handshake == Handshake.RequestToSend)
{
Debug.Print("***** Testing HW Flow Control *****");
start = new byte[] { 0, 0, 0, 0, 0, (byte)'X', (byte)'2', (byte)'5', (byte)'\r', (byte)'\n', 0 };
}
SerialPortTest app = new SerialPortTest();
byte[] Record = new byte[c_BufferSize];
UInt32 uiRecordNumber = 0x1323; // Starting record number (pulled from a hat)
SerialPort hPort = new SerialPort("COM1", (int)BaudRate.Baudrate115200);
hPort.Handshake = handshake;
hPort.ReadTimeout = 500;
hPort.Open();
hPort.Flush();
while (0 < hPort.Read(Record, 0, Record.Length)) ;
// Note:
// When a hardware reset is issued to some targets prior to a deploy, the original deployed
// code begins to execute for a second or two before Visual Studio is able to gain control,
// halt the old deployed code and deploy the current program.
// The following two second delay is to prevent this app from issuing the start record prior
// to VS gaining control. Otherwise, the PC side app will get the signal to start before
// the target side app has even deployed. This will result in the loss of the first three
// or four data records and the test will fail.
Thread.Sleep(2000);
// Send out a simple signal to show the PC side test software that we're ready to go
hPort.Write(start, 0, start.Length);
// Test COM port handshake by flooding the port with testable sequential records
// and verifying that the records arrive correctly. The handshake is verified
// by causing 5 second pauses during reading which should translate to five
// second pauses in the transmit as well - unless the driver buffer is obviating
// the need for handshake - in which case, the buffer should be diminished or the
// volume of traffic should increase until handshake must be employed.
for (int i = 0; i < c_NumRecords; i++)
{
if (!app.ReceiveRecord(hPort, Record)) // If there were problems
{
Debug.Print("There were problems with test #1, record #" + toString(i + 1) + " of " + toString(c_NumRecords));
// return; // We may as well quit now
}
//Debug.Print(AsString(Record));
//Debug.Print(new string(System.Text.UTF8Encoding.UTF8.GetChars(Record)));
if (!app.CheckRecord(uiRecordNumber, Record)) // If there were problems
{
Debug.Print("There were problems with test #1, record #" + toString(i + 1) + " of " + toString(c_NumRecords));
//return; // We may as well quit now
}
uiRecordNumber++; // Next record
}
for (int i = 0; i < c_NumRecords; i++)
{
app.CreateRecord(uiRecordNumber, Record);
//Debug.Print("\nSending Record: " + uiRecordNumber);
//Debug.Print(new string(System.Text.UTF8Encoding.UTF8.GetChars(Record)));
if(!app.SendRecord(hPort, Record)) // If there were problems
{
Debug.Print("There were problems with test #2, record #" + toString(i + 1) + " of " + toString(c_NumRecords));
return; // We may as well quit now
}
uiRecordNumber++;
}
// This is just like the previous test - except that a gap of five seconds
// will be inserted before receiving the rest of the records which will
// hopefully hold off transmission due to a functioning handshake.
for (int i = 0; i < 5; i++)
{
if (!app.ReceiveRecord(hPort, Record)) // If there were problems
{
Debug.Print("There were problems with test #3, record #" + toString(i + 1) + " of 5");
return; // We may as well quit now
}
if (!app.CheckRecord(uiRecordNumber, Record)) // If there were problems
{
return; // We may as well quit now
}
uiRecordNumber++; // Next record
}
Thread.Sleep(5000); // Do not allow reception of characters for five seconds (simulate erasing FLASH or some such)
for (int i = 0; i < (c_NumRecords - 5); i++)
{
if (!app.ReceiveRecord(hPort, Record)) // If there were problems
{
Debug.Print("There were problems with test #4, record #" + toString(i + 1) + " of " + toString(c_NumRecords - 5));
return; // We may as well quit now
}
if (!app.CheckRecord(uiRecordNumber, Record)) // If there were problems
{
byte[] CRecord = new byte[c_BufferSize];
app.CreateRecord(uiRecordNumber, CRecord);
Debug.Print("got: " + AsString(Record));
Debug.Print("exp: " + AsString(CRecord));
Debug.Print("There were problems with test #4, record #" + toString(i + 1) + " of " + toString(c_NumRecords - 5));
return; // We may as well quit now
}
uiRecordNumber++; // Next record
}
// During this test, the receiving unit will hopefully hold off which will
// cause this transmission to also (hopefully) report the same holdoff
for (int i = 0; i < c_NumRecords; i++)
{
app.CreateRecord(uiRecordNumber, Record);
if (!app.SendRecord(hPort, Record)) // If there were problems
{
Debug.Print("There were problems with test #5, record #" + toString(i + 1) + " of " + toString(c_NumRecords));
return; // We may as well quit now
}
uiRecordNumber++;
}
Debug.Print("All records apparently sent and received as expected");
hPort.Dispose();
GC.WaitForPendingFinalizers();
}
/// <summary>
/// Empties the contents of a serial port's buffer.
/// </summary>
public override void Flush()
{
#if NETMF
_port.Flush();
#endif
}
// ----- INITIALISATION ACTIONNEURS -----
public void initialiser(couleur couleur, int position)
{
m_jambes = new CLocomotion();
m_direction = new OutputPort((Cpu.Pin)09, false);
m_portSerie = new SerialPort("COM1", 1000000, Parity.None, 8, StopBits.One);
m_portSerie.ReadTimeout = 250;
m_portSerie.Open();
if (m_portSerie.IsOpen)
{
m_portSerie.Flush();
m_ax12_pince = new CAX_12(2, m_portSerie, m_direction);
m_ax12_bras = new CAX_12(5, m_portSerie, m_direction);
m_pince = new CPince(m_ax12_pince);
m_bras = new CBras(m_ax12_bras);
}
m_controleur = new CSerializer("COM3");
m_moteurAscenceur = new CMoteur(m_controleur, 1);
m_moteurPompe = new CMoteur(m_controleur, 2);
m_potar = new CPotar(m_controleur, 1);
m_ascenseur = new CAscenseur(m_moteurAscenceur, m_potar);
m_pompe = new CPompe(m_moteurPompe);
initialiserAscenseur();
initialiserLocomotion(couleur, position);
saisirVerres = false;
threadSaisirVerre.Start();
}
/// <summary>
/// Relays data between a serial port and the telnet session.
/// This allows access from telnet to the serial
/// port of the EC and PH moduled directly.
/// </summary>
/// <param name="SerialPortName">String for the serial port you want to access.</param>
private void Calibrate(String SerialPortName)
{
SerialPort sp = new SerialPort(SerialPortName, 38400, Parity.None, 8, StopBits.One);
try
{
byte ExitCommand = 94; //^ Key
bool Continue = true;
int m_LoopCount = 0;
sp.ReadTimeout = 4000;
sp.WriteTimeout = 4000;
sp.Open();
do
{
m_LoopCount += 1; //Incriment loop count for inactivity.
if (activeConnection.Available > 0)
{
byte[] t_buffer = new byte[activeConnection.Available];
activeConnection.Receive(t_buffer);
if (t_buffer[0] == ExitCommand) //exit if ^ is pressed
{
Continue = false;
break;
}
else
{
if (t_buffer[t_buffer.Length - 2] == 13 && t_buffer[t_buffer.Length - 1] == 10) //When sending data to the stamp replace crlf with return.
{
m_LoopCount = 0; //Reset Loop Count
sp.Write(t_buffer, 0, t_buffer.Length - 1); //Send message to the serial port
}
else
{
m_LoopCount = 0; //Reset Loop Count
sp.Write(t_buffer, 0, t_buffer.Length); //Send message to the serial port
}
sp.Flush();
}
t_buffer = null;
}
if (sp.BytesToRead > 0)
{
byte[] ph_cmd = new byte[sp.BytesToRead];
sp.Read(ph_cmd, 0, ph_cmd.Length); //Read from serial port
activeConnection.Send(ph_cmd, SocketFlags.None); //Write what was read to telnet session
m_LoopCount = 0; //Reset Loop Count
ph_cmd = null;
}
Thread.Sleep(100);
} while (Continue && m_LoopCount < 60000); //Time out after 1 minute of inactivity.
}
catch (Exception e)
{
_sendReply("Error accessing serial port: \r\n" + e.Message + "\r\nIt may be in use. Try again later.\r\n");
}
finally
{
//close the serial port if its opened and Dispose it.
if (sp.IsOpen)
sp.Close();
sp.Dispose();
}
}
