public void DoReplyGetSystemState()
{
byte[] majorVersion = StringToByteArray(Version.Substring(0, 2));
byte[] minorVersion = StringToByteArray(Version.Substring(3, 2));
byte[] reply = MsgGetSystemState.GetReply((byte)MidiChannel, (byte)(BoxId + 1), new byte[2] {
majorVersion[0], minorVersion[0]
});
stream.Write(reply, 0, reply.Length);
MessageSent = string.Format("Sent: {0}", ByteArrayToString(reply));
const int MixerChannel = 1;
const int FaderValue0Db = 0x6B;
var channelStrip = new ChannelStrip(MidiChannel, MixerChannel, FaderValue0Db);
var msg = channelStrip.GetFader()[0].Message;
stream.Write(msg, 0, msg.Length);
MessageSent = string.Format("Sent: {0}", ByteArrayToString(msg));
foreach (MsgNrpn msgNrpn in channelStrip.GetFader())
{
stream.Write(msgNrpn.Message, 0, msgNrpn.Message.Length);
MessageSent = string.Format("Sent: {0}", ByteArrayToString(msgNrpn.Message));
}
}
public void ReplyGetSystemState()
{
const byte MidiChannel = 0x99;
const byte BoxId = 0x04;
string version = "01.99";
byte[] majorVersion = VmQuServer.StringToByteArray(version.Substring(0, 2));
byte[] minorVersion = VmQuServer.StringToByteArray(version.Substring(3, 2));
byte[] byVersion = new byte[2];
Buffer.SetByte(byVersion, 0, majorVersion[0]);
Buffer.SetByte(byVersion, 1, minorVersion[0]);
var reply = MsgGetSystemState.GetReply(MidiChannel, BoxId, byVersion);
Console.WriteLine(VmQuServer.ByteArrayToString(reply));
Assert.AreEqual(reply.Length, 13);
Assert.AreEqual(reply, new byte[] { 0xF0, 0x00, 0x00, 0x1A, 0x50, 0x11, 0x01, 0x00, 0x99, 0x04, majorVersion[0], minorVersion[0], 0xF7 });
}
/// <summary>
///
/// </summary>
public void DoConnect()
{
try
{
byte[] bytes = new byte[256];
string data = null;
IPAddress localAddr = IPAddress.Parse(LocalHost);
server = new TcpListener(localAddr, QuPort);
server.Start();
while (true)
{
Status = "Waiting for a connection... ";
TcpClient client = server.AcceptTcpClient();
Status = "Connected!";
data = null;
stream = client.GetStream();
int i;
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
var command = Commands["DoActiveSensed"];
if (ActiveSense.Check4Message(bytes, i) && command.CanExecute(null))
{
MessageReceived = "Received: DoActiveSensed";
command.Execute(null);
break;
}
command = Commands["DoReplyGetSystemState"];
if (MsgGetSystemState.Check4Request(bytes, i) && command.CanExecute(null))
{
MessageReceived = "Received: GetSystemState";
command.Execute(null);
break;
}
else
{
data = Encoding.ASCII.GetString(bytes, 0, i);
MessageReceived = string.Format("Received: {0}", data);
data = data.ToUpper();
byte[] msg = Encoding.ASCII.GetBytes(data);
stream.Write(msg, 0, msg.Length);
MessageSent = string.Format("Sent: {0}", data);
}
}
client.Close();
}
}
catch (SocketException e)
{
Status = string.Format("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
server.Stop();
}
}
public void DoSendRequest(object oData)
{
try
{
byte[] data = (byte[])oData;
// Create a TcpClient.
// Note, for this client to work you need to have a TcpServer
// connected to the same address as specified by the server, port
// combination.
TcpClient client = new TcpClient(LocalHost, QuPort);
// Get a client stream for reading and writing.
NetworkStream stream = client.GetStream();
// Send the message to the connected TcpServer.
stream.Write(data, 0, data.Length);
string message = Encoding.ASCII.GetString(data, 0, data.Length);
Message = string.Format("Sent: {0}", message);
WindowUtils.DoEvents();
Thread.Sleep(5000);
// Receive the TcpServer.response.
// Buffer to store the response bytes.
data = new byte[256];
// Read the first batch of the TcpServer response bytes.
int bytes = stream.Read(data, 0, data.Length);
if (MsgGetSystemState.Check4Reply(data, bytes))
{
byte[] dataGetSystemState = new byte[13];
Buffer.BlockCopy(data, 0, dataGetSystemState, 0, 13);
MidiChannel = BitConverter.ToString(dataGetSystemState, 8, 1);
BoxId = dataGetSystemState[9];
OSVersion = string.Format("{0}.{1}", BitConverter.ToString(dataGetSystemState, 10, 1), BitConverter.ToString(dataGetSystemState, 11, 1));
Message = string.Format("Received: {0}", ByteArrayToString(dataGetSystemState));
for (int i = 0; i < 4; i++)
{
byte[] dataMsgNrpn = new byte[4];
Buffer.BlockCopy(data, 13 + i * 4, dataMsgNrpn, 0, 4);
Message = string.Format("Received: {0}", ByteArrayToString(dataMsgNrpn));
}
}
else
{
string responseData = Encoding.ASCII.GetString(data, 0, bytes);
Message = string.Format("Received: {0}", responseData);
}
// Close everything.
stream.Close();
client.Close();
}
catch (ArgumentNullException e)
{
Message = string.Format("ArgumentNullException: {0}", e);
}
catch (SocketException e)
{
Message = string.Format("SocketException: {0}", e);
}
}
public void MessageGetSystemState_Check4Message()
{
Assert.IsFalse(MsgGetSystemState.Check4Request(new byte[] { 0xF0, 0x00, 0x00, 0x1A, 0x50, 0x11, 0x01, 0x00, 0x7F, 0x10, 0x01 }, 11));
Assert.IsFalse(MsgGetSystemState.Check4Request(new byte[] { 0xF0, 0x00, 0x00, 0x1A, 0x50, 0x11, 0x01, 0x00, 0x7F, 0x10, 0x00, 0xF7 }, 12));
Assert.IsTrue(MsgGetSystemState.Check4Request(new byte[] { 0xF0, 0x00, 0x00, 0x1A, 0x50, 0x11, 0x01, 0x00, 0x7F, 0x10, 0x01, 0xF7 }, 12));
}
