private void connectContactsRealDo()
{
ChronopicRegisterPort crp = crpConnectContactsRealThread;
string message = "";
bool success = false;
bool connected = false;
if (cpDoing == 1)
{
LogB.Information("connectContactsRealDo() 1");
sp = new SerialPort(crp.Port);
chronopicInit = new ChronopicInit();
connected = chronopicInit.Do(1, out cp, out sp,
platformState, crp.Port, out message, out success);
}
else //(cpDoing == 2)
{
LogB.Information("connectContactsRealDo() 2");
sp2 = new SerialPort(crp.Port);
chronopicInit = new ChronopicInit();
connected = chronopicInit.Do(2, out cp2, out sp2,
platformState, crp.Port, out message, out success);
}
LogB.Information("Ended chronopicInit.Do()");
if (connected)
{
assignLastConnectedVariables(crp);
}
SuccededConnectContactsRealThread = connected;
}
private void chronojumpWindowTestsChronopicContactReal()
{
LogB.TestStart("chronojumpWindowTestsChronopicContactReal");
chronopicRegisterUpdate(false);
if (chronopicRegister.NumConnectedOfType(ChronopicRegisterPort.Types.CONTACTS) != 1)
{
testsActive = false;
new DialogMessage(Constants.MessageTypes.WARNING, "Warning, need ONE contacts chronopic connected");
return;
}
ChronopicRegisterPort crp = chronopicRegister.ConnectedOfType(ChronopicRegisterPort.Types.CONTACTS);
if (cp2016.IsLastConnectedReal(crp, 1))
{
LogB.TestEnd("chronojumpWindowTestsChronopicContactReal");
chronojumpWindowTestsNext();
}
else
{
cp2016.FakeButtonContactsRealDone.Clicked +=
new EventHandler(on_connection_contacts_real_done);
cp2016.ConnectContactsReal(app1, crp, 1,
"Press TEST button on Chronopic to stablish initial communication"); //TODO: translate this
}
LogB.TestEnd("chronojumpWindowTestsChronopicContactReal");
}
private void createGui(Gtk.Window app1, ChronopicRegisterPort crp, string labelStr)
{
chronopic_contacts_real_win = new Window("Chronopic connection");
chronopic_contacts_real_win.AllowGrow = false;
chronopic_contacts_real_win.Modal = true;
chronopic_contacts_real_win.TransientFor = app1;
chronopic_contacts_real_win.BorderWidth = 20;
chronopic_contacts_real_win.DeleteEvent += on_delete_event;
Gtk.VBox vbox_main = new Gtk.VBox(false, 20);
chronopic_contacts_real_win.Add(vbox_main);
LogB.Information("Connecting real (starting connection)");
LogB.Information("Press test button on Chronopic");
Gtk.Label labelMessage = new Gtk.Label();
labelMessage.Text = labelStr + "\n" +
"\n" + Catalog.GetString("Port") + ": " + crp.Port +
"\n" + Catalog.GetString("Serial Number") + ": " + crp.SerialNumber;
vbox_main.Add(labelMessage);
progressbar = new Gtk.ProgressBar();
vbox_main.Add(progressbar);
Gtk.Button button_cancel = new Gtk.Button("Cancel");
button_cancel.Clicked += new EventHandler(on_button_cancel_clicked);
Gtk.HButtonBox hbox = new Gtk.HButtonBox();
hbox.Add(button_cancel);
vbox_main.Add(hbox);
chronopic_contacts_real_win.ShowAll();
}
private void createListDo(uint ftdiDeviceCount)
{
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = ftdiDeviceWin.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (uint i = 0; i < ftdiDeviceCount; i++)
{
LogB.Information(String.Format("Device Index: " + i.ToString()));
LogB.Information(String.Format("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags)));
LogB.Information(String.Format("Type: " + ftdiDeviceList[i].Type.ToString()));
LogB.Information(String.Format("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID)));
LogB.Information(String.Format("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId)));
LogB.Information(String.Format("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString()));
LogB.Information(String.Format("Description: " + ftdiDeviceList[i].Description.ToString()));
string port = getComPort(ftdiDeviceList[i]);
ChronopicRegisterPort crp = new ChronopicRegisterPort(port);
crp.FTDI = true;
crp.SerialNumber = ftdiDeviceList[i].SerialNumber.ToString();
crp.Type = ChronopicRegisterPort.Types.UNKNOWN;
LogB.Information(string.Format("crp: " + crp.ToString()));
registerAddOrUpdate(crp);
}
}
}
private void on_button_right_clicked(object o, EventArgs args)
{
Button buttonClicked = o as Button;
if (o == null)
{
return;
}
int count = 0;
foreach (Gtk.Button button in list_buttons_right)
{
if (button == buttonClicked)
{
TypePix tp = TypePixList.GetPixPrevNext(listConnected[count].Type, "RIGHT");
listConnected[count].Type = tp.Type;
list_images[count].Pixbuf = tp.Pix;
list_labels_type[count].Text = ChronopicRegisterPort.TypePrint(listConnected[count].Type);
buttons_sensitivity(list_buttons_left[count], button, tp.Type);
updateSQL(listConnected[count].SerialNumber, tp.Type);
}
count++;
}
}
private void chronopicConnectionSequenceInit(int numCPs)
{
connectNum = 1;
if (numCPs == 1)
{
connectAnother = false;
crpDoing = chronopicRegister.ConnectedOfType(ChronopicRegisterPort.Types.CONTACTS);
//store a boolean in order to read info faster
cp2016.StoredCanCaptureContacts = true;
}
else
{ //2
connectAnother = true;
//will get two crps or null
crpMultiList = chronopicRegister.GetTwoContactsConnected();
//store a boolean in order to read info faster
if (crpMultiList == null)
{
return;
}
crpDoing = crpMultiList[0];
cp2016.StoredCanCaptureContacts = (crpMultiList.Count == 2);
}
connectingSequence = connectingSequenceEnum.START;
chronopicConnectionSequenceDo();
}
public static List <ChronopicRegisterPort> SelectAll(bool dbconOpened)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "SELECT * FROM " + table;
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
SqliteDataReader reader = dbcmd.ExecuteReader();
List <ChronopicRegisterPort> l = new List <ChronopicRegisterPort>();
while (reader.Read())
{
ChronopicRegisterPort crp = new ChronopicRegisterPort(
reader[0].ToString(), //serialNumber
(ChronopicRegisterPort.Types)Enum.Parse(
typeof(ChronopicRegisterPort.Types), reader[1].ToString()) //type
);
l.Add(crp);
}
reader.Close();
closeIfNeeded(dbconOpened);
return(l);
}
private void callConnectContactsReal(ChronopicRegisterPort crp, int numCP)
{
cp2016.FakeButtonContactsRealDone.Clicked +=
new EventHandler(on_connection_contacts_real_done);
cp2016.ConnectContactsReal(app1, crp, numCP,
Catalog.GetString("Please touch the platform or click Chronopic TEST button"));
}
public void Add(ChronopicRegisterPort crp)
{
//Add to SQL
SqliteChronopicRegister.Insert(false, crp);
//Add to list
L.Add(crp);
}
public void Delete(ChronopicRegisterPort crp)
{
//Delete from SQL
SqliteChronopicRegister.Delete(false, crp);
//Delete from list
L.Remove(crp);
}
public static void Delete(bool dbconOpened, ChronopicRegisterPort crp)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "Delete FROM " + table +
" WHERE serialNumber = " + crp.SerialNumber;
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
closeIfNeeded(dbconOpened);
}
public static void Delete(bool dbconOpened, ChronopicRegisterPort crp)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "Delete FROM " + table +
" WHERE serialNumber = " + crp.SerialNumber;
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
closeIfNeeded(dbconOpened);
}
public void UpdatePort(ChronopicRegisterPort crp, string newPort)
{
foreach (ChronopicRegisterPort c in L)
{
if (c.SerialNumber == crp.SerialNumber)
{
c.Port = newPort;
break;
}
}
}
public static void Insert(bool dbconOpened, ChronopicRegisterPort crp)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "INSERT INTO " + table +
" (serialNumber, type) VALUES (\"" +
crp.SerialNumber + "\", \"" + crp.Type.ToString() + "\")" ;
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
closeIfNeeded(dbconOpened);
}
public bool Exists(ChronopicRegisterPort crp)
{
foreach (ChronopicRegisterPort c in L)
{
if (c.SerialNumber == crp.SerialNumber)
{
return(true);
}
}
return(false);
}
public static void Update(bool dbconOpened, ChronopicRegisterPort crp, ChronopicRegisterPort.Types newType)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "UPDATE " + table +
" SET type = \"" + newType.ToString() +
"\" WHERE serialNumber = \"" + crp.SerialNumber + "\"";
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
closeIfNeeded(dbconOpened);
}
public static void Insert(bool dbconOpened, ChronopicRegisterPort crp)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "INSERT INTO " + table +
" (serialNumber, type) VALUES (\"" +
crp.SerialNumber + "\", \"" + crp.Type.ToString() + "\")";
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
closeIfNeeded(dbconOpened);
}
//returns first found (should be only one if called NumConnectedOfType and returned value was 1
public ChronopicRegisterPort ConnectedOfType(ChronopicRegisterPort.Types type)
{
foreach (ChronopicRegisterPort crp in crpl.L)
{
if (crp.Type == type && crp.Port != "")
{
return crp;
}
}
return null;
}
protected override ChronopicRegisterPort readFTDI(ChronopicRegisterPort crp)
{
/*
* old:
* /bin/udevadm info —name=/dev/ttyUSB0 |grep ID_SERIAL_SHORT|cut -d= -f2
* error on some systems:
* Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.
*/
//new: udevadm info -p $(udevadm info -q path -n /dev/ttyUSB0)
//TODO: find a way to call this in only one process
//1) get path
List <string> parameters = new List <string> {
"info", "-q", "path", "-n", crp.Port
};
ExecuteProcess.Result result = ExecuteProcess.runShowErrorIfNotStarted("udevadm", parameters);
string path = result.stdout;
if (result.stderr != "")
{
return(crp);
}
//2) read FTDI info
parameters = new List <string> {
"info", "-p", path
};
result = ExecuteProcess.runShowErrorIfNotStarted("udevadm", parameters);
if (result.stderr != "")
{
return(crp);
}
foreach (string lineOut in result.stdout.Split('\n'))
{
if (lineOut.Contains("ID_VENDOR="))
{
string [] strFull = lineOut.Split(new char[] { '=' });
crp.FTDI = (strFull[1] == "FTDI");
}
else if (lineOut.Contains("ID_SERIAL_SHORT="))
{
string [] strFull = lineOut.Split(new char[] { '=' });
crp.SerialNumber = strFull[1];
}
}
return(crp);
}
protected override ChronopicRegisterPort readFTDI(ChronopicRegisterPort crp)
{
//TODO: 1) check if it's FTDI
crp.FTDI = true;
//2) read SerialNumber
//eg crp.Port = "/dev/tty.usbserialA123456F";
string chunk = "usbserial";
int pos = crp.Port.LastIndexOf(chunk) + chunk.Length;
crp.SerialNumber = crp.Port.Substring(pos); //eg. A123456F
return(crp);
}
private void chronopicConnectionSequenceDo()
{
//0 print sequence
LogB.Information("SEQUENCE: " + connectingSequence.ToString());
//1 check if need to end sequence or go to second chronopic
if (connectingSequence == connectingSequenceEnum.END)
{
if (connectAnother)
{
System.Threading.Thread.Sleep(250);
crpDoing = crpMultiList[1];
connectingSequence = connectingSequenceEnum.START;
connectAnother = false;
connectNum = 2;
chronopicConnectionSequenceDo();
return;
}
else
{
button_activate_chronopics.Show();
on_button_execute_test_acceptedPre();
return;
}
}
//2 update sequence
if (connectingSequence == connectingSequenceEnum.START)
{
if (cp2016.IsLastConnectedReal(crpDoing, connectNum))
{
connectingSequence = connectingSequenceEnum.FIRMWAREIFNEEDED;
}
else
{
connectingSequence = connectingSequenceEnum.CONNECTINGREAL;
}
chronopicConnectionSequenceDo();
}
else if (connectingSequence == connectingSequenceEnum.CONNECTINGREAL)
{
callConnectContactsReal(crpDoing, connectNum);
//this opens a thread and when end goes to chronopicConnectionSequenceDo again
}
else if (connectingSequence == connectingSequenceEnum.FIRMWAREIFNEEDED)
{
changeMultitestFirmwareIfNeeded(connectNum);
//this will call chronopicConnectionSequenceDo if success
}
}
private void assignLastConnectedVariables(ChronopicRegisterPort crp)
{
if (cpDoing == 1)
{
lastConnectedRealPort = crp.Port;
lastConnectedRealSerialNumber = crp.SerialNumber;
lastConnectedRealType = ChronopicRegisterPort.Types.CONTACTS;
}
else //2
{
lastConnectedRealPort2 = crp.Port;
lastConnectedRealSerialNumber2 = crp.SerialNumber;
lastConnectedRealType2 = ChronopicRegisterPort.Types.CONTACTS;
}
}
public void ConnectContactsReal(Gtk.Window app1, ChronopicRegisterPort crp,
int cpCount, string labelStr) //cpCount 2 is for 2nd chronopic on multichronopic
{
createGui(app1, crp, labelStr);
crpConnectContactsRealThread = crp;
cpDoing = cpCount;
connectContactsRealThread = new Thread(new ThreadStart(connectContactsRealDo));
GLib.Idle.Add(new GLib.IdleHandler(pulseConnectContactsReal));
LogB.ThreadStart();
connectContactsRealThread.Start();
}
public void UpdateType(ChronopicRegisterPort crp, ChronopicRegisterPort.Types newType)
{
//Update SQL
SqliteChronopicRegister.Update(false, crp, newType);
//Update list
foreach (ChronopicRegisterPort c in L)
{
if (c.SerialNumber == crp.SerialNumber)
{
c.Type = newType;
break;
}
}
}
protected void registerAddOrUpdate(ChronopicRegisterPort crp)
{
if (!crp.FTDI)
{
return;
}
if (!crpl.Exists(crp))
{
crpl.Add(crp);
}
else if (crpl.PortChanged(crp))
{
crpl.UpdatePort(crp, crp.Port);
}
}
//only call this if Exists
public bool PortChanged(ChronopicRegisterPort crp)
{
foreach (ChronopicRegisterPort c in L)
{
if (c.SerialNumber == crp.SerialNumber)
{
if (c.Port == crp.Port)
{
return(false);
}
return(true);
}
}
return(true);
}
//used on Linux and Mac
protected virtual void createList()
{
List <string> ports = getPorts(true);
foreach (string p in ports)
{
LogB.Information(string.Format("ChronopicRegister for port: " + p));
ChronopicRegisterPort crp = new ChronopicRegisterPort(p);
crp = readFTDI(crp);
LogB.Information(crp.ToString());
//2 add/update registered list
registerAddOrUpdate(crp);
}
}
public bool IsLastConnectedReal(ChronopicRegisterPort crp, int cpCount)
{
if (cpCount == 1 &&
lastConnectedRealPort != "" && lastConnectedRealSerialNumber != "" &&
lastConnectedRealType == ChronopicRegisterPort.Types.CONTACTS &&
crp.Port == lastConnectedRealPort &&
crp.SerialNumber == lastConnectedRealSerialNumber)
{
return(true);
}
else if (cpCount == 2 &&
lastConnectedRealPort2 != "" && lastConnectedRealSerialNumber2 != "" &&
lastConnectedRealType2 == ChronopicRegisterPort.Types.CONTACTS &&
crp.Port == lastConnectedRealPort2 &&
crp.SerialNumber == lastConnectedRealSerialNumber2)
{
return(true);
}
return(false);
}
public ChronopicRegisterWindowTypes(ChronopicRegisterPort crp)
{
this.SerialNumber = crp.SerialNumber;
this.Port = crp.Port;
Unknown = false;
Contacts = false;
Encoder = false;
if (crp.Type == ChronopicRegisterPort.Types.UNKNOWN)
{
Unknown = true;
}
else if (crp.Type == ChronopicRegisterPort.Types.CONTACTS)
{
Contacts = true;
}
else
{
Encoder = true;
}
}
private void callConnectContactsReal(ChronopicRegisterPort crp, int numCP)
{
cp2016.FakeButtonContactsRealDone.Clicked +=
new EventHandler(on_connection_contacts_real_done);
string message = Catalog.GetString("Please, touch the platform or click Chronopic TEST button.");
if (current_menuitem_mode == Constants.Menuitem_modes.RUNSSIMPLE ||
current_menuitem_mode == Constants.Menuitem_modes.RUNSINTERVALLIC)
{
message = Catalog.GetString("Please, cut photocell barrier or click Chronopic TEST button.");
}
cp2016.ConnectContactsReal(app1, crp, numCP, message);
//manage show threshold stuff
threshold.ChronopicFirmwareReconnected(numCP); //t_stored_on_chronopic will be 50, and later firmware will be changed
label_threshold.Text = Catalog.GetString("Threshold") + " " + threshold.GetLabel() + " ms";
if (threshold.GetT == 50)
{
label_threshold.Text += " (" + Catalog.GetString("Applied") + ")";
}
}
//cpCount 2 is for 2nd chronopic on multichronopic
public void ConnectContactsReal(Gtk.Window app1, ChronopicRegisterPort crp,
int cpCount, string labelStr)
{
createGui(app1, labelStr);
crpConnectContactsRealThread = crp;
cpDoing = cpCount;
connectContactsRealThread = new Thread (new ThreadStart (connectContactsRealDo));
GLib.Idle.Add (new GLib.IdleHandler (pulseConnectContactsReal));
LogB.ThreadStart();
connectContactsRealThread.Start();
}
public bool IsLastConnectedReal(ChronopicRegisterPort crp)
{
LogB.Information(string.Format(
"lastConnectedReal (port:{0}, serialNumber:{1}, type:{2})",
lastConnectedRealPort, lastConnectedRealSerialNumber,
lastConnectedRealType.ToString()));
LogB.Information(crp.ToString());
if(lastConnectedRealPort != "" && lastConnectedRealSerialNumber != "" &&
lastConnectedRealType == ChronopicRegisterPort.Types.CONTACTS &&
crp.Port == lastConnectedRealPort &&
crp.SerialNumber == lastConnectedRealSerialNumber)
return true;
return false;
}
protected void registerAddOrUpdate(ChronopicRegisterPort crp)
{
if(! crp.FTDI)
return;
if (! crpl.Exists(crp))
crpl.Add(crp);
else if(crpl.PortChanged(crp))
crpl.UpdatePort(crp, crp.Port);
}
public void Add(ChronopicRegisterPort crp)
{
//Add to SQL
SqliteChronopicRegister.Insert(false, crp);
//Add to list
L.Add(crp);
}
public bool Exists(ChronopicRegisterPort crp)
{
foreach(ChronopicRegisterPort c in L)
if(c.SerialNumber == crp.SerialNumber)
return true;
return false;
}
public static void Update(bool dbconOpened, ChronopicRegisterPort crp, ChronopicRegisterPort.Types newType)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "UPDATE " + table +
" SET type = \"" + newType.ToString() +
"\" WHERE serialNumber = \"" + crp.SerialNumber + "\"" ;
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
closeIfNeeded(dbconOpened);
}
public void UpdatePort(ChronopicRegisterPort crp, string newPort)
{
foreach(ChronopicRegisterPort c in L) {
if(c.SerialNumber == crp.SerialNumber) {
c.Port = newPort;
break;
}
}
}
//only call this if Exists
public bool PortChanged(ChronopicRegisterPort crp)
{
foreach(ChronopicRegisterPort c in L) {
if(c.SerialNumber == crp.SerialNumber) {
if(c.Port == crp.Port)
return false;
return true;
}
}
return true;
}
//unused
protected virtual ChronopicRegisterPort readFTDI(ChronopicRegisterPort crp)
{
return(crp);
}
public void UpdateType(ChronopicRegisterPort crp, ChronopicRegisterPort.Types newType)
{
//Update SQL
SqliteChronopicRegister.Update(false, crp, newType);
//Update list
foreach(ChronopicRegisterPort c in L) {
if(c.SerialNumber == crp.SerialNumber) {
c.Type = newType;
break;
}
}
}
private void createListDo(uint ftdiDeviceCount)
{
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = ftdiDeviceWin.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (uint i = 0; i < ftdiDeviceCount; i++)
{
LogB.Information(String.Format("Device Index: " + i.ToString()));
LogB.Information(String.Format("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags)));
LogB.Information(String.Format("Type: " + ftdiDeviceList[i].Type.ToString()));
LogB.Information(String.Format("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID)));
LogB.Information(String.Format("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId)));
LogB.Information(String.Format("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString()));
LogB.Information(String.Format("Description: " + ftdiDeviceList[i].Description.ToString()));
string port = getComPort(ftdiDeviceList[i]);
ChronopicRegisterPort crp = new ChronopicRegisterPort(port);
crp.FTDI = true;
crp.SerialNumber = ftdiDeviceList[i].SerialNumber.ToString();
crp.Type = ChronopicRegisterPort.Types.UNKNOWN;
LogB.Information(string.Format("crp: " + crp.ToString()));
registerAddOrUpdate(crp);
}
}
}
protected override ChronopicRegisterPort readFTDI(ChronopicRegisterPort crp)
{
//TODO: 1) check if it's FTDI
crp.FTDI = true;
//2) read SerialNumber
//eg crp.Port = "/dev/tty.usbserialA123456F";
string chunk = "usbserial";
int pos = crp.Port.LastIndexOf(chunk) + chunk.Length;
crp.SerialNumber = crp.Port.Substring(pos); //eg. A123456F
return crp;
}
public void Delete(ChronopicRegisterPort crp)
{
//Delete from SQL
SqliteChronopicRegister.Delete(false, crp);
//Delete from list
L.Remove(crp);
}
protected override ChronopicRegisterPort readFTDI(ChronopicRegisterPort crp)
{
/*
* old:
* /bin/udevadm info —name=/dev/ttyUSB0 |grep ID_SERIAL_SHORT|cut -d= -f2
* error on some systems:
* Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.
*/
//new: udevadm info -p $(udevadm info -q path -n /dev/ttyUSB0)
//TODO: find a way to call this in only one process
//1) get path
List<string> parameters = new List<string> { "info", "-q", "path", "-n", crp.Port };
ExecuteProcess.Result result = ExecuteProcess.runShowErrorIfNotStarted ("udevadm", parameters);
string path = result.stdout;
if (result.stderr != "") {
return crp;
}
//2) read FTDI info
parameters = new List<string> { "info", "-p", path };
result = ExecuteProcess.runShowErrorIfNotStarted ("udevadm", parameters);
if (result.stderr != "") {
return crp;
}
foreach (string lineOut in result.stdout.Split('\n'))
{
if (lineOut.Contains("ID_VENDOR=")) {
string [] strFull = lineOut.Split(new char[] {'='});
crp.FTDI = (strFull[1] == "FTDI");
} else if (lineOut.Contains("ID_SERIAL_SHORT=")) {
string [] strFull = lineOut.Split(new char[] {'='});
crp.SerialNumber = strFull[1];
}
}
return crp;
}
private void createTable()
{
int rows = listConnected.Count;
Gtk.Label label_device_title = new Gtk.Label("<b>" + Catalog.GetString("Device") + "</b>");
Gtk.Label label_type_title = new Gtk.Label("<b>" + Catalog.GetString("Type") + "</b>");
label_device_title.UseMarkup = true;
label_type_title.UseMarkup = true;
label_device_title.Show();
label_type_title.Show();
table_main = new Gtk.Table((uint)rows + 1, 2, false); //not homogeneous
table_main.ColumnSpacing = 20;
table_main.RowSpacing = 6;
table_main.Attach(label_device_title, (uint)1, (uint)2, 0, 1);
table_main.Attach(label_type_title, (uint)2, (uint)3, 0, 1);
list_buttons_left = new List <Gtk.Button>();
list_images = new List <Gtk.Image>();
list_labels_type = new List <Gtk.Label>();
list_buttons_right = new List <Gtk.Button>();
for (int count = 1; count <= rows; count++)
{
string deviceStr = listConnected[count - 1].SerialNumber + "\n\n" + listConnected[count - 1].Port;
Gtk.Label label_device = new Gtk.Label(deviceStr);
table_main.Attach(label_device, (uint)1, (uint)2, (uint)count, (uint)count + 1);
label_device.Show();
Gtk.HBox hbox_type = new Gtk.HBox(false, 6);
Button button_left = UtilGtk.CreateArrowButton(ArrowType.Left, ShadowType.In, 50, -1);
button_left.Sensitive = (listConnected[count - 1].Type != TypePixList.l[0].Type);
button_left.CanFocus = false;
button_left.IsFocus = false;
button_left.Clicked += on_button_left_clicked;
//hbox_type.Add(button_left);
hbox_type.PackStart(button_left, true, false, 1);
//create image
Pixbuf pixbuf = TypePixList.GetPix(listConnected[count - 1].Type);
Gtk.Image image = new Gtk.Image();
image.Pixbuf = pixbuf;
hbox_type.Add(image);
hbox_type.PackStart(image, false, false, 1);
Button button_right = UtilGtk.CreateArrowButton(ArrowType.Right, ShadowType.In, 50, -1);
button_right.CanFocus = false;
button_right.IsFocus = false;
button_right.Clicked += on_button_right_clicked;
button_right.Sensitive = (listConnected[count - 1].Type != TypePixList.l[TypePixList.l.Count - 1].Type);
hbox_type.PackStart(button_right, true, false, 1);
Gtk.VBox vbox = new Gtk.VBox(false, 2);
vbox.Add(hbox_type);
Gtk.Label label_type = new Gtk.Label(ChronopicRegisterPort.TypePrint(listConnected[count - 1].Type));
vbox.Add(label_type);
table_main.Attach(vbox, (uint)2, (uint)3, (uint)count, (uint)count + 1);
list_buttons_left.Add(button_left);
list_images.Add(image);
list_labels_type.Add(label_type);
list_buttons_right.Add(button_right);
}
table_main.Show();
}
//unused
protected virtual ChronopicRegisterPort readFTDI(ChronopicRegisterPort crp)
{
return crp;
}
//used on Linux and Mac
protected virtual void createList()
{
List<string> ports = getPorts(true);
foreach(string p in ports)
{
LogB.Information(string.Format("ChronopicRegister for port: " + p));
ChronopicRegisterPort crp = new ChronopicRegisterPort(p);
crp = readFTDI(crp);
LogB.Information(crp.ToString());
//2 add/update registered list
registerAddOrUpdate(crp);
}
}
public static List<ChronopicRegisterPort> SelectAll(bool dbconOpened)
{
openIfNeeded(dbconOpened);
dbcmd.CommandText = "SELECT * FROM " + table;
LogB.SQL(dbcmd.CommandText.ToString());
dbcmd.ExecuteNonQuery();
SqliteDataReader reader = dbcmd.ExecuteReader();
List<ChronopicRegisterPort> l = new List<ChronopicRegisterPort>();
while(reader.Read()) {
ChronopicRegisterPort crp = new ChronopicRegisterPort(
reader[0].ToString(), //serialNumber
(ChronopicRegisterPort.Types) Enum.Parse(
typeof(ChronopicRegisterPort.Types), reader[1].ToString()) //type
);
l.Add(crp);
}
closeIfNeeded(dbconOpened);
return l;
}
public int NumConnectedOfType(ChronopicRegisterPort.Types type)
{
int count = 0;
foreach(ChronopicRegisterPort crp in crpl.L)
if(crp.Type == type && crp.Port != "")
count ++;
return count;
}
