public Task(IDataBindEngineClient c, TaskOps o, Task previousForClient)
{
client = c;
op = o;
PreviousForClient = previousForClient;
status = Status.Pending;
}
/// <summary>
/// Start a constant output by the DAQ device. This function starts a task named "OutputTask",
/// Don't forget to stop it when it's no longer needed.
/// </summary>
/// <param name="voltage">the requested voltage to apply</param>
public void StartConstantOutputTask(double voltage)
{
int samplesPerChannel = 2500;
int sampleRate = 2500;
//
// generate output array
//
m_functionGenerator = new FunctionGenerator(samplesPerChannel, voltage, voltage);
//
// get the properties required for the output task
//
ContinuousAOTaskProperties outputProperties = new ContinuousAOTaskProperties(null, sampleRate, samplesPerChannel, voltage);
//
// create the output task
//
m_outputTask = m_daqController.CreateContinuousAOTask(outputProperties);
//
// create the writer of the output task
//
writer = new AnalogSingleChannelWriter(m_outputTask.Stream);
//
// write static voltage
//
writer.WriteMultiSample(true, m_functionGenerator.ConstWave);
}
/*
* Delete a Task
*
* @param: TaskDeleted : a callback
* @param: tasklist : string
* @param: t : Task
*/
public void DeleteTask(Action<IRestResponse<Error>> TaskDeleted, string tasklist, Task t)
{
_oAuth.GetAccessCode(access_token =>
{
lock (_sync)
{
_requesting++;
// building request
_client.Authenticator = new OAuth2AuthorizationRequestHeaderAuthenticator(access_token);
var request = new RestRequest("/tasks/v1/lists/" + tasklist + "/tasks/" + t.Id, Method.DELETE);
// serialize Task
string taskJson = JsonConvert.SerializeObject(t, Formatting.None,
new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
request.AddParameter("application/json; charset=utf-8", taskJson, ParameterType.RequestBody);
LaunchTimer();
_client.ExecuteAsync<Error>(request, response =>
{
lock (_sync)
{
_requesting--;
// handle request's callback
ObservableCollection<Task> tasks = null;
_tasks.TryGetValue(tasklist, out tasks);
if (tasks != null && response.StatusCode == HttpStatusCode.NoContent && response.Data == null)
{
// delete the task
tasks.Remove(t);
}
if (TaskDeleted != null) TaskDeleted(response);
}
});
}
});
}
public async System.Threading.Tasks.Task TestCreateNewTask()
{
UserCredential credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
new ClientSecrets
{
ClientId = _clientId,
ClientSecret = _clientSecret
},
new[] { TasksService.Scope.Tasks },
"user",
CancellationToken.None);
var service = new TasksService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = _application
});
TaskLists lists = await service.Tasklists.List().ExecuteAsync();
Assert.IsTrue(lists.Items.Count > 0);
string listId = lists.Items[0].Id;
Task newTask = new Task()
{
Title = "Test",
};
Task result = await service.Tasks.Insert(newTask, listId).ExecuteAsync();
Assert.AreEqual(newTask.Title, result.Title);
}
public override void AcquisitionStarting()
{
// initialise the output hardware
outputTask = new Task("analog output");
if (!Environs.Debug)
{
AnalogOutputChannel oc =
(AnalogOutputChannel) Environs.Hardware.AnalogOutputChannels[(string)settings["channel"]];
oc.AddToTask(outputTask, oc.RangeLow, oc.RangeHigh);
writer = new AnalogSingleChannelWriter(outputTask.Stream);
writer.WriteSingleSample(true, 0);
}
scanParameter = 0;
//go gently to the correct start position
if ((string)settings["scanMode"] == "up" || (string)settings["scanMode"] == "updown")
{
if ((string)settings["flyback"] == "overshoot") rampOutputToVoltage((double)settings["overshootVoltage"]);
rampOutputToVoltage((double)settings["start"]);
}
if ((string)settings["scanMode"] == "down" || (string)settings["scanMode"] == "downup")
{
if ((string)settings["flyback"] == "overshoot") rampOutputToVoltage((double)settings["overshootVoltage"]);
rampOutputToVoltage((double)settings["end"]);
}
}
private static void PerformTask(Task t)
{
CurrentTaskId++;
int tid = CurrentTaskId;
try
{
Thread.BeginCriticalRegion(); // It is important that this task not be stopped here
MinecraftModUpdater.Logger.Log(Logger.Level.Debug, "Running Task Id: " + tid.ToString());
if (t != null)
{
t.Invoke();
MinecraftModUpdater.Logger.Log(Logger.Level.Debug, "Task " + tid.ToString() + " Done");
}
}
catch (Exception e)
{
MinecraftModUpdater.Logger.Log(Logger.Level.Error, "Error on task " + tid.ToString());
MinecraftModUpdater.Logger.Log(e);
MCModUpdaterExceptionHandler.HandleException(t, e);
}
finally
{
Thread.EndCriticalRegion(); // Thread can now be stopped.
}
}
/// <summary>
/// Gets all tasks from ProjectFile instance.
/// </summary>
/// <param name="projectFile">ProjectFile instance.</param>
/// <returns>List of tasks.</returns>
protected Task[] getAllProjectTasks(ProjectFile projectFile)
{
//get tasks
java.util.List taskList = projectFile.AllTasks;
//convert to array
object[] allTaskObjs = taskList.toArray();
//create alternate storage
Task[] allTasks = new Task[allTaskObjs.Length];
//then cast each object to a Task
for(int o = 0; o < allTaskObjs.Length; o++)
{
//cast
allTasks[o] = (Task)allTaskObjs[o];
//then nullify the initial value, be nice to your memory and it WILL return the favor
allTaskObjs[o] = null;
}
//nullify primary storage
allTaskObjs = null;
//then return the secondary list, otherwise permit a run-time exception
//this is a wild bunch of magic anyways
return allTasks;
}
//AND CAVITY VOLTAGE!!!
//The photodiode inputs have been bundled into one task. We never read one photodiode without reading
//the other.
public void ConfigureReadAI(int numberOfMeasurements, bool autostart)
{
readAIsTask = new Task("readAI");
channels = new Dictionary<string, AnalogInputChannel>();
foreach (string s in analogInputs)
{
AnalogInputChannel channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels[s];
channels.Add(s, channel);
}
foreach (KeyValuePair<string, AnalogInputChannel> pair in channels)
{
pair.Value.AddToTask(readAIsTask, 0, 10);
}
if (autostart == false)
{
readAIsTask.Timing.ConfigureSampleClock(
"",
40000,
SampleClockActiveEdge.Rising,
SampleQuantityMode.FiniteSamples, numberOfMeasurements);
readAIsTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(
(string)Environs.Hardware.GetInfo(trigger),
DigitalEdgeStartTriggerEdge.Rising);
}
readAIsTask.Control(TaskAction.Verify);
analogReader = new AnalogMultiChannelReader(readAIsTask.Stream);
}
public void Read()
{
try {
string[] channelNameList = DaqSystem.Local.GetPhysicalChannels(PhysicalChannelTypes.AI, PhysicalChannelAccess.External);
if (channelNameList.Length > 0) {
Task task = new Task();
task.AIChannels.CreateVoltageChannel(channelNameList[0], "Voltage", AITerminalConfiguration.Differential, 0.0, 10.0, AIVoltageUnits.Volts);
task.Timing.ConfigureSampleClock("", 100000, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples);
task.Control(TaskAction.Verify);
AnalogSingleChannelReader airead = new AnalogSingleChannelReader(task.Stream);
AnalogWaveform<double> waveform;
for(int i=0;i<repeat;i++){
waveform = airead.ReadWaveform(sampleRate);
datalist.AddRange(waveform.GetRawData());
Console.Out.WriteLine("Acquire " + i + "th try");
}
StreamWriter writer = new StreamWriter(File.Open("ai.txt", FileMode.Create));
int c = 0;
foreach (double d in datalist) {
writer.WriteLine(String.Format("{0} {1}",c,d));
c++;
}
writer.Close();
}
} catch (DaqException e) {
Console.Out.WriteLine(e.Message);
}
}
public async System.Threading.Tasks.Task<Task> CreateTaskAsync(Task task, string listId)
{
if (_service == null)
{
throw new Exception("Service is not initialized");
}
return await _service.Tasks.Insert(task, listId).ExecuteAsync();
}
public void Post(Task task)
{
lock (((ICollection)queue).SyncRoot)
{
queue.Add(task);
newItemEvent.Set();
}
}
public void Enqueue(Action action)
{
var task = new Task
{
TaskWithoutState = action
};
queue.Enqueue(task);
}
static void Main(string[] args)
{
Task task =new Task();
Thread thread = new Thread(task.DoWork);
thread.Start(1000);
thread.Join();
Console.WriteLine("Summ ={0}",task.Summ);
}
public void ConfigureCavityScan(int numberOfSteps, bool autostart)
{
outputCavityTask = new Task("CavityPiezoVoltage");
cavityChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[cavityChannelName];
cavityChannel.AddToTask(outputCavityTask, 0, 10);
outputCavityTask.Control(TaskAction.Verify);
cavityWriter = new AnalogSingleChannelWriter(outputCavityTask.Stream);
}
public PooledTaskRunner(Task task, int maxIterationsPerRun)
{
this.maxIterationsPerRun = maxIterationsPerRun;
this.task = task;
this._shutdown = false;
this.iterating = false;
this.queued = true;
ThreadPool.QueueUserWorkItem(new WaitCallback(Run), this);
}
public MainClass ()
{
task = new Task (this);
t = new Timer (task.go, null, 1000, 1000);
}
public void Enqueue(WaitCallback waitCallback, object state, AsyncTaskResultCallback resultCallback)
{
var task = new Task
{
WaitCallback = waitCallback,
State = state,
ResultCallback = resultCallback
};
lock (taskQueue) taskQueue.Enqueue(task);
}
public void Enqueue(Action<object> action, object state)
{
var task = new Task
{
TaskWithState = action,
State = state
};
queue.Enqueue(task);
}
//The photodiode inputs have been bundled into one task. We never read one photodiode without reading
//the other.
public void ConfigureReadPhotodiodes(int numberOfMeasurements, bool autostart)
{
readPhotodiodesTask = new Task("ReadPhotodiodes");
referenceLaserChannel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels[masterPDChannelName];
lockingLaserChannel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels[slavePDChannelName];
referenceLaserChannel.AddToTask(readPhotodiodesTask, 0, 10);
lockingLaserChannel.AddToTask(readPhotodiodesTask, 0, 10);
readPhotodiodesTask.Control(TaskAction.Verify);
photodiodesReader = new AnalogMultiChannelReader(readPhotodiodesTask.Stream);
}
public override void QueueTask(Task task)
{
lock (tasksLock)
{
DateTime executionTime = DateTime.Now;
if (!scheduledTasks.ContainsKey(executionTime))
scheduledTasks.Add(executionTime, new List<Task>());
scheduledTasks[executionTime].Add(task);
schedulerInterrupt.Set();
}
}
internal SpikeFileOutput(string filenameBase, int numChannels, double samplingRate,
int numSamplesPerWaveform, Task recordingTask, string extension, bool recordingUnits)
{
this.numChannels = numChannels;
this.numSamplesPerWaveform = numSamplesPerWaveform;
this.recordingUnits = recordingUnits;
//Create output file
outStream = createStream(filenameBase + extension, 256 * 1024);
writeHeader(numChannels, samplingRate, recordingTask);
}
public TaskRunner CreateTaskRunner(Task task, string name, ThreadPriority taskPriority)
{
if(this.dedicatedTaskRunner)
{
return new DedicatedTaskRunner(task, name, taskPriority);
}
else
{
return new PooledTaskRunner(task, this.maxIterationsPerRun);
}
}
//This takes in a voltage. A bit cheezy, but I needed the laser
// voltage to be set as soon value as soon as it gets configured.
public void ConfigureSetLaserVoltage(double voltage)
{
outputLaserTask = new Task("FeedbackToLaser" + laserChannelName);
laserChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[laserChannelName];
laserChannel.AddToTask(outputLaserTask, laserChannel.RangeLow, laserChannel.RangeHigh);
outputLaserTask.Control(TaskAction.Verify);
laserWriter = new AnalogSingleChannelWriter(outputLaserTask.Stream);
laserWriter.WriteSingleSample(true, voltage);
//outputLaserTask.Start();
}
public DedicatedTaskRunner(Task task)
{
if(task == null)
{
throw new NullReferenceException("Task was null");
}
this.task = task;
this.theThread = new Thread(Run) {IsBackground = true};
this.theThread.Start();
}
public void AddTask(Action action, Thread thread, object key)
{
Task task = new Task(action, thread, key);
lock (m_lock)
{
// Add the task to the queue
m_tasks.Enqueue(task);
}
// Inform the thread there is something to do
m_actionPending.Release();
}
public void EnsureIDidNotMessUpTasks()
{
var task = new Task("do stuff");
task.Start();
task.Stop();
task.Start();
task.Stop();
var description = task.Description;
// just make sure it doesn't blow up
}
public void StartJobAsync(Task task, TaskData taskData) {
try {
this.TaskId = task.Id;
originalTaskData = taskData;
Prepare(task);
StartTaskInAppDomain(taskData);
}
catch (Exception) {
// make sure to clean up if something went wrong
DisposeAppDomain();
throw;
}
}
public async System.Threading.Tasks.Task<Task> UpdateTaskAsync(Task task, string listId)
{
if (_service == null)
{
throw new Exception("Service is not initialized");
}
if (task.Status.Equals("needsAction"))
{
task.Completed = null;
}
return await _service.Tasks.Update(task, listId, task.Id).ExecuteAsync();
}
internal ClosedLoopOut(NRTask CLE, int fs, DataSrv DatSrv, StimSrv StimSrv, Task buffLoadTask, Logger Debugger, string NRFilePath, bool NRRecording, NeuroRighter NR)
{
this.CLE = CLE;
this.outputSampFreq = fs;
this.DatSrv = DatSrv;
this.StimSrv = StimSrv;
this.useManStimWave = false;
this.buffLoadTask = buffLoadTask;
this.Debugger = Debugger;
this.NRFilePath = NRFilePath;
this.NRRecording = NRRecording;
this.NR = NR;
}
public void WaitingTask1()
{
var cdl = new CountDownLatch(1);
var task = new Task(cdl);
var runner = new Thread(task.DoSomething);
runner.Start();
Thread.Sleep(600);
cdl.CountDown();
runner.Join();
Assert.IsTrue(task.Elapsed >= 500, "The task should cost more than 500 millis");
Assert.IsTrue(task.Elapsed <= 700, "The task should cost less than 700 millis");
}