//execution
public PulseExecute(int personID, string personName, int sessionID, string type, double fixedPulse, int totalPulsesNum,
Chronopic cp, Gtk.Window app, int pDN,
bool volumeOn, Preferences.GstreamerTypes gstreamer,
//double progressbarLimit,
ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fixedPulse = fixedPulse;
this.totalPulsesNum = totalPulsesNum;
this.cp = cp;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.gstreamer = gstreamer;
// this.progressbarLimit = progressbarLimit;
this.egd = egd;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Pulse
eventDone = new Pulse();
}
//run execution
public RunExecute(int personID, int sessionID, string type, double distance,
Chronopic cp, Gtk.TextView event_execute_textview_message, Gtk.Window app, int pDN, bool metersSecondsPreferred, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd
)
{
this.personID = personID;
this.sessionID = sessionID;
this.type = type;
this.distance = distance;
this.cp = cp;
this.event_execute_textview_message = event_execute_textview_message;
this.app = app;
this.pDN = pDN;
this.metersSecondsPreferred = metersSecondsPreferred;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Run
eventDone = new Run();
}
//this is called on AutoDetect
static public ChronopicWindow Create(Chronopic cpDetected, ArrayList myCpd, string myEncoderPort, bool recreate, bool volumeOn)
{
LogB.Debug("enter create");
if (ChronopicWindowBox != null && recreate)
{
ChronopicWindowBox.chronopic_window.Hide();
}
if (ChronopicWindowBox == null || recreate)
{
ChronopicWindowBox = new ChronopicWindow(cpDetected, myCpd);
}
LogB.Information("create cp is null? " + (ChronopicWindowBox.cp == null).ToString());
//don't show until View is called
//ChronopicWindowBox.chronopic_window.Show ();
ChronopicWindowBox.volumeOn = volumeOn;
ChronopicWindowBox.setEncoderPort(myEncoderPort);
ChronopicWindowBox.fakeWindowDone = new Gtk.Button();
//ChronopicWindowBox.fakeWindowReload = new Gtk.Button();
return(ChronopicWindowBox);
}
public MultiChronopicExecute(int personID, string personName, int sessionID, string type,
Chronopic cp, Chronopic cp2, Chronopic cp3, Chronopic cp4, bool syncFirst, bool deleteFirst, string vars,
Gtk.Window app,
//double progressbarLimit,
ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.cp = cp;
this.cp2 = cp2;
this.cp3 = cp3;
this.cp4 = cp4;
this.syncFirst = syncFirst;
this.deleteFirst = deleteFirst;
this.vars = vars;
this.app = app;
// this.progressbarLimit = progressbarLimit;
this.egd = egd;
chronopics = 4;
initValues();
}
public static void Main()
{
Application.Init();
//-- Crear el interfaz
Window w = new Window("Prueba");
Button b1 = new Button("Test 1");
Button b2 = new Button("Test 2");
HBox h = new HBox();
w.DeleteEvent += new DeleteEventHandler(Window_Delete);
b1.Clicked += new EventHandler(Button_Clicked);
b2.Clicked += new EventHandler(Button2_Clicked);
h.PackStart(b1, false, false, 0);
h.PackStart(b2, false, false, 0);
w.Add(h);
w.SetDefaultSize(100, 100);
w.ShowAll();
//-- Inicializar chronopic
cp = new Chronopic("/dev/ttyUSB0");
//-- Inicializar otras cosas
Cola = new Queue();
//-- Inicializar temporizador
GLib.Timeout.Add(100, new GLib.TimeoutHandler(Time_Out));
Application.Run();
}
public static void Main()
{
Application.Init();
//-- Crear el interfaz
Window w = new Window("Prueba");
Button b1 = new Button("Test 1");
Button b2 = new Button("Test 2");
HBox h= new HBox();
w.DeleteEvent += new DeleteEventHandler(Window_Delete);
b1.Clicked += new EventHandler(Button_Clicked);
b2.Clicked += new EventHandler(Button2_Clicked);
h.PackStart(b1,false,false,0);
h.PackStart(b2,false,false,0);
w.Add(h);
w.SetDefaultSize(100,100);
w.ShowAll();
//-- Inicializar chronopic
cp = new Chronopic("/dev/ttyUSB0");
//-- Inicializar otras cosas
Cola = new Queue();
//-- Inicializar temporizador
GLib.Timeout.Add(100, new GLib.TimeoutHandler(Time_Out));
Application.Run();
}
//reactionTime execution
public ReactionTimeExecute(int personID, string personName, int sessionID,
Chronopic cp, Gtk.TextView event_execute_textview_message, Gtk.Window app, int pDN, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.cp = cp;
this.event_execute_textview_message = event_execute_textview_message;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a ReactionTime
eventDone = new ReactionTime();
//updateProgressBar = new UpdateProgressBar();
}
//jump execution
public JumpRjExecute(int personID, string personName,
int sessionID, string type, double fall, double weight,
double limitAsDouble, bool jumpsLimited,
Chronopic cp, Gtk.Window app, int pDN, bool allowFinishAfterTime,
bool volumeOn, Preferences.GstreamerTypes gstreamer,
RepetitiveConditionsWindow repetitiveConditionsWin,
double progressbarLimit, ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fall = fall;
this.weight = weight;
this.limitAsDouble = limitAsDouble;
this.jumpsLimited = jumpsLimited;
if (jumpsLimited)
{
this.limited = limitAsDouble.ToString() + "J";
}
else
{
//this.limited = limitAsDouble.ToString() + "T"; define later, because it can be higher if allowFinishRjAfterTime is defined
}
this.cp = cp;
this.app = app;
this.pDN = pDN;
this.allowFinishAfterTime = allowFinishAfterTime;
this.volumeOn = volumeOn;
this.gstreamer = gstreamer;
this.repetitiveConditionsWin = repetitiveConditionsWin;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
if (TypeHasFall)
{
hasFall = true;
}
else
{
hasFall = false;
}
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
timesForSavingRepetitive = 10; //number of times that this repetive event needs for being recorded in temporal table
//initialize eventDone as a JumpRj
eventDone = new JumpRj();
}
//execution
public PulseExecute(int personID, string personName, int sessionID, string type, double fixedPulse, int totalPulsesNum,
Chronopic cp, Gtk.TextView event_execute_textview_message, Gtk.Window app, int pDN, bool volumeOn,
//double progressbarLimit,
ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fixedPulse = fixedPulse;
this.totalPulsesNum = totalPulsesNum;
this.cp = cp;
this.event_execute_textview_message = event_execute_textview_message;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
// this.progressbarLimit = progressbarLimit;
this.egd = egd;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Pulse
eventDone = new Pulse();
}
// <----- change multitest firmware END
//nullify only when exit software
public void SerialPortsCloseIfNeeded(bool nullify)
{
if (sp != null && sp.IsOpen)
{
LogB.Information("Closing sp");
sp.Close();
LogB.Information("Flushing cp to see if helps on OSX port busy");
cp.FlushByTimeOut();
if (nullify)
{
LogB.Information("Disposing cp to see if helps on OSX port busy");
cp = null;
}
}
if (sp2 != null && sp2.IsOpen)
{
LogB.Information("Closing sp2");
sp2.Close();
LogB.Information("Flushing cp2 to see if helps on OSX port busy");
cp2.FlushByTimeOut();
if (nullify)
{
LogB.Information("Disposing cp2 to see if helps on OSX port busy");
cp2 = null;
}
}
}
//chronopic init should not touch gtk, for the threads
public bool Do(int currentCp, out Chronopic myCp, out SerialPort mySp, Chronopic.Plataforma myPS, string myPort, out string returnString, out bool success)
{
LogB.Information("starting connection with chronopic");
CancelledByUser = false;
success = true;
LogB.Information("chronopicInit-1");
LogB.Information(string.Format("chronopic port: {0}", myPort));
mySp = new SerialPort(myPort);
try {
mySp.Open();
LogB.Information("chronopicInit-2");
//-- Create chronopic object, for accessing chronopic
myCp = new Chronopic(mySp);
LogB.Information("chronopicInit-2.1");
myCp.Flush();
//if myCp has been cancelled
if (myCp.AbortFlush)
{
LogB.Information("chronopicInit-2.2 cancelled");
success = false;
myCp = new Chronopic(); //fake constructor
}
else
{
LogB.Information("chronopicInit-3");
//on windows, this check make a crash
//i think the problem is: as we don't really know the Timeout on Windows (.NET) and this variable is not defined on chronopic.cs
//the Read_platform comes too much soon (when cp is not totally created), and this makes crash
//-- Obtener el estado inicial de la plataforma
bool ok = false;
LogB.Information("chronopicInit-4");
do
{
LogB.Information("chronopicInit-5");
ok = myCp.Read_platform(out myPS);
LogB.Information("chronopicInit-6");
} while(!ok && !CancelledByUser);
LogB.Information("chronopicInit-7");
if (!ok)
{
//-- Si hay error terminar
LogB.Error(string.Format("Error: {0}", myCp.Error));
success = false;
}
}
} catch {
LogB.Error("chronopicInit-2.a catched");
success = false;
myCp = new Chronopic(); //fake constructor
}
returnString = "";
return(success);
}
public ChronopicWindow(Chronopic cpDetected, ArrayList myCpd)
{
LogB.Debug("constructor");
Glade.XML gxml;
gxml = Glade.XML.FromAssembly(Util.GetGladePath() + "chronojump.glade", "chronopic_window", "chronojump");
gxml.Autoconnect(this);
cpd = myCpd;
if (cpDetected != null)
{
cp = cpDetected;
sp = new SerialPort(((ChronopicPortData)cpd[0]).Port);
}
UtilGtk.IconWindow(chronopic_window);
if (UtilAll.IsWindows())
{
isWindows = true;
}
else
{
isWindows = false;
}
setDefaultValues();
chronopicInit = new ChronopicInit();
//Pixbuf pixbuf = new Pixbuf (null, Util.GetImagePath(false) + "chronopic_128.png");
//chronopic_image.Pixbuf = pixbuf;
/*
* Pixbuf pixbuf;
* pixbuf = new Pixbuf (null, Util.GetImagePath(true) + Constants.FileNameContactPlatformModular);
* image_contact_modular.Pixbuf = pixbuf;
* pixbuf = new Pixbuf (null, Util.GetImagePath(true) + Constants.FileNameInfrared);
* image_infrared.Pixbuf = pixbuf;
*/
/*
* if(chronopicPort1 != Constants.ChronopicDefaultPortWindows &&
* (chronopicPort1 != Constants.ChronopicDefaultPortLinux && File.Exists(chronopicPort1))
* ) {
* ConfirmWindow confirmWin = ConfirmWindow.Show(Catalog.GetString("Do you want to connect to Chronopic now?"), "", "");
* confirmWin.Button_accept.Clicked += new EventHandler(chronopicAtStart);
* }
*/
}
//jump execution
public JumpExecute(int personID, string personName, int sessionID, string type, double fall, double weight,
Chronopic cp, Gtk.Window app, int pDN,
bool volumeOn, Preferences.GstreamerTypes gstreamer,
double progressbarLimit, ExecutingGraphData egd, string description,
bool avoidGraph //on configChronojump.Exhibition do not show graph because it gets too slow with big database
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fall = fall; //-1 means has to be calculated with a previous jump
this.weight = weight;
this.cp = cp;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.gstreamer = gstreamer;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.description = description;
this.avoidGraph = avoidGraph;
if (TypeHasFall)
{
hasFall = true;
}
else
{
hasFall = false;
}
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Jump
eventDone = new Jump();
}
//jump execution
public JumpExecute(int personID, string personName, int sessionID, string type, double fall, double weight,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app, int pDN, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd, string description
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fall = fall; //-1 means has to be calculated with a previous jump
this.weight = weight;
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.description = description;
if (TypeHasFall)
{
hasFall = true;
}
else
{
hasFall = false;
}
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Jump
eventDone = new Jump();
}
//jump execution
public JumpExecute(int personID, string personName, int sessionID, string type, double fall, double weight,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app, int pDN, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd, string description
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fall = fall; //-1 means has to be calculated with a previous jump
this.weight = weight;
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.description = description;
if(TypeHasFall) {
hasFall = true;
} else {
hasFall = false;
}
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Jump
eventDone = new Jump();
}
protected Chronopic.Plataforma chronopicInitialValue(Chronopic cp)
{
Chronopic.Plataforma myPlatformState = Chronopic.Plataforma.UNKNOW; //on (in platform), off (jumping), or unknow
bool ok = false;
int timeWait = 50; //wait 50ms between calls to Read_platform
int timeLimit = 1000;
int count = 0;
do
{
try {
ok = cp.Read_platform(out myPlatformState);
} catch {
LogB.Warning("Manage called after finishing constructor, do later");
}
Thread.Sleep(timeWait); //wait 50ms
count += timeWait;
} while (!ok && count < timeLimit);
return(myPlatformState);
}
//jump execution
public JumpExecute(int personID, string personName, int sessionID, string type, double fall, double weight,
Chronopic cp, Gtk.TextView event_execute_textview_message, Gtk.Window app, int pDN, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fall = fall;
this.weight = weight;
this.cp = cp;
this.event_execute_textview_message = event_execute_textview_message;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
if(TypeHasFall) {
hasFall = true;
} else {
hasFall = false;
}
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Jump
eventDone = new Jump();
}
//run execution
public RunExecute(int personID, int sessionID, string type, double distance,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app,
int pDN, bool metersSecondsPreferred, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd,
Constants.DoubleContact checkDoubleContactMode, int checkDoubleContactTime,
bool speedStartArrival
)
{
this.personID = personID;
this.sessionID = sessionID;
this.type = type;
this.distance = distance;
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.pDN = pDN;
this.metersSecondsPreferred = metersSecondsPreferred;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.checkDoubleContactMode = checkDoubleContactMode;
this.checkDoubleContactTime = checkDoubleContactTime;
this.speedStartArrival = speedStartArrival;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Run
eventDone = new Run();
}
//run execution
public RunExecute(int personID, int sessionID, string type, double distance,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app,
int pDN, bool metersSecondsPreferred, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd,
Constants.DoubleContact checkDoubleContactMode, int checkDoubleContactTime,
bool speedStartArrival
)
{
this.personID = personID;
this.sessionID = sessionID;
this.type = type;
this.distance = distance;
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.pDN = pDN;
this.metersSecondsPreferred = metersSecondsPreferred;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.checkDoubleContactMode = checkDoubleContactMode;
this.checkDoubleContactTime = checkDoubleContactTime;
this.speedStartArrival = speedStartArrival;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a Run
eventDone = new Run();
}
//----------------------------------------
//-- Obtener el estado de la plataforma
//----------------------------------------
public Respuesta Read_platform(out Plataforma plataforma)
{
int error;
int estado;
Respuesta resp;
//-- Enviar trama de estado
error = Chronopic.estado(this.serial_fd, out estado);
//-- Convertir el error al tipo Respueta
switch (error)
{
case 0:
resp = Respuesta.Timeout;
plataforma = Plataforma.UNKNOW;
break;
case 1:
resp = Respuesta.Ok;
if (estado == 0)
{
plataforma = Plataforma.OFF;
}
else
{
plataforma = Plataforma.ON;
}
break;
default:
resp = Respuesta.Error;
plataforma = Plataforma.UNKNOW;
break;
}
//-- Devolver Respuesta
return(resp);
}
//execution
public MultiChronopicExecute(int personID, string personName, int sessionID, string type,
Chronopic cp, bool syncFirst, bool deleteFirst, string vars, Gtk.Window app,
//double progressbarLimit,
ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.cp = cp;
this.syncFirst = syncFirst;
this.deleteFirst = deleteFirst;
this.vars = vars;
this.app = app;
// this.progressbarLimit = progressbarLimit;
this.egd = egd;
chronopics = 1;
initValues();
}
//reactionTime execution
public ReactionTimeExecute(int personID, string personName, int sessionID, string type,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app, int pDN, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd, string description
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.description = description;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
FakeButtonReactionTimeStart = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a ReactionTime
eventDone = new ReactionTime();
//updateProgressBar = new UpdateProgressBar();
}
//reactionTime execution
public ReactionTimeExecute(int personID, string personName, int sessionID, string type,
Chronopic cp, Gtk.Window app, int pDN,
bool volumeOn, Preferences.GstreamerTypes gstreamer,
double progressbarLimit, ExecutingGraphData egd, string description
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.cp = cp;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.gstreamer = gstreamer;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.description = description;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
FakeButtonReactionTimeStart = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a ReactionTime
eventDone = new ReactionTime();
//updateProgressBar = new UpdateProgressBar();
}
//reactionTime execution
public ReactionTimeExecute(int personID, string personName, int sessionID,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app, int pDN, bool volumeOn,
double progressbarLimit, ExecutingGraphData egd, string description
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.description = description;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
FakeButtonReactionTimeStart = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
//initialize eventDone as a ReactionTime
eventDone = new ReactionTime();
//updateProgressBar = new UpdateProgressBar();
}
//run execution
public RunIntervalExecute(int personID, int sessionID, string type, double distanceInterval, double limitAsDouble, bool tracksLimited,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app, int pDN, bool metersSecondsPreferred,
bool volumeOn, RepetitiveConditionsWindow repetitiveConditionsWin,
double progressbarLimit, ExecutingGraphData egd ,
Constants.DoubleContact checkDoubleContactMode, int checkDoubleContactTime,
bool speedStartArrival
)
{
this.personID = personID;
this.sessionID = sessionID;
this.type = type;
this.distanceInterval = distanceInterval;
this.limitAsDouble = limitAsDouble;
this.tracksLimited = tracksLimited;
//if distances are variable
distancesString = "";
if(distanceInterval == -1) {
RunType runType = SqliteRunIntervalType.SelectAndReturnRunIntervalType(type, false);
distancesString = runType.DistancesString;
}
if(tracksLimited) {
this.limited = limitAsDouble.ToString() + "R"; //'R'uns (don't put 'T'racks for not confusing with 'T'ime)
} else {
this.limited = limitAsDouble.ToString() + "T";
timeTotal = limitAsDouble;
}
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.metersSecondsPreferred = metersSecondsPreferred;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.repetitiveConditionsWin = repetitiveConditionsWin;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.checkDoubleContactMode = checkDoubleContactMode;
this.checkDoubleContactTime = checkDoubleContactTime;
this.speedStartArrival = speedStartArrival;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
timesForSavingRepetitive = 1; //number of times that this repetive event needs for being recorded in temporal table
//initialize eventDone as a RunInterval
eventDone = new RunInterval();
}
//run execution
public RunIntervalExecute(int personID, int sessionID, string type, double distanceInterval, double limitAsDouble, bool tracksLimited,
Chronopic cp, Gtk.Label event_execute_label_message, Gtk.Window app, int pDN, bool metersSecondsPreferred,
bool volumeOn, RepetitiveConditionsWindow repetitiveConditionsWin,
double progressbarLimit, ExecutingGraphData egd,
Constants.DoubleContact checkDoubleContactMode, int checkDoubleContactTime,
bool speedStartArrival
)
{
this.personID = personID;
this.sessionID = sessionID;
this.type = type;
this.distanceInterval = distanceInterval;
this.limitAsDouble = limitAsDouble;
this.tracksLimited = tracksLimited;
//if distances are variable
distancesString = "";
if (distanceInterval == -1)
{
RunType runType = SqliteRunIntervalType.SelectAndReturnRunIntervalType(type, false);
distancesString = runType.DistancesString;
}
if (tracksLimited)
{
this.limited = limitAsDouble.ToString() + "R"; //'R'uns (don't put 'T'racks for not confusing with 'T'ime)
}
else
{
this.limited = limitAsDouble.ToString() + "T";
timeTotal = limitAsDouble;
}
this.cp = cp;
this.event_execute_label_message = event_execute_label_message;
this.app = app;
this.metersSecondsPreferred = metersSecondsPreferred;
this.pDN = pDN;
this.volumeOn = volumeOn;
this.repetitiveConditionsWin = repetitiveConditionsWin;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
this.checkDoubleContactMode = checkDoubleContactMode;
this.checkDoubleContactTime = checkDoubleContactTime;
this.speedStartArrival = speedStartArrival;
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
fakeButtonThreadDyed = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
timesForSavingRepetitive = 1; //number of times that this repetive event needs for being recorded in temporal table
//initialize eventDone as a RunInterval
eventDone = new RunInterval();
}
protected override void waitEvent()
{
double timestamp = 0;
bool success = false;
shouldFinishAtNextFall = false;
bool ok;
int countForSavingTempTable = 0;
//prepare variables to allow being cancelled or finished
if (!simulated)
{
Chronopic.InitCancelAndFinish();
}
do
{
if (simulated)
{
ok = true;
}
else
{
ok = cp.Read_event(out timestamp, out platformState);
}
//if chronopic signal is Ok and state has changed
if (ok && (
(platformState == Chronopic.Plataforma.ON && loggedState == States.OFF) ||
(platformState == Chronopic.Plataforma.OFF && loggedState == States.ON)) &&
!cancel && !finish)
{
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
LogB.Information(Util.GetTotalTime(tcString, tvString).ToString());
string equal = "";
//while no finished time or jumps, continue recording events
if (!success)
{
//don't record the time until the first event
if (firstRjValue)
{
firstRjValue = false;
//but start timer
initializeTimer();
feedbackMessage = "";
needShowFeedbackMessage = true;
}
else
{
//reactive jump has not finished... record the next jump
LogB.Information(string.Format("tcCount: {0}, tvCount: {1}", tcCount, tvCount));
if (tcCount == tvCount)
{
lastTc = timestamp / 1000.0;
if (tcCount > 0)
{
equal = "=";
}
tcString = tcString + equal + lastTc.ToString();
updateTimerCountWithChronopicData(tcString, tvString);
tcCount = tcCount + 1;
}
else
{
//tcCount > tvCount
lastTv = timestamp / 1000.0;
if (tvCount > 0)
{
equal = "=";
}
tvString = tvString + equal + lastTv.ToString();
updateTimerCountWithChronopicData(tcString, tvString);
tvCount = tvCount + 1;
//update event progressbar
//app1.ProgressBarEventOrTimePreExecution(
updateProgressBar = new UpdateProgressBar(
true, //isEvent
jumpsLimited, //if jumpsLimited: do fraction; if time limited: do pulse
tvCount
);
needUpdateEventProgressBar = true;
//update graph
PrepareEventGraphJumpReactiveObject = new PrepareEventGraphJumpReactive(lastTv, lastTc, tvString, tcString);
needUpdateGraphType = eventType.JUMPREACTIVE;
needUpdateGraph = true;
//put button_finish as sensitive when first jump is done (there's something recordable)
if (tvCount == 1)
{
needSensitiveButtonFinish = true;
}
//save temp table if needed
countForSavingTempTable++;
if (countForSavingTempTable == timesForSavingRepetitive)
{
writeRj(true); //tempTable
countForSavingTempTable = 0;
}
}
}
}
//if we finish by time, and allowFinishAfterTime == true, when time passed, if the jumper is jumping
//if flags the shouldFinishAtNextFall that will finish when he arrives to the platform
if (shouldFinishAtNextFall && platformState == Chronopic.Plataforma.ON && loggedState == States.OFF)
{
finish = true;
}
//check if reactive jump should finish
if (jumpsLimited)
{
if (limitAsDouble != -1)
{
if (Util.GetNumberOfJumps(tvString, false) >= limitAsDouble)
{
jumpPhase = jumpPhases.PLATFORM_END;
writeRj(false); //tempTable
success = true;
//update event progressbar
//app1.ProgressBarEventOrTimePreExecution(
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
tvCount
);
needUpdateEventProgressBar = true;
//update graph
PrepareEventGraphJumpReactiveObject = new PrepareEventGraphJumpReactive(lastTv, lastTc, tvString, tcString);
needUpdateGraphType = eventType.JUMPREACTIVE;
needUpdateGraph = true;
}
}
}
if (platformState == Chronopic.Plataforma.OFF)
{
loggedState = States.OFF;
}
else
{
loggedState = States.ON;
}
}
} while (!success && !cancel && !finish);
if (finish)
{
//write only if there's a jump at minimum
if (Util.GetNumberOfJumps(tcString, false) >= 1 && Util.GetNumberOfJumps(tvString, false) >= 1)
{
jumpPhase = jumpPhases.PLATFORM_END;
writeRj(false); //tempTable
}
else
{
//cancel a jump if clicked finish before any events done
cancel = true;
}
}
}
protected override void waitEvent()
{
double timestamp = 0;
bool success = false;
bool ok;
int phase = 0;
//prepare variables to allow being cancelled or finished
if (!simulated)
{
Chronopic.InitCancelAndFinish();
}
do
{
if (simulated)
{
ok = true;
}
else
{
LogB.Information("calling Read_event");
ok = cp.Read_event(out timestamp, out platformState);
LogB.Information("Read_event done!");
}
/*
* \()/ \()/
* \/ \/
* _()_ /\ _()_ /\ _()_
* \/ \/ \/
* ___/\______________/\______________/\___
*
* GraphA graphB graphC graphD graphE
* unused jumps lands jumps lands
*
* ______start_______ end
*
* DJ DJ SJ
* hasFall hasFall
* fall -1
*
*/
//if (ok)
if (ok && !cancel)
{
if (platformState == Chronopic.Plataforma.ON && loggedState == States.OFF)
{
//has landed
if (hasFall && tc == 0)
{
//**** graphC ****
if (fall == -1)
{
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
//calculate the fall height using flight time
double tvPreJump = timestamp / 1000.0;
fall = Convert.ToDouble(Util.GetHeightInCentimeters(tvPreJump.ToString()));
}
//jump with fall, landed first time
initializeTimer();
//app1.ProgressBarEventOrTimePreExecution(
//don't do it, put a boolean value and let the PulseGTK do it
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //jumpsLimited: percentageMode
++phase
);
needUpdateEventProgressBar = true;
feedbackMessage = "";
needShowFeedbackMessage = true;
}
else
{
//**** graphE **** jump with fall: second landed; or without fall first landing
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
LogB.Information(string.Format("t1:{0}", timestamp));
tv = timestamp / 1000.0;
jumpPhase = jumpPhases.PLATFORM_END;
write();
success = true;
//app1.ProgressBarEventOrTimePreExecution(
//don't do it, put a boolean value and let the PulseGTK do it
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
++phase
);
needUpdateEventProgressBar = true;
}
loggedState = States.ON;
}
else if (platformState == Chronopic.Plataforma.OFF && loggedState == States.ON)
{
//it's out, was inside (= has jumped)
//fall != -1 because if it was == -1, it will change once touching floor for the first time
if (hasFall && fall != -1)
{
//**** graphD ****
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
LogB.Information(string.Format("t2:{0}", timestamp));
//record the TC
tc = timestamp / 1000.0;
//takeOff jump (only one TC)
//if(fixedValue == 0.5)
if (type == Constants.TakeOffName || type == Constants.TakeOffWeightName)
{
tv = 0;
jumpPhase = jumpPhases.PLATFORM_END;
write();
success = true;
}
//update event progressbar
//app1.ProgressBarEventOrTimePreExecution(
//don't do it, put a boolean value and let the PulseGTK do it
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
++phase
);
needUpdateEventProgressBar = true;
}
else
{
//**** graphD (if normal jump) ****
//**** graphB (if hasFall and fall == -1) ****
initializeTimer();
//update event progressbar
//app1.ProgressBarEventOrTimePreExecution(
//don't do it, put a boolean value and let the PulseGTK do it
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
++phase
);
needUpdateEventProgressBar = true;
feedbackMessage = "";
needShowFeedbackMessage = true;
}
//change the automata state
loggedState = States.OFF;
}
}
} while (!success && !cancel);
LogB.Information("Exited waitEvent main bucle");
}
protected override void waitEvent()
{
double timestamp = 0;
bool success = false;
string equal = "";
bool ok;
//prepare variables to allow being cancelled or finished
if (!simulated)
{
Chronopic.InitCancelAndFinish();
}
do
{
if (simulated)
{
ok = true;
}
else
{
ok = cp.Read_event(out timestamp, out platformState);
}
if (ok && !cancel && !finish)
{
if (platformState == Chronopic.Plataforma.ON && loggedState == States.OFF)
{
//has arrived
//if we arrive to the platform for the first time, don't record anything
if (pulsePhase == pulsePhases.WAIT_FIRST_EVENT)
{
pulsePhase = pulsePhases.DOING;
//pulse starts
initializeTimer();
feedbackMessage = "";
needShowFeedbackMessage = true;
}
else
{
//is not the first pulse
if (totalPulsesNum == -1)
{
//if is "unlimited",
//then play with the progress bar until finish button is pressed
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
if (timesString.Length > 0)
{
equal = "=";
}
timesString = timesString + equal + (contactTime / 1000.0 + timestamp / 1000.0).ToString();
tracks++;
//update event progressbar
//progressBarEventOrTimePreExecution(
updateProgressBar = new UpdateProgressBar(
true, //isEvent
false, //activityMode
tracks
);
needUpdateEventProgressBar = true;
//update graph
//preparePulseGraph(timestamp/1000.0, timesString);
PrepareEventGraphPulseObject = new PrepareEventGraphPulse(timestamp / 1000.0, timesString);
needUpdateGraphType = eventType.PULSE;
needUpdateGraph = true;
//put button_finish as sensitive when first jump is done (there's something recordable)
if (tracks == 1)
{
needSensitiveButtonFinish = true;
}
}
else
{
//is not the first pulse, and it's limited by tracks (ticks)
tracks++;
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
if (timesString.Length > 0)
{
equal = "=";
}
timesString = timesString + equal + (contactTime / 1000.0 + timestamp / 1000.0).ToString();
if (tracks >= totalPulsesNum)
{
//finished
write();
success = true;
pulsePhase = pulsePhases.DONE;
}
//update event progressbar
//progressBarEventOrTimePreExecution(
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //PercentageMode
tracks
);
needUpdateEventProgressBar = true;
//update graph
//preparePulseGraph(timestamp/1000.0, timesString);
PrepareEventGraphPulseObject = new PrepareEventGraphPulse(timestamp / 1000.0, timesString);
needUpdateGraphType = eventType.PULSE;
needUpdateGraph = true;
//put button_finish as sensitive when first jump is done (there's something recordable)
if (tracks == 1)
{
needSensitiveButtonFinish = true;
}
}
}
//change the automata state
loggedState = States.ON;
}
else if (platformState == Chronopic.Plataforma.OFF && loggedState == States.ON)
{
//it's out, was inside (= has abandoned platform)
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
contactTime = timestamp;
//change the automata state
loggedState = States.OFF;
}
}
} while (!success && !cancel && !finish);
if (finish)
{
write();
pulsePhase = pulsePhases.DONE;
}
}
//jump execution
public JumpRjExecute(int personID, string personName,
int sessionID, string type, double fall, double weight,
double limitAsDouble, bool jumpsLimited,
Chronopic cp, Gtk.TextView event_execute_textview_message, Gtk.Window app, int pDN, bool allowFinishAfterTime,
bool volumeOn, RepetitiveConditionsWindow repetitiveConditionsWin,
double progressbarLimit, ExecutingGraphData egd
)
{
this.personID = personID;
this.personName = personName;
this.sessionID = sessionID;
this.type = type;
this.fall = fall;
this.weight = weight;
this.limitAsDouble = limitAsDouble;
this.jumpsLimited = jumpsLimited;
if(jumpsLimited) {
this.limited = limitAsDouble.ToString() + "J";
} else {
//this.limited = limitAsDouble.ToString() + "T"; define later, because it can be higher if allowFinishRjAfterTime is defined
}
this.cp = cp;
this.event_execute_textview_message = event_execute_textview_message;
this.app = app;
this.pDN = pDN;
this.allowFinishAfterTime = allowFinishAfterTime;
this.volumeOn = volumeOn;
this.repetitiveConditionsWin = repetitiveConditionsWin;
this.progressbarLimit = progressbarLimit;
this.egd = egd;
if(TypeHasFall) { hasFall = true; }
else { hasFall = false; }
fakeButtonUpdateGraph = new Gtk.Button();
fakeButtonEventEnded = new Gtk.Button();
fakeButtonFinished = new Gtk.Button();
simulated = false;
needUpdateEventProgressBar = false;
needUpdateGraph = false;
timesForSavingRepetitive = 10; //number of times that this repetive event needs for being recorded in temporal table
//initialize eventDone as a JumpRj
eventDone = new JumpRj();
}
/**********************/
/* PROGRAMA PRINCIPAL */
/**********************/
public static void Main()
{
Chronopic.Plataforma estado_plataforma;
Chronopic.Respuesta respuesta;
Automata estado_automata;
double timestamp;
double toff;
//-- Crear objeto chronopic, para acceder al chronopic
Chronopic cp = new Chronopic("/dev/ttyUSB0");
//-- Obtener el estado inicial de la plataforma
respuesta = cp.Read_platform(out estado_plataforma);
switch (respuesta)
{
case Chronopic.Respuesta.Error:
Console.WriteLine("Error en comunicacion con Chronopic");
return;
case Chronopic.Respuesta.Timeout:
Console.WriteLine("Chronopic no responde");
return;
default:
break;
}
Console.WriteLine("Estado plataforma: {0}", estado_plataforma);
//-- Establecer el estado inicial del automata
if (estado_plataforma == Chronopic.Plataforma.ON)
{
estado_automata = Automata.ON;
}
else
{
Console.WriteLine("Suba a la plataforma para realizar el salto");
//-- Esperar a que llegue una trama con el estado de la plataforma
//-- igual a ON. Esto indica que el usuario se ha subido
do
{
respuesta = cp.Read_event(out timestamp, out estado_plataforma);
} while (respuesta != Chronopic.Respuesta.Ok);
//-- Se han subido a la plataforma
estado_automata = Automata.ON;
}
Console.WriteLine("");
Console.WriteLine("Puede saltar cuando quiera");
Console.WriteLine("Pulse control-c para finalizar la sesion");
Console.WriteLine("-----------------------------------------");
while (true)
{
//-- Esperar a que llegue una trama
do
{
respuesta = cp.Read_event(out timestamp, out estado_plataforma);
} while (respuesta != Chronopic.Respuesta.Ok);
//-- Segun el estado del automata
switch (estado_automata)
{
case Automata.OFF: //-- Usuario estaba en el aire
//-- Si ha aterrizado
if (estado_plataforma == Chronopic.Plataforma.ON)
{
//-- Pasar al estado ON
estado_automata = Automata.ON;
//-- Registrar tiempo de vuelo
toff = timestamp;
//-- Imprimir informacion
Console.WriteLine("Tiempo: {0:f1} ms", toff);
}
break;
case Automata.ON: //-- Usuario estaba en la plataforma
//-- Si ahora esta en el aire...
if (estado_plataforma == Chronopic.Plataforma.OFF)
{
//-- Pasar al estado OFF
estado_automata = Automata.OFF;
}
break;
}
}
}
/**********************/
/* PROGRAMA PRINCIPAL */
/**********************/
public static void Main(string[] args)
{
Chronopic.Plataforma estado_plataforma;
Automata estado_automata;
double timestamp;
double toff;
double ton;
bool ok;
string portName = "";
string fileName = "";
TextWriter writer;
//always output to a file, but if not specified, output here and rewrite it every chronojump_mini execution
string defaultFileName = Path.Combine(getOutputDir(), "output");
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("es-ES");
System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("es-ES");
//connect with catalog.cs for using gettext translation
Catalog.Init("chronojump", "./locale");
//parameters passing only on linux
if (!UtilAll.IsWindows())
{
if (args.Length > 2)
{
printSyntaxAndQuit();
}
for (int i = 0; i != args.Length; ++i)
{
Console.WriteLine("param[{0}]: {1}", i, args[i]);
if (args[i].StartsWith("PORT="))
{
portName = args[i].Substring(5);
}
else if (args[i].StartsWith("FILE="))
{
fileName = args[i].Substring(5);
fileName = getOutputDir() + Path.DirectorySeparatorChar + fileName;
}
else
{
printSyntaxAndQuit();
}
}
}
//detection of ports
string messageInfo;
//string messageDetected ="";
if (UtilAll.IsWindows())
{
messageInfo = Constants.PortNamesWindows;
/*
* messageDetected = Catalog.GetString("Detected ports:") + "\n";
*
* string jumpLine = "";
* foreach (string s in SerialPort.GetPortNames()) {
* messageDetected += jumpLine + s;
* jumpLine = "\n";
* }
*/
}
else
{
messageInfo = Constants.PortNamesLinux;
}
messageInfo += string.Format("\n" + Catalog.GetString("More information on Chronojump manual"));
Console.WriteLine("---------------------------");
Console.WriteLine(messageInfo);
Console.WriteLine("---------------------------");
if (portName == "")
{
if (!UtilAll.IsWindows())
{
Console.WriteLine(UtilAll.DetectPortsLinux(false)); //formatting
}
Console.WriteLine(Catalog.GetString("Print the port name where chronopic is connected:"));
portName = Console.ReadLine();
}
//output file stuff
fileName = manageFileName(fileName);
if (fileName == "")
{
fileName = defaultFileName + "-" + portName.Replace("/", "") + ".csv";
}
writer = File.CreateText(fileName);
Console.WriteLine(Catalog.GetString("Opening port...") + " " +
Catalog.GetString("Please touch the platform or click Chronopic TEST button"));
//-- Crear puerto serie
SerialPort sp;
sp = new SerialPort(portName);
//-- Abrir puerto serie. Si ocurre algun error
//-- Se lanzara una excepcion
try {
sp.Open();
} catch (Exception e) {
Console.WriteLine(Catalog.GetString("Error opening serial port"));
Console.WriteLine(e);
Environment.Exit(1);
}
//-- Crear objeto chronopic, para acceder al chronopic
Chronopic cp = new Chronopic(sp);
cp.Flush();
//-- Obtener el estado inicial de la plataforma
// this do...while is here because currently there's no timeout on chronopic.cs on windows
do
{
ok = cp.Read_platform(out estado_plataforma);
} while(!ok);
if (!ok)
{
//-- Si hay error terminar
Console.WriteLine(string.Format(Catalog.GetString("Error: {0}"), cp.Error));
System.Environment.Exit(-1);
}
Console.WriteLine(string.Format(Catalog.GetString("Platform state: {0}"), estado_plataforma));
//Console.WriteLine("Automatic variables: ");
//cp.Read_variables_automatic();
//-- Establecer el estado inicial del automata
if (estado_plataforma == Chronopic.Plataforma.ON)
{
estado_automata = Automata.ON;
}
else
{
Console.WriteLine(Catalog.GetString("Go up platform for jumping"));
//-- Esperar a que llegue una trama con el estado de la plataforma
//-- igual a ON. Esto indica que el usuario se ha subido
do
{
ok = cp.Read_event(out timestamp, out estado_plataforma);
} while (!ok);
//-- Se han subido a la plataforma
estado_automata = Automata.ON;
}
Console.WriteLine("");
Console.WriteLine(Catalog.GetString("Jump when prepared"));
Console.WriteLine(Catalog.GetString("Press CTRL-c for ending session"));
Console.WriteLine("-----------------------------------------");
double count = 1.0;
Console.WriteLine(" TC(ms) TF(ms)");
writer.WriteLine("count;TC(ms);TF(ms)");
while (true)
{
//-- Esperar a que llegue una trama
do
{
ok = cp.Read_event(out timestamp, out estado_plataforma);
} while (ok == false);
//-- Segun el estado del automata
switch (estado_automata)
{
case Automata.OFF: //-- Usuario estaba en el aire
//-- Si ha aterrizado
if (estado_plataforma == Chronopic.Plataforma.ON)
{
//-- Pasar al estado ON
estado_automata = Automata.ON;
//-- Registrar tiempo de vuelo
toff = timestamp;
//-- Imprimir informacion
Console.WriteLine("{0:f1}", toff);
writer.WriteLine("{0:f1}", toff);
}
break;
case Automata.ON: //-- Usuario estaba en la plataforma
//-- Si ahora esta en el aire...
if (estado_plataforma == Chronopic.Plataforma.OFF)
{
//-- Pasar al estado OFF
estado_automata = Automata.OFF;
//-- Registrar tiempo de contacto
ton = timestamp;
//-- Imprimir informacion
Console.Write(count + " {0:f1} ", ton);
writer.Write(count + ";{0:f1};", ton);
}
break;
}
writer.Flush();
count += .5;
}
}
/*
* //onTimer allow to update progressbar_time every 50 milliseconds
* //also can change platform state in simulated mode
* //protected void onTimer( Object source, ElapsedEventArgs e )
* protected override void onTimer( )
* {
* timerCount = timerCount + .05; //0,05 segons == 50 milliseconds, time between each call of onTimer
* }
*/
public override void Manage()
{
//boolean to know if chronopic has been disconnected
chronopicDisconnected = false;
if (chronopics > 0)
{
platformState = chronopicInitialValue(cp);
if (platformState == Chronopic.Plataforma.ON)
{
loggedState = States.ON;
cp1StartedIn = true;
}
else if (platformState == Chronopic.Plataforma.OFF)
{
loggedState = States.OFF;
cp1StartedIn = false;
}
else //UNKNOW (Chronopic disconnected, port changed, ...)
{
chronopicHasBeenDisconnected();
return;
}
//prepare jump for being cancelled if desired
cancel = false;
//prepare jump for being finished earlier if desired
finish = false;
if (chronopics > 1)
{
platformState2 = chronopicInitialValue(cp2);
if (platformState2 == Chronopic.Plataforma.ON)
{
loggedState2 = States.ON;
cp2StartedIn = true;
}
else if (platformState2 == Chronopic.Plataforma.OFF)
{
loggedState2 = States.OFF;
cp2StartedIn = false;
}
else //UNKNOW (Chronopic disconnected, port changed, ...)
{
chronopicHasBeenDisconnected();
return;
}
if (chronopics > 2)
{
platformState3 = chronopicInitialValue(cp3);
if (platformState3 == Chronopic.Plataforma.ON)
{
loggedState3 = States.ON;
cp3StartedIn = true;
}
else if (platformState3 == Chronopic.Plataforma.OFF)
{
loggedState3 = States.OFF;
cp3StartedIn = false;
}
else //UNKNOW (Chronopic disconnected, port changed, ...)
{
chronopicHasBeenDisconnected();
return;
}
if (chronopics > 3)
{
platformState4 = chronopicInitialValue(cp4);
if (platformState4 == Chronopic.Plataforma.ON)
{
loggedState4 = States.ON;
cp4StartedIn = true;
}
else if (platformState4 == Chronopic.Plataforma.OFF)
{
loggedState4 = States.OFF;
cp4StartedIn = false;
}
else //UNKNOW (Chronopic disconnected, port changed, ...)
{
chronopicHasBeenDisconnected();
return;
}
}
}
}
}
string platformsProblems = "";
if (type == Constants.RunAnalysisName)
{
string sep = "";
if (platformState == Chronopic.Plataforma.ON)
{
platformsProblems = Catalog.GetString("Photocells");
sep = ", ";
}
if (platformState2 == Chronopic.Plataforma.ON)
{
platformsProblems += sep + Catalog.GetString("Platform");
}
}
if (platformsProblems.Length > 0)
{
ConfirmWindow confirmWin;
confirmWin = ConfirmWindow.Show(
string.Format(Catalog.GetString("There's contact in {0}. Please leave."), platformsProblems), "", "");
Util.PlaySound(Constants.SoundTypes.BAD, volumeOn, gstreamer);
//we call again this function
confirmWin.Button_accept.Clicked += new EventHandler(callAgainManage);
//if confirmWin.Button_cancel is pressed retuen
confirmWin.Button_cancel.Clicked += new EventHandler(cancel_event_before_start);
}
else
{
firstValue = true;
//writingStarted = false;
//start thread
if (chronopics > 0)
{
//prepare variables to allow being cancelled or finished
if (!simulated)
{
Chronopic.InitCancelAndFinish();
}
thread = new Thread(new ThreadStart(waitEventPre));
if (chronopics > 1)
{
thread2 = new Thread(new ThreadStart(waitEventPre2));
if (chronopics > 2)
{
thread3 = new Thread(new ThreadStart(waitEventPre3));
if (chronopics > 3)
{
thread4 = new Thread(new ThreadStart(waitEventPre4));
}
}
}
}
GLib.Idle.Add(new GLib.IdleHandler(PulseGTK));
if (chronopics > 0)
{
LogB.ThreadStart();
thread.Start();
if (chronopics > 1)
{
thread2.Start();
if (chronopics > 2)
{
thread3.Start();
if (chronopics > 4)
{
thread4.Start();
}
}
}
}
}
}
//chronopic init should not touch gtk, for the threads
public bool Do(int currentCp, out Chronopic myCp, out SerialPort mySp, Chronopic.Plataforma myPS, string myPort, out string returnString, out bool success)
{
LogB.Information("starting connection with chronopic");
CancelledByUser = false;
success = true;
LogB.Information("chronopicInit-1");
LogB.Information(string.Format("chronopic port: {0}", myPort));
mySp = new SerialPort(myPort);
try {
mySp.Open();
LogB.Information("chronopicInit-2");
//-- Create chronopic object, for accessing chronopic
myCp = new Chronopic(mySp);
LogB.Information("chronopicInit-2.1");
myCp.Flush();
//if myCp has been cancelled
if (myCp.AbortFlush)
{
LogB.Information("chronopicInit-2.2 cancelled");
success = false;
myCp = new Chronopic(); //fake constructor
}
else
{
LogB.Information("chronopicInit-3");
//on windows, this check make a crash
//i think the problem is: as we don't really know the Timeout on Windows (.NET) and this variable is not defined on chronopic.cs
//the Read_platform comes too much soon (when cp is not totally created), and this makes crash
//-- Obtener el estado inicial de la plataforma
bool ok = false;
LogB.Information("chronopicInit-4");
do
{
LogB.Information("chronopicInit-5");
ok = myCp.Read_platform(out myPS);
LogB.Information("chronopicInit-6");
} while(!ok && !CancelledByUser);
LogB.Information("chronopicInit-7");
if (!ok)
{
//-- Si hay error terminar
LogB.Error(string.Format("Error: {0}", myCp.Error));
success = false;
}
}
} catch {
LogB.Error("chronopicInit-2.a catched");
success = false;
myCp = new Chronopic(); //fake constructor
}
bool connected = false;
returnString = "";
if (success)
{
if (currentCp == 1)
{
connected = true;
}
returnString = string.Format(Catalog.GetString("<b>Connected</b> to Chronopic on port: {0}"), myPort);
}
else
{
returnString = Catalog.GetString("Problems communicating to chronopic.");
if (currentCp == 1)
{
returnString += " " + Catalog.GetString("Changed platform to 'Simulated'");
returnString += Catalog.GetString("\n\nWe recommend to remove and connect USB cable.");
}
//this will raise on_radiobutton_simulated_ativate and
//will put cpRunning to false, and simulated to true and cp.Close()
if (currentCp == 1)
{
connected = false;
}
}
return(connected);
}
// <----- change multitest firmware END
public void SerialPortsCloseIfNeeded()
{
if(sp != null && sp.IsOpen) {
LogB.Information("Closing sp");
sp.Close();
LogB.Information("Flushing cp to see if helps on OSX port busy");
cp.FlushByTimeOut();
LogB.Information("Disposing cp to see if helps on OSX port busy");
cp = null;
}
if(sp2 != null && sp2.IsOpen) {
LogB.Information("Closing sp2");
sp2.Close();
LogB.Information("Flushing cp2 to see if helps on OSX port busy");
cp2.FlushByTimeOut();
LogB.Information("Disposing cp2 to see if helps on OSX port busy");
cp2 = null;
}
}
protected override void waitEvent()
{
double timestamp = 0;
bool success = false;
bool ok;
//prepare variables to allow being cancelled or finished
if (!simulated)
{
Chronopic.InitCancelAndFinish();
}
LogB.Information("Inside waitEvent");
do
{
if (simulated)
{
ok = true;
}
else
{
ok = cp.Read_event(out timestamp, out platformState);
}
LogB.Information("Inside do");
LogB.Information("cancel == ");
LogB.Information(cancel.ToString());
LogB.Information("ok == ");
LogB.Information(ok.ToString());
//if (ok) {
if (ok && !cancel)
{
LogB.Information("ok!");
if (platformState == Chronopic.Plataforma.ON && loggedState == States.OFF)
{
//LogB.Information("condition guai! hem entrat!");
//has landed
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
LogB.Information(string.Format("t1:{0}", timestamp));
time = timestamp / 1000.0;
write();
success = true;
//update event progressbar
double percentageToPass = 2; //has two phases
//progressBarEventOrTimePreExecution(
//don't do it, put a boolean value and let the PulseGTK do it
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
percentageToPass
);
needUpdateEventProgressBar = true;
loggedState = States.ON;
}
else if (platformState == Chronopic.Plataforma.OFF && loggedState == States.ON)
{
//LogB.Information("condition hem sortit");
//it's out, was inside (= has released)
initializeTimer();
feedbackMessage = "";
needShowFeedbackMessage = true;
//update event progressbar
//progressBarEventOrTimePreExecution(
//don't do it, put a boolean value and let the PulseGTK do it
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
1 //normal jump, phase 1/2
);
needUpdateEventProgressBar = true;
//change the automata state
loggedState = States.OFF;
}
}
//Log.WriteLine("PREEXIT");
} while (!success && !cancel);
//Log.WriteLine("EXIT");
}
protected Chronopic.Plataforma chronopicInitialValue(Chronopic cp)
{
Chronopic.Plataforma myPlatformState = Chronopic.Plataforma.UNKNOW; //on (in platform), off (jumping), or unknow
bool ok = false;
int timeWait = 50; //wait 50ms between calls to Read_platform
int timeLimit = 1000;
int count = 0;
do {
try {
ok = cp.Read_platform(out myPlatformState);
} catch {
Log.WriteLine("Manage called after finishing constructor, do later");
}
Thread.Sleep(timeWait); //wait 50ms
count += timeWait;
} while (! ok && count < timeLimit);
return myPlatformState;
}
protected void waitChronopicStart()
{
chronopicConnectionWin.Button_cancel.Clicked += new EventHandler(on_chronopic_cancelled);
if(currentCp == 1) {
// simulated = false;
// SqlitePreferences.Update("simulated", simulated.ToString(), false);
if(connected)
return;
}
SerialPort sp2;
SerialPort sp3;
SerialPort sp4;
string message = "";
string myPort = "";
bool success = false;
if(currentCp == 1) {
myPort = ((ChronopicPortData) cpd[0]).Port;
cpDoing = cp;
chronopicInit(out cpDoing, out sp, platformState, myPort, out message, out success);
cp = cpDoing;
if(success) {
((ChronopicPortData) cpd[0]).Connected=true;
button_connect_cp1.Sensitive = false;
image_cp1_no.Hide();
image_cp1_yes.Show();
if(isWindows) {
combo_windows1.Sensitive = false;
combo_windows2.Sensitive = true;
UtilGtk.ComboDelThisValue(combo_windows2, myPort);
combo_windows2.Active = 0; //first option
UtilGtk.ComboDelThisValue(combo_windows3, myPort);
combo_windows3.Active = 0;
UtilGtk.ComboDelThisValue(combo_windows4, myPort);
combo_windows4.Active = 0;
} else {
combo_linux1.Sensitive = false;
combo_linux2.Sensitive = true;
UtilGtk.ComboDelThisValue(combo_linux2, myPort);
combo_linux2.Active = 0; //first option
UtilGtk.ComboDelThisValue(combo_linux3, myPort);
combo_linux3.Active = 0;
UtilGtk.ComboDelThisValue(combo_linux4, myPort);
combo_linux4.Active = 0;
}
}
}
else if(currentCp == 2) {
myPort = ((ChronopicPortData) cpd[1]).Port;
cpDoing = cp2;
chronopicInit(out cpDoing, out sp2, platformState2, myPort, out message, out success);
cp2 = cpDoing;
if(success) {
((ChronopicPortData) cpd[1]).Connected=true;
button_connect_cp2.Sensitive = false;
image_cp2_no.Hide();
image_cp2_yes.Show();
if(isWindows) {
combo_windows2.Sensitive = false;
combo_windows3.Sensitive = true;
UtilGtk.ComboDelThisValue(combo_windows3, myPort);
combo_windows3.Active = 0;
UtilGtk.ComboDelThisValue(combo_windows4, myPort);
combo_windows4.Active = 0;
} else {
combo_linux2.Sensitive = false;
combo_linux3.Sensitive = true;
UtilGtk.ComboDelThisValue(combo_linux3, myPort);
combo_linux3.Active = 0;
UtilGtk.ComboDelThisValue(combo_linux4, myPort);
combo_linux4.Active = 0;
}
}
}
else if(currentCp == 3) {
myPort = ((ChronopicPortData) cpd[2]).Port;
cpDoing = cp3;
chronopicInit(out cpDoing, out sp3, platformState3, myPort, out message, out success);
cp3 = cpDoing;
if(success) {
((ChronopicPortData) cpd[2]).Connected=true;
button_connect_cp3.Sensitive = false;
image_cp3_no.Hide();
image_cp3_yes.Show();
if(isWindows) {
combo_windows3.Sensitive = false;
combo_windows4.Sensitive = true;
UtilGtk.ComboDelThisValue(combo_windows4, myPort);
combo_windows4.Active = 0;
} else {
combo_linux3.Sensitive = false;
combo_linux4.Sensitive = true;
UtilGtk.ComboDelThisValue(combo_linux4, myPort);
combo_linux4.Active = 0;
}
}
}
else if(currentCp == 4) {
myPort = ((ChronopicPortData) cpd[3]).Port;
cpDoing = cp4;
chronopicInit(out cpDoing, out sp4, platformState4, myPort, out message, out success);
cp4 = cpDoing;
if(success) {
((ChronopicPortData) cpd[3]).Connected=true;
button_connect_cp4.Sensitive = false;
image_cp4_no.Hide();
image_cp4_yes.Show();
if(isWindows)
combo_windows4.Sensitive = false;
else
combo_linux4.Sensitive = false;
}
}
Log.WriteLine(string.Format("wait_chronopic_start {0}", message));
if(success) {
Util.PlaySound(Constants.SoundTypes.GOOD, volumeOn);
updateChronopicWinValuesState= true; //connected
updateChronopicWinValuesMessage= message;
} else {
Util.PlaySound(Constants.SoundTypes.BAD, volumeOn);
updateChronopicWinValuesState= false; //disconnected
updateChronopicWinValuesMessage= message;
}
foreach(ChronopicPortData a in cpd)
Log.WriteLine(a.Num + ", " + a.Port + ", " + a.Connected);
fakeWindowDone.Click();
needUpdateChronopicWin = true;
}
protected void waitEvent(Chronopic myCP, Chronopic.Plataforma myPS, States myLS, out string inStr, out string outStr, int cpNum)
{
double timestamp = 0;
bool success = false;
bool ok;
string inEqual = "";
string outEqual = "";
inStr = ""; outStr = "";
int runAnalysisTcCount = 0;
int runAnalysisTfCount = 0;
bool isFirstOut = true;
bool isFirstIn = true;
syncStates syncing = syncStates.DONE;
if(syncFirst) {
syncing = syncStates.NOTHING;
feedbackMessage = Catalog.GetString("Press and mantain Test button in all Chronopics simultaneously.");
needShowFeedbackMessage = true;
}
do {
ok = myCP.Read_event(out timestamp, out myPS);
//if chronopic signal is Ok and state has changed
if (ok && (
(myPS == Chronopic.Plataforma.ON && myLS == States.OFF) ||
(myPS == Chronopic.Plataforma.OFF && myLS == States.ON) )
&& !cancel && !finish) {
//while no finished time or jumps, continue recording events
if ( ! success) {
//don't record the time until the first event of the first Chronopic
//this is only executed on the first chronopic that receives a change
if (firstValue) {
firstValue = false;
initializeTimer(); //this is for first Chronopic and only for simulated
feedbackMessage = "";
needShowFeedbackMessage = true;
}
if(syncing == syncStates.NOTHING && myPS == Chronopic.Plataforma.ON && myLS == States.OFF) {
syncing = syncStates.CONTACTED;
feedbackMessage = Catalog.GetString("Release Test button in all Chronopics simultaneously.");
needShowFeedbackMessage = true;
}
else if (syncing == syncStates.CONTACTED && myPS == Chronopic.Plataforma.OFF && myLS == States.ON) {
syncing = syncStates.DONE;
feedbackMessage = Catalog.GetString("Synchronization done.") + "\n" +
Catalog.GetString("Test starts now.");
needShowFeedbackMessage = true;
}
else {
if(type != Constants.RunAnalysisName)
needSensitiveButtonFinish = true;
if(myPS == Chronopic.Plataforma.ON && myLS == States.OFF) {
//this is for runAnalysis, delete first tf on 2nd cp (jump cp)
if(cpNum == 2 && type == Constants.RunAnalysisName && runAnalysisTfCount == 0)
runAnalysisTfCount ++;
//this is for multiChronopic, not for runAnalysis
else if(deleteFirst && isFirstOut)
isFirstOut = false;
else {
double lastOut = timestamp/1000.0;
Log.WriteLine(cpNum.ToString() + " landed: " + lastOut.ToString());
outStr = outStr + outEqual + lastOut.ToString();
outEqual = "=";
}
/*
if it's a runAnalysis,
should end when arrive at 2n photocell (controlled by cp1)
*/
if(cpNum == 1 && type == Constants.RunAnalysisName) {
runAnalysisTcCount ++;
if(runAnalysisTcCount >= 2) {
success = true;
//better call also finish
//then all cps know about ending
finish = true;
}
}
}
else if(myPS == Chronopic.Plataforma.OFF && myLS == States.ON) {
//this is for multiChronopic, not for runAnalysis
if(deleteFirst && isFirstIn)
isFirstIn = false;
else {
double lastIn = timestamp/1000.0;
Log.WriteLine(cpNum.ToString() + " jumped: " + lastIn.ToString());
inStr = inStr + inEqual + lastIn.ToString();
inEqual = "=";
}
}
PrepareEventGraphMultiChronopicObject = new PrepareEventGraphMultiChronopic(
//timestamp/1000.0,
cp1StartedIn, cp2StartedIn, cp3StartedIn, cp4StartedIn,
cp1InStr, cp1OutStr, cp2InStr, cp2OutStr,
cp3InStr, cp3OutStr, cp4InStr, cp4OutStr);
needUpdateGraphType = eventType.MULTICHRONOPIC;
needUpdateGraph = true;
updateProgressBar = new UpdateProgressBar (
true, //isEvent
false, //means activity mode
-1 //don't show text
);
needUpdateEventProgressBar = true;
}
}
if(myPS == Chronopic.Plataforma.OFF)
myLS = States.OFF;
else
myLS = States.ON;
}
} while ( ! success && ! cancel && ! finish );
if (finish) {
finishThisCp(cpNum);
//call write on gui/chronojump.cs, because if done in execute/MultiChronopic,
//will be called n times if n chronopics are working
//write(false); //tempTable
//event will be raised, and managed in chronojump.cs
//only one call (that comes from first chronopic)
if(cpNum == 1)
fakeButtonFinished.Click();
}
if(cancel) {
//event will be raised, and managed in chronojump.cs
fakeButtonFinished.Click();
cancelThisCp(cpNum);
}
}
//chronopic init should not touch gtk, for the threads
public bool Do(int currentCp, out Chronopic myCp, out SerialPort mySp, Chronopic.Plataforma myPS, string myPort, out string returnString, out bool success)
{
LogB.Information("starting connection with chronopic");
CancelledByUser = false;
success = true;
LogB.Information("chronopicInit-1");
LogB.Information(string.Format("chronopic port: {0}", myPort));
mySp = new SerialPort(myPort);
try {
mySp.Open();
LogB.Information("chronopicInit-2");
//-- Create chronopic object, for accessing chronopic
myCp = new Chronopic(mySp);
LogB.Information("chronopicInit-2.1");
myCp.Flush();
//if myCp has been cancelled
if(myCp.AbortFlush) {
LogB.Information("chronopicInit-2.2 cancelled");
success = false;
myCp = new Chronopic(); //fake constructor
} else {
LogB.Information("chronopicInit-3");
//on windows, this check make a crash
//i think the problem is: as we don't really know the Timeout on Windows (.NET) and this variable is not defined on chronopic.cs
//the Read_platform comes too much soon (when cp is not totally created), and this makes crash
//-- Obtener el estado inicial de la plataforma
bool ok=false;
LogB.Information("chronopicInit-4");
do {
LogB.Information("chronopicInit-5");
ok = myCp.Read_platform(out myPS);
LogB.Information("chronopicInit-6");
} while(! ok && ! CancelledByUser);
LogB.Information("chronopicInit-7");
if (!ok) {
//-- Si hay error terminar
LogB.Error(string.Format("Error: {0}", myCp.Error));
success = false;
}
}
} catch {
LogB.Error("chronopicInit-2.a catched");
success = false;
myCp = new Chronopic(); //fake constructor
}
bool connected = false;
returnString = "";
if(success) {
if(currentCp == 1)
connected = true;
returnString = string.Format(Catalog.GetString("<b>Connected</b> to Chronopic on port: {0}"), myPort);
}
else {
returnString = Catalog.GetString("Problems communicating to chronopic.");
if(currentCp == 1) {
returnString += " " + Catalog.GetString("Changed platform to 'Simulated'");
returnString += Catalog.GetString("\n\nWe recommend to remove and connect USB cable.");
}
//this will raise on_radiobutton_simulated_ativate and
//will put cpRunning to false, and simulated to true and cp.Close()
if(currentCp == 1) {
connected = false;
}
}
return connected;
}
//***************************************
// METODOS PRIVADOS
//***************************************
//-- Apertura del puerto serie
private int Open(string disp)
{
return(Chronopic.open(disp));
}
protected void waitEvent(Chronopic myCP, Chronopic.Plataforma myPS, States myLS, out string inStr, out string outStr, int cpNum)
{
double timestamp = 0;
bool success = false;
bool ok;
string inEqual = "";
string outEqual = "";
inStr = ""; outStr = "";
int runAnalysisTcCount = 0;
int runAnalysisTfCount = 0;
bool isFirstOut = true;
bool isFirstIn = true;
syncStates syncing = syncStates.DONE;
if (syncFirst)
{
syncing = syncStates.NOTHING;
feedbackMessage = Catalog.GetString("Press and maintain Test button in all Chronopics simultaneously.");
needShowFeedbackMessage = true;
}
do
{
ok = myCP.Read_event(out timestamp, out myPS);
//if chronopic signal is Ok and state has changed
if (ok && (
(myPS == Chronopic.Plataforma.ON && myLS == States.OFF) ||
(myPS == Chronopic.Plataforma.OFF && myLS == States.ON)) &&
!cancel && !finish)
{
//while no finished time or jumps, continue recording events
if (!success)
{
//don't record the time until the first event of the first Chronopic
//this is only executed on the first chronopic that receives a change
if (firstValue)
{
firstValue = false;
initializeTimer(); //this is for first Chronopic and only for simulated
feedbackMessage = "";
needShowFeedbackMessage = true;
}
if (syncing == syncStates.NOTHING && myPS == Chronopic.Plataforma.ON && myLS == States.OFF)
{
syncing = syncStates.CONTACTED;
feedbackMessage = Catalog.GetString("Release Test button in all Chronopics simultaneously.");
needShowFeedbackMessage = true;
}
else if (syncing == syncStates.CONTACTED && myPS == Chronopic.Plataforma.OFF && myLS == States.ON)
{
syncing = syncStates.DONE;
feedbackMessage = Catalog.GetString("Synchronization done.") + "\n" +
Catalog.GetString("Test starts now.");
needShowFeedbackMessage = true;
}
else
{
if (type != Constants.RunAnalysisName)
{
needSensitiveButtonFinish = true;
}
if (myPS == Chronopic.Plataforma.ON && myLS == States.OFF)
{
//this is for runAnalysis, delete first tf on 2nd cp (jump cp)
if (cpNum == 2 && type == Constants.RunAnalysisName && runAnalysisTfCount == 0)
{
runAnalysisTfCount++;
}
//this is for multiChronopic, not for runAnalysis
else if (deleteFirst && isFirstOut)
{
isFirstOut = false;
}
else
{
double lastOut = timestamp / 1000.0;
LogB.Information(cpNum.ToString() + " landed: " + lastOut.ToString());
outStr = outStr + outEqual + lastOut.ToString();
outEqual = "=";
}
/*
* if it's a runAnalysis,
* should end when arrive at 2n photocell (controlled by cp1)
*/
if (cpNum == 1 && type == Constants.RunAnalysisName)
{
runAnalysisTcCount++;
if (runAnalysisTcCount >= 2)
{
success = true;
//better call also finish
//then all cps know about ending
finish = true;
}
}
}
else if (myPS == Chronopic.Plataforma.OFF && myLS == States.ON)
{
//this is for multiChronopic, not for runAnalysis
if (deleteFirst && isFirstIn)
{
isFirstIn = false;
}
else
{
double lastIn = timestamp / 1000.0;
LogB.Information(cpNum.ToString() + " jumped: " + lastIn.ToString());
inStr = inStr + inEqual + lastIn.ToString();
inEqual = "=";
}
}
PrepareEventGraphMultiChronopicObject = new PrepareEventGraphMultiChronopic(
//timestamp/1000.0,
cp1StartedIn, cp2StartedIn, cp3StartedIn, cp4StartedIn,
cp1InStr, cp1OutStr, cp2InStr, cp2OutStr,
cp3InStr, cp3OutStr, cp4InStr, cp4OutStr);
needUpdateGraphType = eventType.MULTICHRONOPIC;
needUpdateGraph = true;
updateProgressBar = new UpdateProgressBar(
true, //isEvent
false, //means activity mode
-1 //don't show text
);
needUpdateEventProgressBar = true;
}
}
if (myPS == Chronopic.Plataforma.OFF)
{
myLS = States.OFF;
}
else
{
myLS = States.ON;
}
}
} while (!success && !cancel && !finish);
if (finish)
{
finishThisCp();
//call write on gui/chronojump.cs, because if done in execute/MultiChronopic,
//will be called n times if n chronopics are working
//write(false); //tempTable
}
}
protected void waitChronopicStart()
{
if (currentCp == 1)
{
// simulated = false;
// SqlitePreferences.Update("simulated", simulated.ToString(), false);
if (connected)
{
return;
}
}
SerialPort sp2;
SerialPort sp3;
SerialPort sp4;
string message = "";
string myPort = "";
bool success = false;
if (currentCp == 1)
{
myPort = ((ChronopicPortData)cpd[0]).Port;
cpDoing = cp;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp, platformState, myPort, out message, out success);
cp = cpDoing;
if (success)
{
connectionSucceded(1, true);
}
}
else if (currentCp == 2)
{
myPort = ((ChronopicPortData)cpd[1]).Port;
cpDoing = cp2;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp2, platformState2, myPort, out message, out success);
cp2 = cpDoing;
if (success)
{
connectionSucceded(2, true);
}
}
else if (currentCp == 3)
{
myPort = ((ChronopicPortData)cpd[2]).Port;
cpDoing = cp3;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp3, platformState3, myPort, out message, out success);
cp3 = cpDoing;
if (success)
{
connectionSucceded(3, true);
}
}
else if (currentCp == 4)
{
myPort = ((ChronopicPortData)cpd[3]).Port;
cpDoing = cp4;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp4, platformState4, myPort, out message, out success);
cp4 = cpDoing;
if (success)
{
connectionSucceded(4, true);
}
}
LogB.Information(string.Format("wait_chronopic_start {0}", message));
if (success)
{
Util.PlaySound(Constants.SoundTypes.GOOD, volumeOn);
updateChronopicWinValuesState = true; //connected
updateChronopicWinValuesMessage = message;
}
else
{
Util.PlaySound(Constants.SoundTypes.BAD, volumeOn);
updateChronopicWinValuesState = false; //disconnected
updateChronopicWinValuesMessage = message;
}
foreach (ChronopicPortData a in cpd)
{
LogB.Information(a.Num + ", " + a.Port + ", " + a.Connected);
}
needUpdateChronopicWin = true;
}
public ChronopicWindow(Chronopic cpDetected, ArrayList myCpd)
{
LogB.Debug("constructor");
Glade.XML gxml;
gxml = Glade.XML.FromAssembly (Util.GetGladePath() + "chronopic_window.glade", "chronopic_window", "chronojump");
gxml.Autoconnect(this);
cpd = myCpd;
if(cpDetected != null) {
cp = cpDetected;
sp = new SerialPort( ((ChronopicPortData) cpd[0]).Port );
}
UtilGtk.IconWindow(chronopic_window);
if(UtilAll.IsWindows())
isWindows = true;
else
isWindows = false;
setDefaultValues();
chronopicInit = new ChronopicInit();
//Pixbuf pixbuf = new Pixbuf (null, Util.GetImagePath(false) + "chronopic_128.png");
//chronopic_image.Pixbuf = pixbuf;
/*
Pixbuf pixbuf;
pixbuf = new Pixbuf (null, Util.GetImagePath(true) + Constants.FileNameContactPlatformModular);
image_contact_modular.Pixbuf = pixbuf;
pixbuf = new Pixbuf (null, Util.GetImagePath(true) + Constants.FileNameInfrared);
image_infrared.Pixbuf = pixbuf;
*/
/*
if(chronopicPort1 != Constants.ChronopicDefaultPortWindows &&
(chronopicPort1 != Constants.ChronopicDefaultPortLinux && File.Exists(chronopicPort1))
) {
ConfirmWindow confirmWin = ConfirmWindow.Show(Catalog.GetString("Do you want to connect to Chronopic now?"), "", "");
confirmWin.Button_accept.Clicked += new EventHandler(chronopicAtStart);
}
*/
}
/**********************/
/* PROGRAMA PRINCIPAL */
/**********************/
public static void Main()
{
Chronopic.Plataforma estado_plataforma;
Chronopic.Respuesta respuesta;
Automata estado_automata;
double timestamp;
double toff;
//-- Crear objeto chronopic, para acceder al chronopic
Chronopic cp = new Chronopic("/dev/ttyUSB0");
//-- Obtener el estado inicial de la plataforma
respuesta=cp.Read_platform(out estado_plataforma);
switch(respuesta) {
case Chronopic.Respuesta.Error:
Console.WriteLine("Error en comunicacion con Chronopic");
return;
case Chronopic.Respuesta.Timeout:
Console.WriteLine("Chronopic no responde");
return;
default:
break;
}
Console.WriteLine("Estado plataforma: {0}",estado_plataforma);
//-- Establecer el estado inicial del automata
if (estado_plataforma==Chronopic.Plataforma.ON)
estado_automata=Automata.ON;
else {
Console.WriteLine("Suba a la plataforma para realizar el salto");
//-- Esperar a que llegue una trama con el estado de la plataforma
//-- igual a ON. Esto indica que el usuario se ha subido
do {
respuesta = cp.Read_event(out timestamp, out estado_plataforma);
} while (respuesta!=Chronopic.Respuesta.Ok);
//-- Se han subido a la plataforma
estado_automata = Automata.ON;
}
Console.WriteLine("");
Console.WriteLine("Puede saltar cuando quiera");
Console.WriteLine("Pulse control-c para finalizar la sesion");
Console.WriteLine("-----------------------------------------");
while(true) {
//-- Esperar a que llegue una trama
do {
respuesta = cp.Read_event(out timestamp, out estado_plataforma);
} while (respuesta!=Chronopic.Respuesta.Ok);
//-- Segun el estado del automata
switch(estado_automata) {
case Automata.OFF: //-- Usuario estaba en el aire
//-- Si ha aterrizado
if (estado_plataforma==Chronopic.Plataforma.ON) {
//-- Pasar al estado ON
estado_automata=Automata.ON;
//-- Registrar tiempo de vuelo
toff = timestamp;
//-- Imprimir informacion
Console.WriteLine("Tiempo: {0:f1} ms",toff);
}
break;
case Automata.ON: //-- Usuario estaba en la plataforma
//-- Si ahora esta en el aire...
if (estado_plataforma==Chronopic.Plataforma.OFF) {
//-- Pasar al estado OFF
estado_automata=Automata.OFF;
}
break;
}
}
}
//***************************************
// METODOS PUBLICOS
//***************************************
//----------------------------
//-- Cerrar el puerto serie
//----------------------------
public void Close()
{
Chronopic.close(this.serial_fd);
this.serial_fd = -1;
}
protected override void waitEvent()
{
double timestamp = 0;
double timestampFirstContact = 0; //used when runPhase == runPhases.PLATFORM_INI_YES_TIME;
double timestampDCFlightTimes = -1; //sum of the flight times that happen in small time
double timestampDCContactTimes = -1; //sum of the contact times that happen in small time
double timestampDCn = 0; //number of flight times
bool success = false;
bool ok;
//prepare variables to allow being cancelled or finished
if (!simulated)
{
Chronopic.InitCancelAndFinish();
}
do
{
if (simulated)
{
ok = true;
}
else
{
ok = cp.Read_event(out timestamp, out platformState);
}
//if (ok) {
if (ok && !cancel)
{
//LogB.Information("timestamp:" + timestamp);
if (platformState == Chronopic.Plataforma.ON && loggedState == States.OFF)
{
//has arrived
loggedState = States.ON;
if (runPhase == runPhases.PRE_RUNNING)
{
if (speedStartArrival)
{
runPhase = runPhases.PLATFORM_INI_YES_TIME;
initializeTimer(); //timerCount = 0
}
else
{
runPhase = runPhases.PLATFORM_INI_NO_TIME;
}
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //tracksLimited: percentageMode
1 //just reached platform, phase 1/3
);
needUpdateEventProgressBar = true;
}
else
{
//run finished:
//if started outside (behind platform) it's the second arrive
//if started inside: it's the first arrive
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
//prevent double contact stuff
if (checkDoubleContactMode != Constants.DoubleContact.NONE)
{
if (timestamp <= checkDoubleContactTime)
{
/*
* when checking double contact
* first time that timestamp < checkDoubleContactTime
* and we arrived (it's a flight time)
* record this time as timestampDCFlightTimes
*/
timestampDCn++;
timestampDCFlightTimes += timestamp;
}
else
{
if (timestampDCn > 0)
{
if (checkDoubleContactMode ==
Constants.DoubleContact.FIRST)
{
/* user want first flight time,
* then add all DC times*/
timestamp += timestampDCFlightTimes +
timestampDCContactTimes;
}
else if (checkDoubleContactMode ==
Constants.DoubleContact.LAST)
{
//user want last flight time, take that
// It doesn't change the timestamp so this is the same as:
// timestamp = timestamp;
}
else /* do the avg of all flights and contacts
* then add to last timestamp */
{
timestamp +=
(timestampDCFlightTimes +
timestampDCContactTimes)
/ timestampDCn;
}
}
success = true;
}
}
if (checkDoubleContactMode == Constants.DoubleContact.NONE)
{
success = true;
}
if (success)
{
runPhase = runPhases.PLATFORM_END;
//add the first contact time if PLATFORM_INI_YES_TIME
if (timestampFirstContact > 0)
{
timestamp += timestampFirstContact;
}
time = timestamp / 1000.0;
write();
//success = true;
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
//percentageToPass
3
);
needUpdateEventProgressBar = true;
}
}
}
else if (platformState == Chronopic.Plataforma.OFF && loggedState == States.ON)
{
//it's out, was inside (= has abandoned platform)
//don't record time
//change the automata state
loggedState = States.OFF;
if (checkDoubleContactMode != Constants.DoubleContact.NONE && timestampDCn > 0)
{
timestampDCContactTimes += timestamp;
}
else
{
if (runPhase == runPhases.PLATFORM_INI_YES_TIME)
{
timestampFirstContact = timestamp;
}
else if (runPhase == runPhases.PLATFORM_INI_NO_TIME)
{
initializeTimer(); //timerCount = 0
}
//update event progressbar
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //percentageMode
2 //normal run, phase 2/3
);
needUpdateEventProgressBar = true;
feedbackMessage = "";
needShowFeedbackMessage = true;
runPhase = runPhases.RUNNING;
}
}
}
} while (!success && !cancel);
}
//this is called on AutoDetect
public static ChronopicWindow Create(Chronopic cpDetected, ArrayList myCpd, string myEncoderPort, bool recreate, bool volumeOn)
{
LogB.Debug("enter create");
if (ChronopicWindowBox != null && recreate) {
ChronopicWindowBox.chronopic_window.Hide();
}
if (ChronopicWindowBox == null || recreate) {
ChronopicWindowBox = new ChronopicWindow (cpDetected, myCpd);
}
LogB.Information("create cp is null? " + (ChronopicWindowBox.cp == null).ToString());
//don't show until View is called
//ChronopicWindowBox.chronopic_window.Show ();
ChronopicWindowBox.volumeOn = volumeOn;
ChronopicWindowBox.setEncoderPort(myEncoderPort);
ChronopicWindowBox.fakeWindowDone = new Gtk.Button();
//ChronopicWindowBox.fakeWindowReload = new Gtk.Button();
return ChronopicWindowBox;
}
protected override void waitEvent()
{
double timestamp = 0;
bool success = false;
string equal = "";
//initialize variables
intervalTimesString = "";
tracks = 0;
bool ok;
timerCount = 0;
//bool initialized = false;
int countForSavingTempTable = 0;
lastTc = 0;
distanceIntervalFixed = distanceInterval;
double timestampDCFlightTimes = -1; //sum of the flight times that happen in small time
double timestampDCContactTimes = -1; //sum of the contact times that happen in small time
double timestampDCn = 0; //number of flight times
//prepare variables to allow being cancelled or finished
if (!simulated)
{
Chronopic.InitCancelAndFinish();
}
do
{
if (simulated)
{
ok = true;
}
else
{
ok = cp.Read_event(out timestamp, out platformState);
}
if (ok && !cancel && !finish)
{
if (distanceInterval == -1)
{
distanceIntervalFixed = Util.GetRunIVariableDistancesStringRow(distancesString, (int)tracks);
}
if (platformState == Chronopic.Plataforma.ON && loggedState == States.OFF)
{
//has arrived
loggedState = States.ON;
//show RSA count down only on air
needShowCountDown = false;
//if we start out, and we arrive to the platform for the first time,
//don't record nothing
if (runPhase == runPhases.PRE_RUNNING)
{
if (speedStartArrival)
{
runPhase = runPhases.PLATFORM_INI_YES_TIME;
//run starts
initializeTimer(); //timerCount = 0
}
else
{
runPhase = runPhases.PLATFORM_INI_NO_TIME;
}
feedbackMessage = "";
needShowFeedbackMessage = true;
}
else
{
runPhase = runPhases.RUNNING;
//has arrived and not in the "running previous"
//if interval run is "unlimited" not limited by tracks, nor time,
//then play with the progress bar until finish button is pressed
if (simulated)
{
timestamp = simulatedTimeLast * 1000; //conversion to milliseconds
}
if (checkDoubleContactMode != Constants.DoubleContact.NONE)
{
if (timestamp <= checkDoubleContactTime)
{
/*
* when checking double contact
* first time that timestamp < checkDoubleContactTime
* and we arrived (it's a flight time)
* record this time as timestampDCFlightTimes
*/
timestampDCn++;
timestampDCFlightTimes += timestamp;
continue;
}
else
{
if (timestampDCn > 0)
{
if (checkDoubleContactMode ==
Constants.DoubleContact.FIRST)
{
/* user want first flight time,
* then add all DC times*/
timestamp += timestampDCFlightTimes +
timestampDCContactTimes;
}
else if (checkDoubleContactMode ==
Constants.DoubleContact.LAST)
{
//user want last flight time, take that
// so we don't need to change timestamp. Or we could do (it triggers a warning):
// timestamp = timestamp;
}
else /* do the avg of all flights and contacts
* then add to last timestamp */
{
timestamp +=
(timestampDCFlightTimes +
timestampDCContactTimes)
/ timestampDCn;
}
}
}
}
double myRaceTime = lastTc + timestamp / 1000.0;
if (intervalTimesString.Length > 0)
{
equal = "=";
}
intervalTimesString = intervalTimesString + equal + myRaceTime.ToString();
updateTimerCountWithChronopicData(intervalTimesString);
tracks++;
//save temp table if needed
countForSavingTempTable++;
if (countForSavingTempTable == timesForSavingRepetitive)
{
writeRunInterval(true); //tempTable
countForSavingTempTable = 0;
}
if (limitAsDouble == -1)
{
//has arrived, unlimited
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //unlimited: activity mode
tracks
);
needUpdateEventProgressBar = true;
}
else
{
//has arrived, limited
if (tracksLimited)
{
//has arrived, limited by tracks
if (tracks >= limitAsDouble)
{
runPhase = runPhases.PLATFORM_END;
//finished
writeRunInterval(false); //tempTable = false
success = true;
}
//progressBarEventOrTimePreExecution(
updateProgressBar = new UpdateProgressBar(
true, //isEvent
true, //tracksLimited: percentageMode
tracks
);
needUpdateEventProgressBar = true;
}
else
{
//has arrived, limited by time
updateProgressBar = new UpdateProgressBar(
true, //isEvent
false, //timeLimited: activity mode
tracks
);
needUpdateEventProgressBar = true;
}
}
distanceTotal = Util.GetRunITotalDistance(distanceInterval, distancesString, tracks);
//update graph
PrepareEventGraphRunIntervalObject = new PrepareEventGraphRunInterval(
distanceIntervalFixed, myRaceTime, intervalTimesString,
distanceTotal, distancesString, startIn);
needUpdateGraphType = eventType.RUNINTERVAL;
needUpdateGraph = true;
//put button_finish as sensitive when first jump is done (there's something recordable)
if (tracks == 1)
{
needSensitiveButtonFinish = true;
}
}
}
else if (platformState == Chronopic.Plataforma.OFF && loggedState == States.ON)
{
//it's out, was inside (= has abandoned platform)
if (runPhase == runPhases.PLATFORM_INI_NO_TIME)
{
//run starts
initializeTimer();
lastTc = 0;
feedbackMessage = "";
needShowFeedbackMessage = true;
}
else if (runPhase == runPhases.PLATFORM_INI_YES_TIME)
{
lastTc = timestamp / 1000.0;
feedbackMessage = "";
needShowFeedbackMessage = true;
}
else
{
if (checkDoubleContactMode != Constants.DoubleContact.NONE && timestampDCn > 0)
{
timestampDCContactTimes += timestamp;
}
else
{
lastTc = timestamp / 1000.0;
}
//RSA
double RSAseconds = Util.GetRunIVariableDistancesThisRowIsRSA(
distancesString, Convert.ToInt32(tracks));
if (RSAseconds > 0)
{
RSABellDone = false;
needShowCountDown = true;
}
else
{
needShowCountDown = false;
feedbackMessage = "";
needShowFeedbackMessage = true;
}
}
runPhase = runPhases.RUNNING;
//change the automata state
loggedState = States.OFF;
}
}
} while (!success && !cancel && !finish);
if (finish)
{
runPhase = runPhases.PLATFORM_END;
//write();
//write only if there's a run at minimum
if (Util.GetNumberOfJumps(intervalTimesString, false) >= 1)
{
writeRunInterval(false); //tempTable = false
}
else
{
//cancel a run if clicked finish before any events done, or ended by time without events
cancel = true;
}
}
}
/**********************/
/* PROGRAMA PRINCIPAL */
/**********************/
public static void Main(string[] args)
{
Chronopic.Plataforma estado_plataforma;
Automata estado_automata;
double timestamp;
double toff;
double ton;
bool ok;
string portName = "";
string fileName = "";
TextWriter writer;
//always output to a file, but if not specified, output here and rewrite it every chronojump_mini execution
string defaultFileName = Path.Combine(getOutputDir(), "output");
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("es-ES");
System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("es-ES");
//connect with catalog.cs for using gettext translation
Catalog.Init ("chronojump", "./locale");
//parameters passing only on linux
if(! UtilAll.IsWindows()) {
if(args.Length > 2)
printSyntaxAndQuit();
for( int i = 0; i != args.Length; ++i ) {
Console.WriteLine("param[{0}]: {1}", i, args[i]);
if(args[i].StartsWith("PORT="))
portName = args[i].Substring(5);
else if (args[i].StartsWith("FILE=")) {
fileName = args[i].Substring(5);
fileName= getOutputDir() + Path.DirectorySeparatorChar + fileName;
}
else
printSyntaxAndQuit();
}
}
//detection of ports
string messageInfo;
//string messageDetected ="";
if(UtilAll.IsWindows()) {
messageInfo = Constants.PortNamesWindows;
/*
messageDetected = Catalog.GetString("Detected ports:") + "\n";
string jumpLine = "";
foreach (string s in SerialPort.GetPortNames()) {
messageDetected += jumpLine + s;
jumpLine = "\n";
}
*/
} else {
messageInfo = Constants.PortNamesLinux;
}
messageInfo += string.Format("\n" + Catalog.GetString("More information on Chronojump manual"));
Console.WriteLine("---------------------------");
Console.WriteLine(messageInfo);
Console.WriteLine("---------------------------");
if(portName == "") {
if( ! UtilAll.IsWindows()) {
Console.WriteLine(UtilAll.DetectPortsLinux(false)); //formatting
}
Console.WriteLine(Catalog.GetString("Print the port name where chronopic is connected:"));
portName=Console.ReadLine();
}
//output file stuff
fileName = manageFileName(fileName);
if(fileName == "")
fileName = defaultFileName + "-" + portName.Replace("/","") + ".csv";
writer = File.CreateText(fileName);
Console.WriteLine(Catalog.GetString("Opening port...") + " " +
Catalog.GetString("Please touch the platform or click Chronopic TEST button"));
//-- Crear puerto serie
SerialPort sp;
sp = new SerialPort(portName);
//-- Abrir puerto serie. Si ocurre algun error
//-- Se lanzara una excepcion
try {
sp.Open();
} catch (Exception e){
Console.WriteLine(Catalog.GetString("Error opening serial port"));
Console.WriteLine(e);
Environment.Exit(1);
}
//-- Crear objeto chronopic, para acceder al chronopic
Chronopic cp = new Chronopic(sp);
cp.Flush();
//-- Obtener el estado inicial de la plataforma
// this do...while is here because currently there's no timeout on chronopic.cs on windows
do {
ok=cp.Read_platform(out estado_plataforma);
} while(!ok);
if (!ok) {
//-- Si hay error terminar
Console.WriteLine(string.Format(Catalog.GetString("Error: {0}"),cp.Error));
System.Environment.Exit(-1);
}
Console.WriteLine(string.Format(Catalog.GetString("Platform state: {0}"), estado_plataforma));
//Console.WriteLine("Automatic variables: ");
//cp.Read_variables_automatic();
//-- Establecer el estado inicial del automata
if (estado_plataforma==Chronopic.Plataforma.ON)
estado_automata=Automata.ON;
else {
Console.WriteLine(Catalog.GetString("Go up platform for jumping"));
//-- Esperar a que llegue una trama con el estado de la plataforma
//-- igual a ON. Esto indica que el usuario se ha subido
do {
ok = cp.Read_event(out timestamp, out estado_plataforma);
} while (!ok);
//-- Se han subido a la plataforma
estado_automata = Automata.ON;
}
Console.WriteLine("");
Console.WriteLine(Catalog.GetString("Jump when prepared"));
Console.WriteLine(Catalog.GetString("Press CTRL-c for ending session"));
Console.WriteLine("-----------------------------------------");
double count = 1.0;
Console.WriteLine(" TC(ms) TF(ms)");
writer.WriteLine("count;TC(ms);TF(ms)");
while(true) {
//-- Esperar a que llegue una trama
do {
ok = cp.Read_event(out timestamp, out estado_plataforma);
} while (ok==false);
//-- Segun el estado del automata
switch(estado_automata) {
case Automata.OFF: //-- Usuario estaba en el aire
//-- Si ha aterrizado
if (estado_plataforma==Chronopic.Plataforma.ON) {
//-- Pasar al estado ON
estado_automata=Automata.ON;
//-- Registrar tiempo de vuelo
toff = timestamp;
//-- Imprimir informacion
Console.WriteLine("{0:f1}",toff);
writer.WriteLine("{0:f1}",toff);
}
break;
case Automata.ON: //-- Usuario estaba en la plataforma
//-- Si ahora esta en el aire...
if (estado_plataforma==Chronopic.Plataforma.OFF) {
//-- Pasar al estado OFF
estado_automata=Automata.OFF;
//-- Registrar tiempo de contacto
ton = timestamp;
//-- Imprimir informacion
Console.Write(count + " {0:f1} ",ton);
writer.Write(count + ";{0:f1};",ton);
}
break;
}
writer.Flush();
count += .5;
}
}
protected void waitChronopicStart()
{
if(currentCp == 1) {
// simulated = false;
// SqlitePreferences.Update("simulated", simulated.ToString(), false);
if(connected)
return;
}
SerialPort sp2;
SerialPort sp3;
SerialPort sp4;
string message = "";
string myPort = "";
bool success = false;
if(currentCp == 1) {
myPort = ((ChronopicPortData) cpd[0]).Port;
cpDoing = cp;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp, platformState, myPort, out message, out success);
cp = cpDoing;
if(success)
connectionSucceded(1, true);
}
else if(currentCp == 2) {
myPort = ((ChronopicPortData) cpd[1]).Port;
cpDoing = cp2;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp2, platformState2, myPort, out message, out success);
cp2 = cpDoing;
if(success)
connectionSucceded(2, true);
}
else if(currentCp == 3) {
myPort = ((ChronopicPortData) cpd[2]).Port;
cpDoing = cp3;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp3, platformState3, myPort, out message, out success);
cp3 = cpDoing;
if(success)
connectionSucceded(3, true);
}
else if(currentCp == 4) {
myPort = ((ChronopicPortData) cpd[3]).Port;
cpDoing = cp4;
connected = chronopicInit.Do(currentCp, out cpDoing, out sp4, platformState4, myPort, out message, out success);
cp4 = cpDoing;
if(success)
connectionSucceded(4, true);
}
LogB.Information(string.Format("wait_chronopic_start {0}", message));
if(success) {
Util.PlaySound(Constants.SoundTypes.GOOD, volumeOn);
updateChronopicWinValuesState= true; //connected
updateChronopicWinValuesMessage= message;
} else {
Util.PlaySound(Constants.SoundTypes.BAD, volumeOn);
updateChronopicWinValuesState= false; //disconnected
updateChronopicWinValuesMessage= message;
}
foreach(ChronopicPortData a in cpd)
LogB.Information(a.Num + ", " + a.Port + ", " + a.Connected);
needUpdateChronopicWin = true;
}