private void HandleCommand(LJU3Commands command, object[] args) { LogLevel loglevel = LogLevel.INFO; switch (command) { case LJU3Commands.GET_CONFIG: double value = 0; LJUD.eGet(u3.ljhandle, LJUD.IO.GET_CONFIG, (LJUD.CHANNEL)args[0], ref value, 0); break; case LJU3Commands.PIN_CONFIGURATION_RESET: LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); break; case LJU3Commands.PUT_ANALOG_ENABLE_PORT: LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, (LJUD.CHANNEL)args[0], Convert.ToDouble(args[1]), (int)args[2]); break; case LJU3Commands.GET_DIGITAL_BIT: LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_DIGITAL_BIT, (LJUD.CHANNEL)args[0], Convert.ToDouble(args[1]), (int)args[2], Convert.ToDouble(args[3])); loglevel = LogLevel.RAW; break; case LJU3Commands.PUT_DIGITAL_BIT: LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL)args[0], Convert.ToDouble(args[1]), 0, 0); break; default: evth.LogMessage(this, new LogEventArgs(LogLevel.ERROR, command.ToString() + ": Unhandled Command.")); break; } evth.LogMessage(this, new LogEventArgs(loglevel, "Command executed: " + command.ToString())); }
//Function used to read and display the duty cycle from a timer. private void ReadDutyCycle(int handle, long timerNumber) { double dblValue = 0; double highTime, lowTime, dutyCycle; double dummyDouble = 0; // Satisfies method signatures but does not have any real purpose //Read from Timer. We will go ahead and reset the timer (by writing //a value of 0) at the same time as the read. This way if no new //edges occur (e.g. 0% or 100% duty cycle) the next read will return //the preset high/low times (0/65535 or 65535/0) rather than returning //the old values. LJUD.AddRequest(handle, LJUD.IO.GET_TIMER, (LJUD.CHANNEL)timerNumber, 0, 0, 0); LJUD.AddRequest(handle, LJUD.IO.PUT_TIMER_VALUE, (LJUD.CHANNEL)timerNumber, 0, 0, 0); LJUD.GoOne(handle); LJUD.GetResult(handle, LJUD.IO.PUT_TIMER_VALUE, (LJUD.CHANNEL)timerNumber, ref dummyDouble); //just to check for error LJUD.GetResult(handle, LJUD.IO.GET_TIMER, (LJUD.CHANNEL)timerNumber, ref dblValue); //High time is LSW highTime = (double)(((ulong)dblValue) % (65536)); //Low time is MSW lowTime = (double)(((ulong)dblValue) / (65536)); //Calculate the duty cycle percentage. dutyCycle = 100 * highTime / (highTime + lowTime); Console.Out.WriteLine("\nHigh clicks Timer{0:0.#} = {1:0.#}", timerNumber, highTime); Console.Out.WriteLine("Low clicks Timer{0:0.#} = {1:0.#}", timerNumber, lowTime); Console.Out.WriteLine("Duty cycle Timer{0:0.#} = {1:0.#}", timerNumber, dutyCycle); }
private void tmrPollLJ_Tick(object sender, EventArgs e) { // Read from each bicycle. Note that we want to do this in a single "GoOne" call for each labjack, otherwise things will // be much slower, since there'll be more USB requests. Because of this, we operate over each labjack individually, grouping // by handle. foreach (int thisLJHnd in bicycles.Select(x => x.labjackHandle)) { // Get bikes on this labjack. Note that we .ToArray because we must ensure ordering does not change before we .GetResult // later on. bicycle[] bikesToPoll = bicycles.Where(x => x.labjackHandle == thisLJHnd).ToArray(); // and add a request for each foreach (bicycle thisBike in bikesToPoll) { // Specify negative channel as 32, which (on the U3) will select the special 0-3.6v range LJUD.AddRequest(thisBike.labjackHandle, LJUD.IO.GET_AIN_DIFF, thisBike.FIOChannel, 0, 32, 0); } // Now we can poll this LJ LJUD.GoOne(thisLJHnd); // and get our results, which are in the same order as the bikesToPoll array. foreach (bicycle thisBike in bikesToPoll) { double newVal = 0; LJUD.GetResult(thisBike.labjackHandle, LJUD.IO.GET_AIN_DIFF, thisBike.FIOChannel, ref newVal); thisBike.onRawData(newVal); } } }
public void postXMLDeserialisation() { // Comment this out if you have a real LabJack return; if (LJDeviceHandlesBySerial.ContainsKey(labjackSerial)) { labjackHandle = LJDeviceHandlesBySerial[labjackSerial]; } else { // This labjack hasn't been opened yet, so lets do that. LJUD.OpenLabJack(LJUD.DEVICE.U3, LJUD.CONNECTION.USB, labjackSerial, false, ref labjackHandle); LJDeviceHandlesBySerial[labjackSerial] = labjackHandle; // Reset the config, in case another application has messed with it LJUD.AddRequest(labjackHandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0, 0); // Set 12-bit sampling resolution LJUD.AddRequest(labjackHandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, 12, 0, 0); } // Configure FIO channel for this bicycle as analogue input. LJUD.AddRequest(labjackHandle, LJUD.IO.PUT_ANALOG_ENABLE_BIT, FIOChannel, 1, 0, 0); }
public void outputLow() { try { //Open the first found LabJack U3. u3 = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //First some configuration commands. These will be done with the ePut //function which combines the add/go/get into a single call. //Configure FIO0-FIO3 as analog, all else as digital. That means we //will start from channel 0 and update all 16 flexible bits. We will //pass a value of b0000000000001111 or d15. //LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, 0, 15, 16); //The following commands will use the add-go-get method to group //multiple requests into a single low-level function. //Set DAC0 to 0 volts. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DAC, 0, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DAC, 1, 5, 0, 0); //Set digital output FIO2 to output-high. //LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, 1, 0, 0, 0); LJUD.GoOne(u3.ljhandle); //Set digital output FIO3 to output-low. //LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, 1, 0, 0, 0); } catch (LabJackUDException e) { ShowErrorMessage(e); } }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double highTime, lowTime; double period16 = -1, period32 = -1; // Variables that satisfy a method signature int dummyInt = 0; double dummyDouble = 0; // Open UE9 try { ue9 = new UE9(LJUD.CONNECTION.USB, "0", true); // Connection through USB //ue9 = new UE9(LJUD.CONNECTION.ETHERNET, "192.168.1.50", true); // Connection through ethernet } catch (LabJackUDException e) { showErrorMessage(e); } //Disable all timers and counters to put everything in a known initial state. //Disable the timer and counter, and the FIO lines will return to digital I/O. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 1, 0, 0, 0); LJUD.GoOne(ue9.ljhandle); //First we will output a square wave and count the number of pulses for about 1 second. //Connect a jumper on the UE9 from FIO0 (PWM output) to //FIO1 (Counter0 input). //Use the fixed 750kHz timer clock source. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, (double)LJUD.TIMERCLOCKS.KHZ750, 0, 0); //Set the divisor to 3 so the actual timer clock is 250kHz. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_DIVISOR, 3, 0, 0); //Enable 1 timer. It will use FIO0. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 1, 0, 0); //Configure Timer0 as 8-bit PWM. Frequency will be 250k/256 = 977 Hz. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, 0, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 32768, 0, 0); //Enable Counter0. It will use FIO1 since 1 timer is enabled. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 1, 0, 0); //Execute the requests on a single LabJack. The driver will use a //single low-level TimerCounter command to handle all the requests above. LJUD.GoOne(ue9.ljhandle); //Get all the results just to check for errors. try { LJUD.GetFirstResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool isFinished = false; while (!isFinished) { try { LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } try { //Wait 1 second. Thread.Sleep(1000); //Request a read from the counter. LJUD.eGet(ue9.ljhandle, LJUD.IO.GET_COUNTER, 0, ref dblValue, 0); //This should read roughly 977 counts. Console.Out.WriteLine("Counter = {0:0.0}\n\n", dblValue); //Disable the timer and counter, and the FIO lines will return to digital I/O. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 0, 0, 0); LJUD.GoOne(ue9.ljhandle); //Output a square wave and measure the period. //Connect a jumper on the UE9 from FIO0 (PWM8 output) to //FIO1 (RISINGEDGES32 input) and FIO2 (RISINGEDGES16). //Use the fixed 750kHz timer clock source. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, (double)LJUD.TIMERCLOCKS.KHZ750, 0, 0); //Set the divisor to 3 so the actual timer clock is 250kHz. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_DIVISOR, 3, 0, 0); //Enable 3 timers. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 3, 0, 0); //Configure Timer0 as 8-bit PWM. Frequency will be 250k/256 = 977 Hz. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, 0, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 32768, 0, 0); //Configure Timer1 as 32-bit period measurement. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, 1, (double)LJUD.TIMERMODE.RISINGEDGES32, 0, 0); //Configure Timer2 as 16-bit period measurement. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, 2, (double)LJUD.TIMERMODE.RISINGEDGES16, 0, 0); //Execute the requests on a single LabJack. The driver will use a //single low-level TimerCounter command to handle all the requests above. LJUD.GoOne(ue9.ljhandle); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } //Get all the results just to check for errors. try { LJUD.GetFirstResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } isFinished = false; while (!isFinished) { try { LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } //Wait 1 second. Thread.Sleep(1000); //Now read the period measurements from the 2 timers. We //will use the Add/Go/Get method so that both //reads are done in a single low-level call. //Request a read from Timer1 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.GET_TIMER, 1, 0, 0, 0); //Request a read from Timer2 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.GET_TIMER, 2, 0, 0, 0); //Execute the requests on a single LabJack. The driver will use a //single low-level TimerCounter command to handle all the requests above. LJUD.GoOne(ue9.ljhandle); //Get the results of the two read requests. LJUD.GetFirstResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); isFinished = false; while (!isFinished) { switch (ioType) { case LJUD.IO.GET_TIMER: switch ((int)channel) { case 1: period32 = dblValue; break; case 2: period16 = dblValue; break; } break; } try{ LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // After encountering a if (e.LJUDError > UE9.LJUDERROR.MIN_GROUP_ERROR) { isFinished = true; } else { showErrorMessage(e); } } } try { //Both period measurements should read about 256. The timer //clock was set to 250 kHz, so each tick equals 4 microseconds, so //256 ticks means a period of 1024 microseconds which is a frequency //of 977 Hz. Console.Out.WriteLine("Period32 = {0:0.0}\n", period32); Console.Out.WriteLine("Period16 = {0:0.0}\n\n", period16); //Disable the timer and counter, and the FIO lines will return to digital I/O. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 0, 0, 0); LJUD.GoOne(ue9.ljhandle); //Now we will output a 25% duty-cycle PWM output on Timer0 (FIO0) and measure //the duty cycle on Timer1 FIO1. Requires Control firmware V1.21 or higher. //Use the fixed 750kHz timer clock source. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, (double)LJUD.TIMERCLOCKS.KHZ750, 0, 0); //Set the divisor to 3 so the actual timer clock is 250kHz. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_DIVISOR, 3, 0, 0); //Enable 2 timers. They will use FIO0 and FIO1. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 2, 0, 0); //Configure Timer0 as 8-bit PWM. Frequency will be 250k/256 = 977 Hz. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, 0, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 25%. The passed value is the low time. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 49152, 0, 0); //Configure Timer1 as duty cycle measurement. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, 1, (double)LJUD.TIMERMODE.DUTYCYCLE, 0, 0); //Execute the requests on a single LabJack. The driver will use a //single low-level TimerCounter command to handle all the requests above. LJUD.GoOne(ue9.ljhandle); } catch (LabJackUDException e) { // After encountering a if (e.LJUDError > UE9.LJUDERROR.MIN_GROUP_ERROR) { isFinished = true; } else { showErrorMessage(e); } } //Get all the results just to check for errors. try { LJUD.GetFirstResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } isFinished = false; while (!isFinished) { try { LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } //Wait a little so we are sure a duty cycle measurement has occured. Thread.Sleep(100); try { //Request a read from Timer1. LJUD.eGet(ue9.ljhandle, LJUD.IO.GET_TIMER, (LJUD.CHANNEL) 1, ref dblValue, 0); //High time is LSW highTime = (double)(((ulong)dblValue) % (65536)); //Low time is MSW lowTime = (double)(((ulong)dblValue) / (65536)); Console.Out.WriteLine("High clicks = {0:0.0}\n", highTime); Console.Out.WriteLine("Low clicks = {0:0.0}\n", lowTime); Console.Out.WriteLine("Duty cycle = {0:0.0}\n", 100 * highTime / (highTime + lowTime)); //Disable the timers, and the FIO lines will return to digital I/O. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 0, 0, 0); LJUD.GoOne(ue9.ljhandle); //The PWM output sets FIO0 to output, so we do a read here to set //FIO0 to input. LJUD.eGet(ue9.ljhandle, LJUD.IO.GET_DIGITAL_BIT, 0, ref dblValue, 0); } catch (LabJackUDException e) { // After encountering a if (e.LJUDError > UE9.LJUDERROR.MIN_GROUP_ERROR) { isFinished = true; } else { showErrorMessage(e); } } Console.ReadLine(); // Pause for user }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblVal = 0; double ValueDIPort = 0; int intVal = 0; double val = 0; double[] ValueAIN = new double[16]; long time = 0; long numIterations = 1; int numChannels = 16; //Number of AIN channels, 0-16. long quickSample = 0; //Set to TRUE for quick AIN sampling. See section 2.6 / 3.1 of the User's Guide long longSettling = 1; //Set to TRUE for extra AIN settling time. try { //Open the first found LabJack. u3 = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //Configure quickSample. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, quickSample, 0); //Configure longSettling. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_SETTLING_TIME, longSettling, 0); //Configure the necessary lines as analog. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, 0, Math.Pow(2, numChannels) - 1, numChannels); //Now an Add/Go/Get block to configure the timers and counters. These //are configured on EIO0-EIO3, so if more than 8 analog inputs are //enabled then the analog inputs use these lines. if (numChannels <= 8) { //Set the timer/counter pin offset to 8, which will put the first //timer/counter on EIO0. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_COUNTER_PIN_OFFSET, 8, 0, 0); //Use the default clock source. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, (double)LJUD.TIMERCLOCKS.MHZ48, 0, 0); //Enable 2 timers. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 2, 0, 0); //Configure Timer0 as 8-bit PWM. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_MODE, 0, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 32768, 0, 0); //Configure Timer1 as 8-bit PWM. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_MODE, 1, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 1, 32768, 0, 0); //Enable Counter0. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 1, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 1, 1, 0, 0); //Execute the requests. LJUD.GoOne(u3.ljhandle); } //Now add requests that will be processed every iteration of the loop. //Add analog input requests. for (int j = 0; j < numChannels; j++) { LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_AIN, j, 0, 0, 0); } //Set DAC0 to 2.5 volts. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DAC, 0, 2.5, 0, 0); //Read CIO digital lines. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_DIGITAL_PORT, 16, 0, 4, 0); //Only do the timer/counter stuff if there are less than 8 analog inputs. if (numChannels <= 8) { LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_COUNTER, 0, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_COUNTER, 1, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_TIMER, 0, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_TIMER, 1, 0, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 32768, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 1, 32768, 0, 0); } time = Environment.TickCount; } catch (LabJackUDException e) { showErrorMessage(e); } for (int i = 0; i < numIterations; i++) { try { //Execute the requests. LJUD.GoOne(u3.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. LJUD.GetFirstResult(u3.ljhandle, ref ioType, ref channel, ref val, ref intVal, ref dblVal); } catch (LabJackUDException e) { showErrorMessage(e); } // Get results until there is no more data available bool isFinished = false; while (!isFinished) { switch (ioType) { case LJUD.IO.GET_AIN: ValueAIN[(int)channel] = val; break; case LJUD.IO.GET_DIGITAL_PORT: ValueDIPort = val; break; } try { LJUD.GetNextResult(u3.ljhandle, ref ioType, ref channel, ref val, ref intVal, ref dblVal); } catch (LabJackUDException e) { // If we get an error, report it. If there is no more data available we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } } time = Environment.TickCount - time; Console.Out.WriteLine("Milleseconds per iteration = {0:0.000}\n", (double)time / (double)numIterations); Console.Out.WriteLine("\nDigital Input = {0:0.###}\n", ValueDIPort); Console.Out.WriteLine("\nAIN readings from last iteration:\n"); for (int j = 0; j < numChannels; j++) { Console.Out.WriteLine("{0:0.000}\n", ValueAIN[j]); } Console.ReadLine(); // Pause for user }
/// <summary> /// Opens the LabJack, gets the UD driver version, and /// configures the device. /// </summary> /// <param name="sender">The object that called this event</param> /// <param name="e">Event details</param> private void TimedWindow_Load(object sender, System.EventArgs e) { double dblDriverVersion; LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; // dummy variables to satisfy certian method signatures double dummyDouble = 0; int dummyInt = 0; // Create the event timer but do not start it updateTimer = new System.Timers.Timer(); updateTimer.Elapsed += new ElapsedEventHandler(TimerEvent); updateTimer.Interval = TIMER_INTERVAL; // Disable the start button while the device is loading goStopButton.Enabled = false; Update(); //Read and display the UD version. dblDriverVersion = LJUD.GetDriverVersion(); versionDisplay.Text = String.Format("{0:0.000}", dblDriverVersion); // Open and configure U6 try { //Open the device u6 = new U6(LJUD.CONNECTION.USB, "0", true); //Configure the resolution of the analog inputs (pass a non-zero value for quick sampling). //See section 2.6 / 3.1 for more information. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, 0, 0, 0); //Configure the analog input range on channels 2 and 3 for bipolar 10v. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_AIN_RANGE, (LJUD.CHANNEL) 2, (double)LJUD.RANGES.BIP10V, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_AIN_RANGE, (LJUD.CHANNEL) 3, (double)LJUD.RANGES.BIP10V, 0, 0); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } try { //Execute the requests. LJUD.GoOne(u6.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. The rest of the results are in the below loop. LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } bool isFinished = false; while (!isFinished) { try { LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (exc.LJUDError == U6.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { ShowErrorMessage(exc); return; } } } // Enable the start button goStopButton.Enabled = true; }
public void performActions() { double dblValue = 0; // Open UE9 try { ue9 = new UE9(LJUD.CONNECTION.USB, "0", true); // Connection through USB //ue9 = new UE9(LJUD.CONNECTION.ETHERNET, "192.168.1.50", true); // Connection through ethernet } catch (LabJackUDException e) { showErrorMessage(e); } ///* //Use this code if only a single EI-1050 is connected. // Connections for the probe: // Red (Power) FIO2 // Black (Ground) GND // Green (Data) FIO0 // White (Clock) FIO1 // Brown (Enable) FIO2 try { //Set the Data line to FIO0, which is the default anyway. LJUD.ePut(ue9.ljhandle, LJUD.IO.SHT_DATA_CHANNEL, 0, 0, 0); //Set the Clock line to FIO1, which is the default anyway. LJUD.ePut(ue9.ljhandle, LJUD.IO.SHT_CLOCK_CHANNEL, (LJUD.CHANNEL) 1, 0, 0); //Set FIO2 to output-high to provide power to the EI-1050s. LJUD.ePut(ue9.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 2, 1, 0); //Now, an add/go/get block to get the temp & humidity at the same time. //Request a temperature reading from the EI-1050. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); //Request a humidity reading from the EI-1050. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); //Execute the requests. Will take about 0.5 seconds with a USB high-high //or Ethernet connection, and about 1.5 seconds with a normal USB connection. LJUD.GoOne(ue9.ljhandle); //Get the temperature reading. LJUD.GetResult(ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg K\n", dblValue); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg C\n", (dblValue - 273.15)); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg F\n", (((dblValue - 273.15) * 1.8) + 32)); //Get the humidity reading. LJUD.GetResult(ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); Console.Out.WriteLine("RH Probe A = {0:0.###} percent\n\n", dblValue); } catch (LabJackUDException e) { showErrorMessage(e); } //End of single probe code. //*/ /* * //Use this code if two EI-1050 probes are connected. * // Connections for both probes: * // Red (Power) FIO2 * // Black (Ground) GND * // Green (Data) FIO0 * // White (Clock) FIO1 * // * // Probe A: * // Brown (Enable) FIO3 * // * // Probe B: * // Brown (Enable) DAC0 * try * { * //Set FIO3 to output-low to disable probe A. * LJUD.ePut (ue9.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 3, 0, 0); * * //Set DAC0 to 0 volts to disable probe B. * LJUD.ePut (ue9.ljhandle, LJUD.IO.PUT_DAC, (LJUD.CHANNEL) 0, 0.0, 0); * * //Set FIO3 to output-high to enable probe A. * LJUD.ePut (ue9.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 3, 1, 0); * * //Now, an add/go/get block to get the temp & humidity at the same time. * //Request a temperature reading from the EI-1050. * LJUD.AddRequest (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); * * //Request a humidity reading from the EI-1050. * LJUD.AddRequest (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); * * //Execute the requests. Will take about 0.5 seconds with a USB high-high * //or Ethernet connection, and about 1.5 seconds with a normal USB connection. * LJUD.GoOne (ue9.ljhandle); * * //Get the temperature reading. * LJUD.GetResult (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg K\n",dblValue); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg C\n",(dblValue-273.15)); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg F\n",(((dblValue-273.15)*1.8)+32)); * * //Get the humidity reading. * LJUD.GetResult (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); * Console.Out.WriteLine("RH Probe A = {0:0.###} percent\n\n",dblValue); * * //Set FIO3 to output-low to disable probe A. * LJUD.ePut (ue9.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 3, 0, 0); * * //Set DAC0 to 3.3 volts to enable probe B. * LJUD.ePut (ue9.ljhandle, LJUD.IO.PUT_DAC, 0, 3.3, 0); * * //Now, an add/go/get block to get the temp & humidity at the same time. * //Request a temperature reading from the EI-1050. * LJUD.AddRequest (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); * * //Request a humidity reading from the EI-1050. * LJUD.AddRequest (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); * * //Execute the requests. Will take about 0.5 seconds with a USB high-high * //or Ethernet connection, and about 1.5 seconds with a normal USB connection. * LJUD.GoOne (ue9.ljhandle); * * //Get the temperature reading. * LJUD.GetResult (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); * Console.Out.WriteLine("Temp Probe B = {0:0.###} deg K\n",dblValue); * Console.Out.WriteLine("Temp Probe B = {0:0.###} deg C\n",(dblValue-273.15)); * Console.Out.WriteLine("Temp Probe B = {0:0.###} deg F\n",(((dblValue-273.15)*1.8)+32)); * * //Get the humidity reading. * LJUD.GetResult (ue9.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); * Console.Out.WriteLine("RH Probe B = {0:0.###} percent\n\n",dblValue); * * //Set DAC0 to 0 volts to disable probe B. * LJUD.ePut (ue9.ljhandle, LJUD.IO.PUT_DAC, 0, 0.0, 0); * } * catch (LabJackUDException e) * { * showErrorMessage(e); * } * * //End of dual probe code. */ Console.ReadLine(); // Pause for user }
public void performActions() { // Open UE9 try { ue9 = new UE9(LJUD.CONNECTION.USB, "0", true); // Connection through USB //ue9 = new UE9(LJUD.CONNECTION.ETHERNET, "192.168.1.50", true); // Connection through ethernet } catch (LabJackUDException e) { showErrorMessage(e); } // Variables to pass to and from the driver object long ainResolution = 12; UE9.IO IOType = (UE9.IO) 0; UE9.CHANNEL channel = (UE9.CHANNEL) 0; double val = 0; double dblVal = 0; // Temporary variable required by GetFirstResult int intVal = 0; // Temporary variable required by GetFirstResult // General variable settings long numIterations = 1000; long numChannels = 6; //Number of AIN channels, 0-16. // Variables to store results double ValueDIPort = 0; double[] ValueAIN = new double[16]; try { // Set DAC0 to 2.5 volts LJUD.AddRequest(ue9.ljhandle, UE9.IO.PUT_DAC, 0, 2.5, 0, 0); // Set DAC1 to 3.5 volts LJUD.AddRequest(ue9.ljhandle, UE9.IO.PUT_DAC, 1, 3.5, 0, 0); //Write all digital I/O. Doing a bunch of bit instructions, rather than //the following port instruction, should not make a noticable difference //in the overall execution time. LJUD.AddRequest(ue9.ljhandle, UE9.IO.PUT_DIGITAL_PORT, 0, 0, 23, 0); //Configure the desired resolution. Note that depending on resolution and //number of analog inputs, numIterations might need to be reduced from the //default above so the program does not take too long to execute. LJUD.AddRequest(ue9.ljhandle, UE9.IO.PUT_CONFIG, UE9.CHANNEL.AIN_RESOLUTION, ainResolution, 0, 0); //Add analog input requests. for (int j = 0; j < numChannels; j++) { LJUD.AddRequest(ue9.ljhandle, UE9.IO.GET_AIN, j, 0, 0, 0); } //Request a read of all digital I/O. Doing a bunch of bit instructions, //rather than the following port instruction, should not make a noticable //difference in the overall execution time. LJUD.AddRequest(ue9.ljhandle, UE9.IO.GET_DIGITAL_PORT, 0, 0, 23, 0); } catch (LabJackUDException e) { showErrorMessage(e); } // Get the current tick count for a reference frame double time = System.Environment.TickCount; for (int i = 0; i < numIterations; i++) { try { //Execute the requests. LJUD.GoOne(ue9.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. LJUD.GetFirstResult(ue9.ljhandle, ref IOType, ref channel, ref val, ref intVal, ref dblVal); } catch (LabJackUDException e) { showErrorMessage(e); } // Get results until there is no more data available bool isFinished = false; while (!isFinished) { switch (IOType) { case LJUD.IO.GET_AIN: ValueAIN[(int)channel] = val; break; case LJUD.IO.GET_DIGITAL_PORT: ValueDIPort = val; break; } try { LJUD.GetNextResult(ue9.ljhandle, ref IOType, ref channel, ref val, ref intVal, ref dblVal); } catch (LabJackUDException e) { // If we get an error, report it. If there is no more data available we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } } // Determine how long it took to perform the above tasks and display the millisecounds per iteration along with the readings time = System.Environment.TickCount - time; Console.Out.WriteLine("Milleseconds per iteration = " + ((double)time / (double)numIterations) + "\n"); Console.Out.WriteLine("\nDigital Input = " + ValueDIPort + "\n"); Console.Out.WriteLine("\nAIN readings from last iteration:\n"); for (int j = 0; j < numChannels; j++) { Console.Out.WriteLine("{0:0.###}\n", ValueAIN[j]); } Console.ReadLine(); // Pause for the user }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double ValueDIPort = 0; double[] ValueAIN = new double[16]; long time = 0, i = 0, j = 0; long numIterations = 100; int numChannels = 16; //Number of AIN channels, 0-16. long resolution = 0; //Configure resolution of the analog inputs (pass a non-zero value for quick sampling). //See section 2.6 / 3.1 for more information. long settlingTime = 1; //0=5us, 1=10us, 2=100us, 3=1ms, 4=10ms // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; try { //Open the first found LabJack. u6 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Configure resolution. See section 2.6/3.1 of the User's Guide. LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, resolution, 0); //Configure settling time LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_SETTLING_TIME, settlingTime, 0); //Set the timer/counter pin offset to 8, which will put the first //timer/counter on EIO0. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_COUNTER_PIN_OFFSET, 8, 0, 0); //Use the default clock source. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, (double)LJUD.TIMERCLOCKS.MHZ48, 0, 0); //Enable 2 timers. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 2, 0, 0); //Configure Timer0 as 8-bit PWM. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_TIMER_MODE, 0, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 32768, 0, 0); //Configure Timer1 as 8-bit PWM. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_TIMER_MODE, 1, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 1, 32768, 0, 0); //Enable Counter0. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 1, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 1, 1, 0, 0); //Execute the requests. LJUD.GoOne(u6.ljhandle); //Now add requests that will be processed every iteration of the loop. //Add analog input requests. for (j = 0; j < numChannels; j++) { LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, (LJUD.CHANNEL)j, 0, 0, 0); } //Set DAC0 to 2.5 volts. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_DAC, 0, 2.5, 0, 0); //Read CIO digital lines. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_DIGITAL_PORT, 16, 0, 4, 0); //Only do the timer/counter stuff if there are less than 8 analog inputs. if (numChannels <= 8) { LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_COUNTER, 0, 0, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_COUNTER, 1, 0, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_TIMER, 0, 0, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_TIMER, 1, 0, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 32768, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 1, 32768, 0, 0); } } catch (LabJackUDException e) { showErrorMessage(e); } time = Environment.TickCount; for (i = 0; i < numIterations; i++) { //Execute the requests. try { LJUD.GoOne(u6.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); bool finished = false; while (!finished) { switch (ioType) { case LJUD.IO.GET_AIN: ValueAIN[(int)channel] = dblValue; break; case LJUD.IO.GET_DIGITAL_PORT: ValueDIPort = dblValue; break; } try{ LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { if (e.LJUDError == LJUD.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { showErrorMessage(e); } } } } time = Environment.TickCount - time; Console.Out.WriteLine("Milleseconds per iteration = {0:0.000}\n", (double)time / (double)numIterations); Console.Out.WriteLine("\nDigital Input = {0:0.###}\n", ValueDIPort); Console.Out.WriteLine("\nAIN readings from last iteration:\n"); for (j = 0; j < numChannels; j++) { Console.Out.WriteLine("{0:0.000}\n", ValueAIN[j]); } Console.ReadLine(); // Pause for user }
public void performActions() { long i = 0, k = 0; LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0, dblCommBacklog = 0, dblUDBacklog = 0; double scanRate = 2000; int delayms = 1000; double numScans = 4000; //2x the expected # of scans (2*scanRate*delayms/1000) double numScansRequested; double[] adblData = new double[8000]; //Max buffer size (#channels*numScansRequested) // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; double[] dummyDoubleArray = { 0 }; //Read and display the UD version. dblValue = LJUD.GetDriverVersion(); Console.Out.WriteLine("UD Driver Version = {0:0.000}\n\n", dblValue); try { //Open the first found LabJack U3. u3 = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB //LJUD.ResetLabJack(u3.ljhandle); //Read and display the hardware version of this U3. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.HARDWARE_VERSION, ref dblValue, 0); Console.Out.WriteLine("U3 Hardware Version = {0:0.000}\n\n", dblValue); //Read and display the firmware version of this U3. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.FIRMWARE_VERSION, ref dblValue, 0); Console.Out.WriteLine("U3 Firmware Version = {0:0.000}\n\n", dblValue); //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //Configure FIO0 and FIO1 as analog, all else as digital. That means we //will start from channel 0 and update all 16 flexible bits. We will //pass a value of b0000000000000011 or d3. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, 0, 3, 16); //Configure the stream: //Set the scan rate. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_SCAN_FREQUENCY, scanRate, 0, 0); //Give the driver a 5 second buffer (scanRate * 2 channels * 5 seconds). LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_BUFFER_SIZE, scanRate * 2 * 5, 0, 0); //Configure reads to retrieve whatever data is available without waiting (wait mode LJUD.STREAMWAITMODES.NONE). //See comments below to change this program to use LJUD.STREAMWAITMODES.SLEEP mode. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_WAIT_MODE, (double)LJUD.STREAMWAITMODES.NONE, 0, 0); //Define the scan list as AIN0 then AIN1. LJUD.AddRequest(u3.ljhandle, LJUD.IO.CLEAR_STREAM_CHANNELS, 0, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 0, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL_DIFF, 1, 0, 32, 0); //Execute the list of requests. LJUD.GoOne(u3.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } //Get all the results just to check for errors. try { LJUD.GetFirstResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool finished = false; while (!finished) { try { LJUD.GetNextResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { showErrorMessage(e); } } } //Start the stream. try { LJUD.eGet(u3.ljhandle, LJUD.IO.START_STREAM, 0, ref dblValue, 0); } catch (LabJackUDException e) { showErrorMessage(e); } //The actual scan rate is dependent on how the desired scan rate divides into //the LabJack clock. The actual scan rate is returned in the value parameter //from the start stream command. Console.Out.WriteLine("Actual Scan Rate = {0:0.000}\n", dblValue); Console.Out.WriteLine("Actual Sample Rate = {0:0.000}\n", 2 * dblValue); // # channels * scan rate //Read data while (Win32Interop._kbhit() == 0) //Loop will run until any key is hit { //Since we are using wait mode LJUD.STREAMWAITMODES.NONE, we will wait a little, then //read however much data is available. Thus this delay will control how //fast the program loops and how much data is read each loop. An //alternative common method is to use wait mode LJUD.STREAMWAITMODES.SLEEP where the //stream read waits for a certain number of scans. In such a case //you would not have a delay here, since the stream read will actually //control how fast the program loops. // //To change this program to use sleep mode, // -change numScans to the actual number of scans desired per read, // -change wait mode addrequest value to LJUD.STREAMWAITMODES.SLEEP, // -comment out the following Thread.Sleep command. Thread.Sleep(delayms); //Remove if using LJUD.STREAMWAITMODES.SLEEP. //init array so we can easily tell if it has changed for (k = 0; k < numScans * 2; k++) { adblData[k] = 9999.0; } try { //Read the data. We will request twice the number we expect, to //make sure we get everything that is available. //Note that the array we pass must be sized to hold enough SAMPLES, and //the Value we pass specifies the number of SCANS to read. numScansRequested = numScans; LJUD.eGet(u3.ljhandle, LJUD.IO.GET_STREAM_DATA, LJUD.CHANNEL.ALL_CHANNELS, ref numScansRequested, adblData); //The displays the number of scans that were actually read. Console.Out.WriteLine("\nIteration # {0:0.#}\n", i); Console.Out.WriteLine("Number read = {0:0}\n", numScansRequested); //This displays just the first scan. Console.Out.WriteLine("First scan = {0:0.000}, {1:0.000}\n", adblData[0], adblData[1]); //Retrieve the current backlog. The UD driver retrieves stream data from //the U3 in the background, but if the computer is too slow for some reason //the driver might not be able to read the data as fast as the U3 is //acquiring it, and thus there will be data left over in the U3 buffer. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.STREAM_BACKLOG_COMM, ref dblCommBacklog, 0); Console.Out.WriteLine("Comm Backlog = {0:0}\n", dblCommBacklog); LJUD.eGet(u3.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.STREAM_BACKLOG_UD, ref dblUDBacklog, 0); Console.Out.WriteLine("UD Backlog = {0:0}\n", dblUDBacklog); i++; } catch (LabJackUDException e) { showErrorMessage(e); } } //Stop the stream try{ LJUD.eGet(u3.ljhandle, LJUD.IO.STOP_STREAM, 0, ref dummyDouble, dummyDoubleArray); } catch (LabJackUDException e) { showErrorMessage(e); } Console.Out.WriteLine("\nDone"); Console.ReadLine(); // Pause for user }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double Value2 = 0, Value3 = 0; double ValueDIBit = 0, ValueDIPort = 0, ValueCounter = 0; // dummy variables to satisfy certian method signatures double dummyDouble = 0; int dummyInt = 0; // Open U6 try { u6 = new U6(LJUD.CONNECTION.USB, "0", true); } catch (LabJackUDException e) { showErrorMessage(e); } try { //First some configuration commands. These will be done with the ePut //function which combines the add/go/get into a single call. //Configure the resolution of the analog inputs (pass a non-zero value for quick sampling). //See section 2.6 / 3.1 for more information. LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, 0, 0); //Configure the analog input range on channels 2 and 3 for bipolar 10v. LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_AIN_RANGE, (LJUD.CHANNEL) 2, (double)LJUD.RANGES.BIP10V, 0); LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_AIN_RANGE, (LJUD.CHANNEL) 3, (double)LJUD.RANGES.BIP10V, 0); //Enable Counter0 which will appear on FIO0 (assuming no other //program has enabled any timers or Counter1). LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 1, 0); //Now we add requests to write and read I/O. These requests //will be processed repeatedly by go/get statements in every //iteration of the while loop below. //Request AIN2 and AIN3. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, 2, 0, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, 3, 0, 0, 0); //Set DAC0 to 2.5 volts. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_DAC, 0, 2.5, 0, 0); //Read digital input FIO1. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_DIGITAL_BIT, 1, 0, 0, 0); //Set digital output FIO2 to output-high. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, 2, 1, 0, 0); //Read digital inputs FIO3 through FIO7. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_DIGITAL_PORT, 3, 0, 5, 0); //Request the value of Counter0. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_COUNTER, 0, 0, 0, 0); } catch (LabJackUDException e) { showErrorMessage(e); } bool requestedExit = false; while (!requestedExit) { try { //Execute the requests. LJUD.GoOne(u6.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool isFinished = false; while (!isFinished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 2: Value2 = dblValue; break; case 3: Value3 = dblValue; break; } break; case LJUD.IO.GET_DIGITAL_BIT: ValueDIBit = dblValue; break; case LJUD.IO.GET_DIGITAL_PORT: ValueDIPort = dblValue; break; case LJUD.IO.GET_COUNTER: ValueCounter = dblValue; break; } try { LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == U6.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } // Output the results Console.Out.WriteLine("AIN2 = {0:0.00000}\n", Value2); Console.Out.WriteLine("AIN3 = {0:0.00000}\n", Value3); Console.Out.WriteLine("FIO1 = {0:0.00000}\n", ValueDIBit); Console.Out.WriteLine("FIO3-FIO7 = {0:0.00000}\n", ValueDIPort); //Will read 31 if all 5 lines are pulled-high as normal. Console.Out.WriteLine("Counter0 (FIO0) = {0:0.00000}\n", ValueCounter); Console.Out.WriteLine("\nPress Enter to go again or (q) to quit\n"); requestedExit = Console.ReadLine().Equals("q"); } }
public void preformActions() { long lngGetNextIteration; double dblDriverVersion; LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double Value12 = 9999, Value22 = 9999, Value32 = 9999; double Value13 = 9999, Value23 = 9999, Value33 = 9999; //Read and display the UD version. dblDriverVersion = LJUD.GetDriverVersion(); Console.Out.WriteLine("UD Driver Version = {0:0.000}\n\n", dblDriverVersion); // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; //Open the U6 with local ID 2. try { unit2 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB } catch (LabJackUDException e) { showErrorMessage(e); } //Open the U6 with local ID 3. try { unit3 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB } catch (LabJackUDException e) { showErrorMessage(e); } try { //The following commands will use the add-go-get method to group //multiple requests into a single low-level function. //Request a single-ended reading from AIN1. LJUD.AddRequest(unit2.ljhandle, LJUD.IO.GET_AIN, 1, 0, 0, 0); LJUD.AddRequest(unit3.ljhandle, LJUD.IO.GET_AIN, 1, 0, 0, 0); //Request a single-ended reading from AIN2. LJUD.AddRequest(unit2.ljhandle, LJUD.IO.GET_AIN, 2, 0, 0, 0); LJUD.AddRequest(unit3.ljhandle, LJUD.IO.GET_AIN, 2, 0, 0, 0); } catch (LabJackUDException e) { showErrorMessage(e); } bool isFinished = false; while (!isFinished) { try { //Execute all requests on all open LabJacks. LJUD.Go(); //Get all the results for unit 2. The input measurement results are stored. LJUD.GetFirstResult(unit2.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool unit2Finished = false; while (!unit2Finished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 1: Value12 = dblValue; break; case 2: Value22 = dblValue; break; } break; case LJUD.IO.GET_AIN_DIFF: Value32 = dblValue; break; } try { LJUD.GetNextResult(unit2.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { unit2Finished = true; } else { showErrorMessage(e); } } } //Get all the results for unit 3. The input measurement results are stored. try { LJUD.GetFirstResult(unit3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool unit3Finished = false; while (!unit3Finished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 1: Value13 = dblValue; break; case 2: Value23 = dblValue; break; } break; case LJUD.IO.GET_AIN_DIFF: Value33 = dblValue; break; } try { LJUD.GetNextResult(unit3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { unit3Finished = true; } else { showErrorMessage(e); } } } Console.Out.WriteLine("AIN1 (Unit 2) = {0:0.###}\n", Value12); Console.Out.WriteLine("AIN1 (Unit 3) = {0:0.###}\n", Value13); Console.Out.WriteLine("AIN2 (Unit 2) = {0:0.###}\n", Value22); Console.Out.WriteLine("AIN2 (Unit 3) = {0:0.###}\n", Value23); Console.Out.WriteLine("AIN3 (Unit 2) = {0:0.###}\n", Value32); Console.Out.WriteLine("AIN3 (Unit 3) = {0:0.###}\n", Value33); Console.Out.WriteLine("\nPress Enter to go again or (q) to quit\n"); String str1 = Console.ReadLine(); // Pause for user isFinished = str1 == "q"; } }
public void performActions() { long i = 0, k = 0; LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0, dblCommBacklog = 0; // Dummy variables to satisfy certain method signatures double dummyDouble = 0; int dummyInt = 0; double[] dummyDoubleArray = { 0.0 }; //The actual scan rate is determined by the external clock, but we need //an idea of how fast the scan rate will be so that we can make //the buffers big enough. Also, the driver needs to have an idea of the //expected scan rate to help it decide how big of packets to transfer. double scanRate = 1000; int delayms = 1000; double numScans = 2000; //2x the expected # of scans (2*scanRate*delayms/1000) double numScansRequested; double[] adblData = new double[12000]; //Max buffer size (#channels*numScansRequested) // Open UE9 try { ue9 = new UE9(LJUD.CONNECTION.USB, "0", true); // Connection through USB //ue9 = new UE9(LJUD.CONNECTION.ETHERNET, "192.168.1.50", true); // Connection through ethernet } catch (LabJackUDException e) { showErrorMessage(e); } try { //Make sure the UE9 is not streaming. LJUD.eGet(ue9.ljhandle, LJUD.IO.STOP_STREAM, (LJUD.CHANNEL) 0, ref dummyDouble, 0); } catch (LabJackUDException e) { // If the error indicates that the stream could not be stopped it is because the stream has not started yet and can be ignored if (e.LJUDError != LJUD.LJUDERROR.UNABLE_TO_STOP_STREAM) { showErrorMessage(e); } } try { //Disable all timers and counters to put everything in a known initial state. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 1, 0, 0, 0); LJUD.GoOne(ue9.ljhandle); //First we will configure Timer0 as system timer low and configure Timer1 to //output a 1000 Hz square wave. //Use the fixed 750kHz timer clock source. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, (double)LJUD.TIMERCLOCKS.KHZ750, 0, 0); //Set the divisor to 3 so the actual timer clock is 250 kHz. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_DIVISOR, 3, 0, 0); //Enable 2 timers. They will use FIO0-FIO1. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 2, 0, 0); //Configure Timer0 as system timer low. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, (LJUD.CHANNEL) 0, (double)LJUD.TIMERMODE.SYSTIMERLOW, 0, 0); //Configure Timer1 as frequency output. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_MODE, (LJUD.CHANNEL) 1, (double)LJUD.TIMERMODE.FREQOUT, 0, 0); //Set the frequency output on Timer1 to 1000 Hz (250000/(2*125) = 1000). LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 1, 125, 0, 0); //Execute the requests on a single LabJack. The driver will use a //single low-level TimerCounter command to handle all the requests above. LJUD.GoOne(ue9.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } //Get all the results just to check for errors. bool isFinished = false; try { LJUD.GetFirstResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } while (!isFinished) { try { LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } try { //Configure the stream: //Configure resolution for all analog inputs. Since the test external clock //is at 1000 Hz, and we are scanning 6 channels, we will have a //sample rate of 6000 samples/second. That means the maximum resolution //we could use is 13-bit. We will use 12-bit in this example. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, 12, 0, 0); //Configure the analog input range on channel 0 for bipolar +-5 volts. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_AIN_RANGE, 0, (double)LJUD.RANGES.BIP5V, 0, 0); //Configure the analog input range on channel 1 for bipolar +-5 volts. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_AIN_RANGE, 1, (double)LJUD.RANGES.BIP5V, 0, 0); //Give the driver a 5 second buffer (scanRate * 6 channels * 5 seconds). LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_BUFFER_SIZE, scanRate * 6 * 5, 0, 0); //Configure reads to retrieve whatever data is available without waiting (wait mode LJ_swNONE). //See comments below to change this program to use LJ_swSLEEP mode. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_WAIT_MODE, (double)LJUD.STREAMWAITMODES.NONE, 0, 0); //Configure for external triggering. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_EXTERNAL_TRIGGER, 1, 0, 0); //Define the scan list. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.CLEAR_STREAM_CHANNELS, 0, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 0, 0, 0, 0); //AIN0 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 1, 0, 0, 0); //AIN1 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 193, 0, 0, 0); //EIO_FIO LJUD.AddRequest(ue9.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 194, 0, 0, 0); //MIO_CIO LJUD.AddRequest(ue9.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 200, 0, 0, 0); //Timer0 LSW LJUD.AddRequest(ue9.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 224, 0, 0, 0); //Timer0 MSW //Execute the list of requests. LJUD.GoOne(ue9.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } //Get all the results just to check for errors. try { LJUD.GetFirstResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } isFinished = false; while (!isFinished) { try { LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } try { //Start the stream. LJUD.eGet(ue9.ljhandle, LJUD.IO.START_STREAM, 0, ref dblValue, 0); //Read data while (Win32Interop._kbhit() == 0) //Loop will run until any key is hit { //Since we are using wait mode LJUD.STREAMWAITMODES.NONE, we will wait a little, then //read however much data is available. Thus this delay will control how //fast the program loops and how much data is read each loop. An //alternative common method is to use wait mode LJUD.STREAMWAITMODES.SLEEP where the //stream read waits for a certain number of scans. In such a case //you would not have a delay here, since the stream read will actually //control how fast the program loops. // //To change this program to use sleep mode, // -change numScans to the actual number of scans desired per read, // -change wait mode addrequest value to LJ_swSLEEP, // -comment out the following Sleep command. Thread.Sleep(delayms); //Remove if using LJUD.STREAMWAITMODES.SLEEP //init array so we can easily tell if it has changed for (k = 0; k < numScans * 2; k++) { adblData[k] = 9999.0; } //Read the data. We will request twice the number we expect, to //make sure we get everything that is available. //Note that the array we pass must be sized to hold enough SAMPLES, and //the Value we pass specifies the number of SCANS to read. numScansRequested = numScans; LJUD.eGet(ue9.ljhandle, LJUD.IO.GET_STREAM_DATA, LJUD.CHANNEL.ALL_CHANNELS, ref numScansRequested, adblData); //This displays the number of scans that were actually read. Console.Out.WriteLine("\nIteration # {0:0.###}\n", i); Console.Out.WriteLine("Number read = {0:0.###}\n", numScansRequested); //This displays just the first scan. Console.Out.WriteLine("First scan = {0:0.###},{0:0.###},{0:0.###},{0:0.###},{0:0.###},{0:0.###}\n", adblData[0], adblData[1], adblData[2], adblData[3], adblData[4], adblData[5]); //Retrieve the current Comm backlog. The UD driver retrieves stream data from //the UE9 in the background, but if the computer is too slow for some reason //the driver might not be able to read the data as fast as the UE9 is //acquiring it, and thus there will be data left over in the UE9 buffer. LJUD.eGet(ue9.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.STREAM_BACKLOG_COMM, ref dblCommBacklog, 0); Console.Out.WriteLine("Comm Backlog = {0:0.###}\n", dblCommBacklog); i++; } //Stop the stream LJUD.eGet(ue9.ljhandle, LJUD.IO.STOP_STREAM, 0, ref dummyDouble, 0); //Disable the timers. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 0, 0, 0); LJUD.GoOne(ue9.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } Console.Out.WriteLine("\nDone"); Console.ReadLine(); // Pause for user return; }
public void performActions() { double dblDriverVersion; LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double Value0 = 9999, Value1 = 9999, Value2 = 9999; double ValueDIBit = 9999, ValueDIPort = 9999, ValueCounter = 9999; // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; //Read and display the UD version. dblDriverVersion = LJUD.GetDriverVersion(); Console.Out.WriteLine("UD Driver Version = {0:0.000}\n\n", dblDriverVersion); try { //Open the first found LabJack U3. u3 = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //First some configuration commands. These will be done with the ePut //function which combines the add/go/get into a single call. //Configure FIO0-FIO3 as analog, all else as digital. That means we //will start from channel 0 and update all 16 flexible bits. We will //pass a value of b0000000000001111 or d15. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, 0, 15, 16); //Set the timer/counter pin offset to 7, which will put the first //timer/counter on FIO7. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_COUNTER_PIN_OFFSET, 7, 0); //Enable Counter1 (FIO7). LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, (LJUD.CHANNEL) 1, 1, 0); //The following commands will use the add-go-get method to group //multiple requests into a single low-level function. //Request a single-ended reading from AIN0. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_AIN, 0, 0, 0, 0); //Request a single-ended reading from AIN1. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_AIN, 1, 0, 0, 0); //Request a reading from AIN2 using the Special range. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_AIN_DIFF, 2, 0, 32, 0); //Set DAC0 to 3.5 volts. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DAC, 0, 3.5, 0, 0); //Set digital output FIO4 to output-high. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, 4, 1, 0, 0); //Read digital input FIO5. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_DIGITAL_BIT, 5, 0, 0, 0); //Read digital inputs FIO5 through FIO6. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_DIGITAL_PORT, 5, 0, 2, 0); //Request the value of Counter1 (FIO7). LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_COUNTER, 1, 0, 0, 0); } catch (LabJackUDException e) { ShowErrorMessage(e); } bool requestedExit = false; while (!requestedExit) { try { //Execute the requests. LJUD.GoOne(u3.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. LJUD.GetFirstResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { ShowErrorMessage(e); } bool finished = false; while (!finished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 0: Value0 = dblValue; break; case 1: Value1 = dblValue; break; } break; case LJUD.IO.GET_AIN_DIFF: Value2 = dblValue; break; case LJUD.IO.GET_DIGITAL_BIT: ValueDIBit = dblValue; break; case LJUD.IO.GET_DIGITAL_PORT: ValueDIPort = dblValue; break; case LJUD.IO.GET_COUNTER: ValueCounter = dblValue; break; } try { LJUD.GetNextResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == U3.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { ShowErrorMessage(e); } } } Console.Out.WriteLine("AIN0 = {0:0.###}\n", Value0); Console.Out.WriteLine("AIN1 = {0:0.###}\n", Value1); Console.Out.WriteLine("AIN2 = {0:0.###}\n", Value2); Console.Out.WriteLine("FIO5 = {0:0.###}\n", ValueDIBit); Console.Out.WriteLine("FIO5-FIO6 = {0:0.###}\n", ValueDIPort); //Will read 3 (binary 11) if both lines are pulled-high as normal. Console.Out.WriteLine("Counter1 (FIO7) = {0:0.###}\n", ValueCounter); Console.Out.WriteLine("\nPress Enter to go again or (q) to quit\n"); requestedExit = Console.ReadLine().Equals("q"); } }
/// <summary> /// Actually performs actions on the UE9 and updates the displaye /// </summary> /// <param name="sender">The object that executed this method</param> /// <param name="e">Event parameters</param> private void goButton_Click(object sender, System.EventArgs e) { double dblDriverVersion; LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double Value2 = 0, Value3 = 0; double ValueDIBit = 0, ValueDIPort = 0, ValueCounter = 0; // dummy variables to satisfy certian method signatures double dummyDouble = 0; int dummyInt = 0; //Read and display the UD version. dblDriverVersion = LJUD.GetDriverVersion(); versionDisplay.Text = String.Format("{0:0.000}", dblDriverVersion); // Open UE9 try { ue9 = new UE9(LJUD.CONNECTION.USB, "0", true); // Connection through USB } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } try { //First some configuration commands. These will be done with the ePut //function which combines the add/go/get into a single call. //Configure for 16-bit analog input measurements. LJUD.ePut(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, 16, 0); //Configure the analog input range on channels 2 and 3 for bipolar 5v. LJUD.ePut(ue9.ljhandle, LJUD.IO.PUT_AIN_RANGE, (LJUD.CHANNEL) 2, (double)LJUD.RANGES.BIP5V, 0); LJUD.ePut(ue9.ljhandle, LJUD.IO.PUT_AIN_RANGE, (LJUD.CHANNEL) 3, (double)LJUD.RANGES.BIP5V, 0); //Enable Counter0 which will appear on FIO0 (assuming no other //program has enabled any timers or Counter1). LJUD.ePut(ue9.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 0, 1, 0); //Now we add requests to write and read I/O. These requests //will be processed repeatedly by go/get statements in every //iteration of the while loop below. //Request AIN2 and AIN3. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.GET_AIN, 2, 0, 0, 0); LJUD.AddRequest(ue9.ljhandle, LJUD.IO.GET_AIN, 3, 0, 0, 0); //Set DAC0 to 2.5 volts. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_DAC, 0, 2.5, 0, 0); //Read digital input FIO1. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.GET_DIGITAL_BIT, 1, 0, 0, 0); //Read digital inputs FIO2 through FIO3. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.GET_DIGITAL_PORT, 2, 0, 2, 0); // LJUD.AddRequest (ue9.ljhandle, LJUD.IO.GET_DIGITAL_PORT, 2, 0, 3, 0); would request through FIO4 //Request the value of Counter0. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.GET_COUNTER, 0, 0, 0, 0); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } try { //Execute the requests. LJUD.GoOne(ue9.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. LJUD.GetFirstResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } bool isFinished = false; while (!isFinished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 2: Value2 = dblValue; break; case 3: Value3 = dblValue; break; } break; case LJUD.IO.GET_DIGITAL_BIT: ValueDIBit = dblValue; break; case LJUD.IO.GET_DIGITAL_PORT: ValueDIPort = dblValue; break; case LJUD.IO.GET_COUNTER: ValueCounter = dblValue; break; } try { LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (exc.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { ShowErrorMessage(exc); } } } // Display results ain2Display.Text = String.Format("{0:0.###}", Value2); ain3Display.Text = String.Format("{0:0.###}", Value3); fio1Display.Text = String.Format("{0:0.###}", ValueDIBit); fio2Display.Text = String.Format("{0:0.###}", ValueDIPort); //Will read 30 (binary 11) if both lines are pulled-high as normal. counter0Display.Text = String.Format("{0:0.###}", ValueCounter); }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double dummyDouble = 0; int dummyInt = 0; double numI2CBytesToWrite; double numI2CBytesToRead; byte[] writeArray = new byte[128]; byte[] readArray = new byte[128]; long i = 0; long serialNumber = 0; double slopeDACA = 0, offsetDACA = 0, slopeDACB = 0, offsetDACB = 0; double writeACKS = 0, expectedACKS = 0; byte[] bytes; //Open the LabJack. try { device = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB } catch (LabJackUDException e) { showErrorMessage(e); } //Configure the I2C communication. //The address of the EEPROM on the LJTick-DAC is 0xA0. LJUD.AddRequest(device.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.I2C_ADDRESS_BYTE, 160, 0, 0); //SCL is FIO4 LJUD.AddRequest(device.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.I2C_SCL_PIN_NUM, 4, 0, 0); //SDA is FIO5 LJUD.AddRequest(device.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.I2C_SDA_PIN_NUM, 5, 0, 0); //See description of low-level I2C function. LJUD.AddRequest(device.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.I2C_OPTIONS, 0, 0, 0); //See description of low-level I2C function. 0 is max speed of about 130 kHz. LJUD.AddRequest(device.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.I2C_SPEED_ADJUST, 0, 0, 0); //Execute the requests on a single LabJack. LJUD.GoOne(device.ljhandle); //Get all the results just to check for errors. LJUD.GetFirstResult(device.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); bool finished = false; while (!finished) { try{ LJUD.GetNextResult(device.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { if (e.LJUDError == LJUD.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { showErrorMessage(e); } } } //Initial read of EEPROM bytes 0-3 in the user memory area. //We need a single I2C transmission that writes the address and then reads //the data. That is, there needs to be an ack after writing the address, //not a stop condition. To accomplish this, we use Add/Go/Get to combine //the write and read into a single low-level call. numI2CBytesToWrite = 1; writeArray[0] = 0; //Memory address. User area is 0-63. LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, numI2CBytesToWrite, writeArray, 0); LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, 0, 0, 0); numI2CBytesToRead = 4; LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_READ, numI2CBytesToRead, readArray, 0); //Execute the requests. LJUD.GoOne(device.ljhandle); //Get the result of the write just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, ref dummyDouble); //Get the write ACKs and compare to the expected value. We expect bit 0 to be //the ACK of the last data byte progressing up to the ACK of the address //byte (data bytes only for Control firmware 1.43 and less). So if n is the //number of data bytes, the ACKs value should be (2^(n+1))-1. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, ref writeACKS); expectedACKS = Math.Pow(2, numI2CBytesToWrite + 1) - 1; if (writeACKS != expectedACKS) { Console.Out.WriteLine("Expected ACKs = {0:0}, Received ACKs = %0.f\n", expectedACKS, writeACKS); } //When the GoOne processed the read request, the read data was put into the readArray buffer that //we passed, so this GetResult is also just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_READ, ref dummyDouble); //Display the first 4 elements. Console.Out.WriteLine("Read User Mem [0-3] = {0:0.#}, {1:0.#}, {2:0.#}, {3:0.#}\n", readArray[0], readArray[1], readArray[2], readArray[3]); //Write EEPROM bytes 0-3 in the user memory area, using the page write technique. Note //that page writes are limited to 16 bytes max, and must be aligned with the 16-byte //page intervals. For instance, if you start writing at address 14, you can only write //two bytes because byte 16 is the start of a new page. numI2CBytesToWrite = 5; writeArray[0] = 0; //Memory address. User area is 0-63. //Create 4 new pseudo-random numbers to write. Random rand = new Random((int)DateTime.Now.Ticks); for (i = 1; i < 5; i++) { writeArray[i] = (byte)(rand.NextDouble() * 255); } LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, numI2CBytesToWrite, writeArray, 0); LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, 0, 0, 0); //Execute the requests. LJUD.GoOne(device.ljhandle); //Get the result of the write just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, ref dummyDouble); //Get the write ACKs and compare to the expected value. We expect bit 0 to be //the ACK of the last data byte progressing up to the ACK of the address //byte (data bytes only for Control firmware 1.43 and less). So if n is the //number of data bytes, the ACKs value should be (2^(n+1))-1. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, ref writeACKS); expectedACKS = Math.Pow(2, numI2CBytesToWrite + 1) - 1; if (writeACKS != expectedACKS) { Console.Out.WriteLine("Expected ACKs = {0:0}, Received ACKs = %0.f\n", expectedACKS, writeACKS); } //Delay to allow the EEPROM to complete the write cycle. Datasheet says 1.5 ms max. System.Threading.Thread.Sleep(2); Console.Out.WriteLine("Write User Mem [0-3] = {0:0.#}, {1:0.#}, {2:0.#}, {3:0.#}\n", writeArray[1], writeArray[2], writeArray[3], writeArray[4]); //Final read of EEPROM bytes 0-3 in the user memory area. //We need a single I2C transmission that writes the address and then reads //the data. That is, there needs to be an ack after writing the address, //not a stop condition. To accomplish this, we use Add/Go/Get to combine //the write and read into a single low-level call. numI2CBytesToWrite = 1; writeArray[0] = 0; //Memory address. User area is 0-63. LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, numI2CBytesToWrite, writeArray, 0); LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, 0, 0, 0); numI2CBytesToRead = 4; LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_READ, numI2CBytesToRead, readArray, 0); //Execute the requests. LJUD.GoOne(device.ljhandle); //Get the result of the write just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, ref dummyDouble); //Get the write ACKs and compare to the expected value. We expect bit 0 to be //the ACK of the last data byte progressing up to the ACK of the address //byte (data bytes only for Control firmware 1.43 and less). So if n is the //number of data bytes, the ACKs value should be (2^(n+1))-1. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, ref writeACKS); expectedACKS = Math.Pow(2, numI2CBytesToWrite + 1) - 1; if (writeACKS != expectedACKS) { Console.Out.WriteLine("Expected ACKs = {0:0}, Received ACKs = %0.f\n", expectedACKS, writeACKS); } //When the GoOne processed the read request, the read data was put into the readArray buffer that //we passed, so this GetResult is also just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_READ, ref dummyDouble); //Display the first 4 elements. Console.Out.WriteLine("Read User Mem [0-3] = {0:0.#}, {1:0.#}, {2:0.#}, {3:0.#}\n\n", readArray[0], readArray[1], readArray[2], readArray[3]); //Read cal constants and serial number. //We need a single I2C transmission that writes the address and then reads //the data. That is, there needs to be an ack after writing the address, //not a stop condition. To accomplish this, we use Add/Go/Get to combine //the write and read into a single low-level call. // //64-71 DACA Slope //72-79 DACA Offset //80-87 DACB Slope //88-95 DACB Offset //96-99 Serial Number // numI2CBytesToWrite = 1; writeArray[0] = 64; //Memory address. Cal constants start at 64. LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, numI2CBytesToWrite, writeArray, 0); LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, 0, 0, 0); numI2CBytesToRead = 36; LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_READ, numI2CBytesToRead, readArray, 0); //Execute the requests. LJUD.GoOne(device.ljhandle); //Get the result of the write just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, ref dummyDouble); //Get the write ACKs and compare to the expected value. We expect bit 0 to be //the ACK of the last data byte progressing up to the ACK of the address //byte (data bytes only for Control firmware 1.43 and less). So if n is the //number of data bytes, the ACKs value should be (2^(n+1))-1. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, ref writeACKS); expectedACKS = Math.Pow(2, numI2CBytesToWrite + 1) - 1; if (writeACKS != expectedACKS) { Console.Out.WriteLine("Expected ACKs = {0:0}, Received ACKs = %0.f\n", expectedACKS, writeACKS); } //When the GoOne processed the read request, the read data was put into the readArray buffer that //we passed, so this GetResult is also just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_READ, ref dummyDouble); //Convert fixed point values to floating point doubles. //double[] readArray; //readArray = (double[])(readArray); slopeDACA = BitConverter.ToInt64(readArray, 0) / (double)4294967296; offsetDACA = BitConverter.ToInt64(readArray, 8) / (double)4294967296; slopeDACB = BitConverter.ToInt64(readArray, 16) / (double)4294967296; offsetDACB = BitConverter.ToInt64(readArray, 24) / (double)4294967296; Console.Out.WriteLine("DACA Slope = {0:0.0} bits/volt\n", slopeDACA); Console.Out.WriteLine("DACA Offset = {0:0.0} bits\n", offsetDACA); Console.Out.WriteLine("DACB Slope = {0:0.0} bits/volt\n", slopeDACB); Console.Out.WriteLine("DACB Offset = {0:0.0} bits\n", offsetDACB); //Convert serial number bytes to long. serialNumber = (int)readArray[32] + ((int)readArray[33] << 8) + ((int)readArray[34] << 16) + ((int)readArray[35] << 24); Console.Out.WriteLine("Serial Number = {0:0.#}\n\n", serialNumber); //Update both DAC outputs. //Set the I2C address in the UD driver so that we not talk to the DAC chip. //The address of the DAC chip on the LJTick-DAC is 0x24. LJUD.ePut(device.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.I2C_ADDRESS_BYTE, 36, 0); ///Set DACA to 2.4 volts. numI2CBytesToWrite = 3; writeArray[0] = 48; //Write and update DACA. bytes = BitConverter.GetBytes((long)((2.4 * slopeDACB) + offsetDACB) / 256); writeArray[1] = bytes[0]; //Upper byte of binary DAC value. writeArray[2] = bytes[1]; //Lower byte of binary DAC value. LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, numI2CBytesToWrite, writeArray, 0); LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, 0, 0, 0); //Execute the requests. LJUD.GoOne(device.ljhandle); //Get the result of the write just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, ref dummyDouble); //Get the write ACKs and compare to the expected value. We expect bit 0 to be //the ACK of the last data byte progressing up to the ACK of the address //byte (data bytes only for Control firmware 1.43 and less). So if n is the //number of data bytes, the ACKs value should be (2^(n+1))-1. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, ref writeACKS); expectedACKS = Math.Pow(2, numI2CBytesToWrite + 1) - 1; if (writeACKS != expectedACKS) { Console.Out.WriteLine("Expected ACKs = {0:0}, Received ACKs = %0.f\n", expectedACKS, writeACKS); } Console.Out.WriteLine("DACA set to 2.4 volts\n\n"); //Set DACB to 1.5 volts. numI2CBytesToWrite = 3; writeArray[0] = 49; //Write and update DACB. bytes = BitConverter.GetBytes((long)((1.5 * slopeDACB) + offsetDACB) / 256); writeArray[1] = bytes[0]; //Upper byte of binary DAC value. writeArray[2] = bytes[1]; //Lower byte of binary DAC value. LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, numI2CBytesToWrite, writeArray, 0); LJUD.AddRequest(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, 0, 0, 0); //Execute the requests. LJUD.GoOne(device.ljhandle); //Get the result of the write just to check for an error. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_WRITE, ref dummyDouble); //Get the write ACKs and compare to the expected value. We expect bit 0 to be //the ACK of the last data byte progressing up to the ACK of the address //byte (data bytes only for Control firmware 1.43 and less). So if n is the //number of data bytes, the ACKs value should be (2^(n+1))-1. LJUD.GetResult(device.ljhandle, LJUD.IO.I2C_COMMUNICATION, LJUD.CHANNEL.I2C_GET_ACKS, ref writeACKS); expectedACKS = Math.Pow(2, numI2CBytesToWrite + 1) - 1; if (writeACKS != expectedACKS) { Console.Out.WriteLine("Expected ACKs = {0:0}, Received ACKs = %0.f\n", expectedACKS, writeACKS); } Console.Out.WriteLine("DACB set to 1.5 volts\n"); Console.ReadLine(); // Pause for user return; }
public void performActions() { double dblDriverVersion; LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double Value22 = 9999, Value32 = 9999, Value42 = 9999; double Value23 = 9999, Value33 = 9999, Value43 = 9999; // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; //Read and display the UD version. dblDriverVersion = LJUD.GetDriverVersion(); Console.Out.WriteLine("UD Driver Version = {0:0.000}\n\n", dblDriverVersion); //Open the U3 with local ID 2. try { unit2 = new U3(LJUD.CONNECTION.USB, "2", false); // Connection through USB unit3 = new U3(LJUD.CONNECTION.USB, "3", false); // Connection through USB //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(unit2.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); LJUD.ePut(unit3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //First a configuration command. These will be done with the ePut //function which combines the add/go/get into a single call. //Configure FIO2-FIO4 as analog, all else as digital, on both devices. //That means we will start from channel 0 and update all 16 flexible bits. //We will pass a value of b0000000000011100 or d28. LJUD.ePut(unit2.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, 0, 28, 16); LJUD.ePut(unit3.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, 0, 28, 16); //The following commands will use the add-go-get method to group //multiple requests into a single low-level function. //Request a single-ended reading from AIN2. LJUD.AddRequest(unit2.ljhandle, LJUD.IO.GET_AIN, 2, 0, 0, 0); LJUD.AddRequest(unit3.ljhandle, LJUD.IO.GET_AIN, 2, 0, 0, 0); //Request a single-ended reading from AIN3. LJUD.AddRequest(unit2.ljhandle, LJUD.IO.GET_AIN, 3, 0, 0, 0); LJUD.AddRequest(unit3.ljhandle, LJUD.IO.GET_AIN, 3, 0, 0, 0); //Request a reading from AIN4 using the Special 0-3.6 range. LJUD.AddRequest(unit2.ljhandle, LJUD.IO.GET_AIN_DIFF, 4, 0, 32, 0); LJUD.AddRequest(unit3.ljhandle, LJUD.IO.GET_AIN_DIFF, 4, 0, 32, 0); } catch (LabJackUDException e) { showErrorMessage(e); } bool isFinished = false; while (!isFinished) { try { //Execute all requests on all open LabJacks. LJUD.Go(); //Get all the results for unit 2. The input measurement results are stored. LJUD.GetFirstResult(unit2.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool unit2Finished = false; while (!unit2Finished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 2: Value22 = dblValue; break; case 3: Value32 = dblValue; break; } break; case LJUD.IO.GET_AIN_DIFF: Value42 = dblValue; break; } try { LJUD.GetNextResult(unit2.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { unit2Finished = true; } else { showErrorMessage(e); } } } //Get all the results for unit 3. The input measurement results are stored. try { LJUD.GetFirstResult(unit3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool unit3Finished = false; while (!unit3Finished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 2: Value23 = dblValue; break; case 3: Value33 = dblValue; break; } break; case LJUD.IO.GET_AIN_DIFF: Value43 = dblValue; break; } try { LJUD.GetNextResult(unit3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { unit3Finished = true; } else { showErrorMessage(e); } } } Console.Out.WriteLine("AIN2 (Unit 2) = {0:0.###}\n", Value22); Console.Out.WriteLine("AIN2 (Unit 3) = {0:0.###}\n", Value23); Console.Out.WriteLine("AIN3 (Unit 2) = {0:0.###}\n", Value32); Console.Out.WriteLine("AIN3 (Unit 3) = {0:0.###}\n", Value33); Console.Out.WriteLine("AIN4 (Unit 2) = {0:0.###}\n", Value42); Console.Out.WriteLine("AIN4 (Unit 3) = {0:0.###}\n", Value43); Console.Out.WriteLine("\nPress Enter to go again or (q) to quit\n"); isFinished = Console.ReadLine() == "q"; // Pause for user } }
public void performActions() { double dblValue = 0; //Open the first found LabJack U6. try { u6 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Set the Data line to FIO0 LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SHT_DATA_CHANNEL, 0, 0); //Set the Clock line to FIO1 LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SHT_CLOCK_CHANNEL, 1, 0); //Set FIO2 to output-high to provide power to the EI-1050. LJUD.ePut(u6.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 2, 1, 0); } catch (LabJackUDException e) { showErrorMessage(e); } ///* //Use this code if only a single EI-1050 is connected. // Connections for one probe: // Red (Power) FIO2 // Black (Ground) GND // Green (Data) FIO0 // White (Clock) FIO1 // Brown (Enable) FIO2 try { //Now, an add/go/get block to get the temp & humidity at the same time. //Request a temperature reading from the EI-1050. LJUD.AddRequest(u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); //Request a humidity reading from the EI-1050. LJUD.AddRequest(u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); //Execute the requests. Will take about 0.5 seconds with a USB high-high //or Ethernet connection, and about 1.5 seconds with a normal USB connection. LJUD.GoOne(u6.ljhandle); //Get the temperature reading. LJUD.GetResult(u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg K\n", dblValue); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg C\n", (dblValue - 273.15)); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg F\n", (((dblValue - 273.15) * 1.8) + 32)); //Get the humidity reading. LJUD.GetResult(u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); Console.Out.WriteLine("RH Probe A = {0:0.###} percent\n\n", dblValue); } catch (LabJackUDException e) { showErrorMessage(e); } //End of single probe code. /*/ * * * ///* * //Use this code if two EI-1050 probes are connected. * // Connections for both probes: * // Red (Power) FIO2 * // Black (Ground) GND * // Green (Data) FIO0 * // White (Clock) FIO1 * // * // Probe A: * // Brown (Enable) FIO3 * // * // Probe B: * // Brown (Enable) DAC0 * * try * { * * //Set FIO3 to output-low to disable probe A. * LJUD.ePut (u6.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL)3, 0, 0); * * //Set DAC0 to 0 volts to disable probe B. * LJUD.ePut (u6.ljhandle, LJUD.IO.PUT_DAC, 0, 0.0, 0); * * //Set FIO3 to output-high to enable probe A. * LJUD.ePut (u6.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL)3, 1, 0); * * //Now, an add/go/get block to get the temp & humidity at the same time. * //Request a temperature reading from the EI-1050. * LJUD.AddRequest (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); * * //Request a humidity reading from the EI-1050. * LJUD.AddRequest (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); * * //Execute the requests. Will take about 0.5 seconds with a USB high-high * //or Ethernet connection, and about 1.5 seconds with a normal USB connection. * LJUD.GoOne (u6.ljhandle); * * //Get the temperature reading. * LJUD.GetResult (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg K\n",dblValue); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg C\n",(dblValue-273.15)); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg F\n",(((dblValue-273.15)*1.8)+32)); * * //Get the humidity reading. * LJUD.GetResult (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); * Console.Out.WriteLine("RH Probe A = {0:0.###} percent\n\n",dblValue); * * //Set FIO3 to output-low to disable probe A. * LJUD.ePut (u6.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL)3, 0, 0); * * //Set DAC0 to 3.3 volts to enable probe B. * LJUD.ePut (u6.ljhandle, LJUD.IO.PUT_DAC, 0, 3.3, 0); * * //Since the DACs on the U6 are slower than the communication speed, * //we put a delay here to make sure the DAC has time to rise to 3.3 volts * //before communicating with the EI-1050. * Thread.Sleep(30); //Wait 30 ms. * * //Now, an add/go/get block to get the temp & humidity at the same time. * //Request a temperature reading from the EI-1050. * LJUD.AddRequest (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); * * //Request a humidity reading from the EI-1050. * LJUD.AddRequest (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); * * //Execute the requests. Will take about 0.5 seconds with a USB high-high * //or Ethernet connection, and about 1.5 seconds with a normal USB connection. * LJUD.GoOne (u6.ljhandle); * * //Get the temperature reading. * LJUD.GetResult (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); * Console.Out.WriteLine("Temp Probe B = {0:0.###} deg K\n",dblValue); * Console.Out.WriteLine("Temp Probe B = {0:0.###} deg C\n",(dblValue-273.15)); * Console.Out.WriteLine("Temp Probe B = {0:0.###} deg F\n",(((dblValue-273.15)*1.8)+32)); * * //Get the humidity reading. * LJUD.GetResult (u6.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); * Console.Out.WriteLine("RH Probe B = {0:0.###} percent\n\n",dblValue); * * //Set DAC0 to 0 volts to disable probe B. * LJUD.ePut (u6.ljhandle, LJUD.IO.PUT_DAC, 0, 0.0, 0); * * //If we were going to loop and talk to probe A next, we would * //want a delay here to make sure the DAC falls to 0 volts * //before enabling probe A. * Thread.Sleep(30); //Wait 30 ms. * } * catch (LabJackUDException e) * { * showErrorMessage(e); * } * * //End of dual probe code. * //*/ Console.ReadLine(); // Pause for user }
/// <summary> /// Configure and start the stream on the LabJack /// </summary> /// <returns>True if successful and false otherwise</returns> private bool StartStreaming() { //Read and display the UD version. dblValue = LJUD.GetDriverVersion(); versionDisplay.Text = String.Format("{0:0.000}", dblValue); try { //Open the first found LabJack U6. u6 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Read and display the hardware version of this U6. LJUD.eGet(u6.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.HARDWARE_VERSION, ref dblValue, 0); hardwareDisplay.Text = String.Format("{0:0.000}", dblValue); //Read and display the firmware version of this U6. LJUD.eGet(u6.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.FIRMWARE_VERSION, ref dblValue, 0); firmwareDisplay.Text = String.Format("{0:0.000}", dblValue); //Configure the analog input range on channel 0 for bipolar +-10 volts. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_AIN_RANGE, 0, (double)LJUD.RANGES.BIP10V, 0, 0); //Configure the stream: //Set the scan rate. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_SCAN_FREQUENCY, scanRate, 0, 0); //Give the driver a 5 second buffer (scanRate * 2 channels * 5 seconds). LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_BUFFER_SIZE, scanRate * 2 * 5, 0, 0); //Configure reads to retrieve whatever data is available without waiting (wait mode LJUD.STREAMWAITMODES.NONE). //See comments below to change this program to use LJUD.STREAMWAITMODES.SLEEP mode. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_WAIT_MODE, (double)LJUD.STREAMWAITMODES.NONE, 0, 0); //Define the scan list as AIN0 then AIN1. LJUD.AddRequest(u6.ljhandle, LJUD.IO.CLEAR_STREAM_CHANNELS, 0, 0, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 0, 0, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 1, 0, 0, 0); //Execute the list of requests. LJUD.GoOne(u6.ljhandle); } catch (LabJackUDException e) { ShowErrorMessage(e); return(false); } //Get all the results just to check for errors. try { LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { ShowErrorMessage(e); } bool finished = false; while (!finished) { try { LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { ShowErrorMessage(e); } } } //Start the stream. try { LJUD.eGet(u6.ljhandle, LJUD.IO.START_STREAM, 0, ref dblValue, 0); } catch (LabJackUDException e) { ShowErrorMessage(e); return(false); } //The actual scan rate is dependent on how the desired scan rate divides into //the LabJack clock. The actual scan rate is returned in the value parameter //from the start stream command. scanDisplay.Text = String.Format("{0:0.000}", dblValue); sampleDisplay.Text = String.Format("{0:0.000}", 2 * dblValue); // # channels * scan rate // The stream started successfully return(true); }
/// <summary> /// Actually performs actions on the U3 and updates the displaye /// </summary> /// <param name="sender">The object that executed this method</param> /// <param name="e">Event parameters</param> private void TimerEvent(object sender, ElapsedEventArgs e) { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double Value0 = 9999, Value1 = 9999, Value2 = 9999; double ValueDIBit = 9999; // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; try { //The following commands will use the add-go-get method to group //multiple requests into a single low-level function. //Request a single-ended reading from AIN0. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_AIN, 0, 0, 0, 0); //Request a single-ended reading from AIN1. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_AIN, 1, 0, 0, 0); //Request a reading from AIN2 using the Special range. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_AIN_DIFF, 2, 0, 32, 0); //Read digital input FIO5. LJUD.AddRequest(u3.ljhandle, LJUD.IO.GET_DIGITAL_BIT, 5, 0, 0, 0); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } try { //Execute the requests. LJUD.GoOne(u3.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. LJUD.GetFirstResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } bool finished = false; while (!finished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 0: Value0 = dblValue; break; case 1: Value1 = dblValue; break; } break; case LJUD.IO.GET_AIN_DIFF: Value2 = dblValue; break; case LJUD.IO.GET_DIGITAL_BIT: ValueDIBit = dblValue; break; } try { LJUD.GetNextResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (exc.LJUDError == U3.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { ShowErrorMessage(exc); } } } // Display results ain0Display.Text = String.Format("{0:0.###}", Value0); ain1Display.Text = String.Format("{0:0.###}", Value1); ain2Display.Text = String.Format("{0:0.###}", Value2); fio5Display.Text = String.Format("{0:0.###}", ValueDIBit); }
/// <summary> /// performs read on LabJack device /// </summary> /// <param name="source">The object that called the event</param> /// <param name="e">Event details</param> public void TimerEvent(object source, ElapsedEventArgs e) { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double Value2 = 0, Value3 = 0; double ValueDIBit = 0; // dummy variables to satisfy certian method signatures double dummyDouble = 0; int dummyInt = 0; try { //Now we add requests to write and read I/O. These requests //will be processed repeatedly by go/get statements in every //iteration of the while loop below. //Request AIN2 and AIN3. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, 2, 0, 0, 0); LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, 3, 0, 0, 0); //Read digital input FIO1. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_DIGITAL_BIT, 1, 0, 0, 0); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } try { //Execute the requests. LJUD.GoOne(u6.ljhandle); //Get all the results. The input measurement results are stored. All other //results are for configuration or output requests so we are just checking //whether there was an error. The rest of the results are in the below loop. LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { ShowErrorMessage(exc); return; } bool isFinished = false; while (!isFinished) { switch (ioType) { case LJUD.IO.GET_AIN: switch ((int)channel) { case 2: Value2 = dblValue; break; case 3: Value3 = dblValue; break; } break; case LJUD.IO.GET_DIGITAL_BIT: ValueDIBit = dblValue; break; } try { LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException exc) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (exc.LJUDError == U6.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { ShowErrorMessage(exc); return; } } } // Display results ain2Display.Text = String.Format("{0:0.###}", Value2); ain3Display.Text = String.Format("{0:0.###}", Value3); fio1Display.Text = String.Format("{0:0.###}", ValueDIBit); }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double valueAIN = 0; //Analog Voltage Value LJUD.CHANNEL tempChannel = 0; //Channel which the TC/LJTIA is on (AIN0). double ainResolution = 0; //Configure resolution of the analog inputs (pass a non-zero value for quick sampling). //See section 2.6 / 3.1 for more information. double dblInternal = 0; double range = (double)LJUD.RANGES.BIPP1V; // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; double tcVolts = 0, cjTempK = 0, pTCTempK = 0; LJUD.THERMOCOUPLETYPE tcType = LJUD.THERMOCOUPLETYPE.K; //Set the temperature sensor to a k type thermocouple //Possible Thermocouple types are: //B = 6001 //E = 6002 //J = 6003 //K = 6004 //N = 6005 //R = 6006 //S = 6007 //T = 6008 //Open the first found LabJack U6 via USB. try { u6 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB } catch (LabJackUDException e) { showErrorMessage(e); } try { //Configure the desired resolution. See section 2.6 / 3.1 of the User's Guide LJUD.eGet(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.AIN_RESOLUTION, ref ainResolution, 0); // Set the range on the ananlog input channel to +/- 0.1 volts (x100 gain) LJUD.eGet(u6.ljhandle, LJUD.IO.PUT_AIN_RANGE, channel, ref range, 0); } catch (LabJackUDException e) { showErrorMessage(e); } Console.Out.WriteLine("Press any key to quit\n"); //Constantly acquire temperature readings until a key is pressed bool keyPressed = false; while (!keyPressed) { ioType = 0; channel = 0; tcVolts = 0; cjTempK = 0; pTCTempK = 0; try { //Add analog input requests. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, (LJUD.CHANNEL)tempChannel, 0, 0, 0); //Add request for internal temperature reading -- Internal temp sensor uses //analog input channel 14. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, 14, 0, 0, 0); //Execute all requests on the labjack u6.ljhandle. LJUD.GoOne(u6.ljhandle); //Get all the results. The first result should be the voltage reading of the //temperature channel. LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } //Get the rest of the results. There should only be one more on the request //queue. bool finished = false; while (!finished) { if (ioType == LJUD.IO.GET_AIN) { if (channel == tempChannel) { tcVolts = dblValue; } if (channel == (LJUD.CHANNEL) 14) { dblInternal = dblValue; } } try { LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { if (e.LJUDError == LJUD.LJUDERROR.NO_DATA_AVAILABLE) { finished = true; } else if (e.LJUDError > LJUD.LJUDERROR.MIN_GROUP_ERROR) { finished = true; } else { showErrorMessage(e); } } } //The cold junction is the screw-terminal block where the thermocouple //is connected. As discussed in the U6 User's Guide, add 2.5 degrees C //to the internal temp sensor reading. If using the CB37 rather than //the built-in screw terminals, just add 1.0 degrees C. cjTempK = dblInternal + 2.5; //Display Voltage Reading Console.Out.WriteLine("Analog {0:0}: {1:0.######}\n", (int)tempChannel, valueAIN); //Display the internal temperature sensor reading. This example uses //that value for cold junction compensation. Console.Out.WriteLine("U6 internal sensor: {0:0.0} deg K\n", (double)dblInternal); //Convert TC voltage to temperature. LJUD.TCVoltsToTemp(tcType, tcVolts, cjTempK, ref pTCTempK); //Display Temperature Console.Out.WriteLine("Thermocouple sensor: {0:0.0} deg K\n\n", pTCTempK); Thread.Sleep(1500); // Short pause keyPressed = Win32Interop._kbhit() != 0; // If a key was hit break out of the loop } }
/// <summary> /// Configure and start the stream on the LabJack /// </summary> /// <returns>True if successful and false otherwise</returns> private bool StartStreaming() { //Read and display the UD version. dblValue = LJUD.GetDriverVersion(); versionDisplay.Text = String.Format("{0:0.000}", dblValue); try { //Open the first found LabJack U3. u3 = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Read and display the hardware version of this U3. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.HARDWARE_VERSION, ref dblValue, 0); hardwareDisplay.Text = String.Format("{0:0.000}", dblValue); //Read and display the firmware version of this U3. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_CONFIG, LJUD.CHANNEL.FIRMWARE_VERSION, ref dblValue, 0); firmwareDisplay.Text = String.Format("{0:0.000}", dblValue); //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //Configure FIO0 and FIO1 as analog, all else as digital. That means we //will start from channel 0 and update all 16 flexible bits. We will //pass a value of b0000000000000011 or d3. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_ANALOG_ENABLE_PORT, 0, 3, 16); //Configure the stream: //Set the scan rate. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_SCAN_FREQUENCY, scanRate, 0, 0); //Give the driver a 5 second buffer (scanRate * 2 channels * 5 seconds). LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_BUFFER_SIZE, scanRate * 2 * 5, 0, 0); //Configure reads to retrieve whatever data is available without waiting (wait mode LJUD.STREAMWAITMODES.NONE). //See comments below to change this program to use LJUD.STREAMWAITMODES.SLEEP mode. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.STREAM_WAIT_MODE, (double)LJUD.STREAMWAITMODES.NONE, 0, 0); //Define the scan list as AIN0 then AIN1. LJUD.AddRequest(u3.ljhandle, LJUD.IO.CLEAR_STREAM_CHANNELS, 0, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL, 0, 0, 0, 0); LJUD.AddRequest(u3.ljhandle, LJUD.IO.ADD_STREAM_CHANNEL_DIFF, 1, 0, 32, 0); //Execute the list of requests. LJUD.GoOne(u3.ljhandle); } catch (LabJackUDException e) { ShowErrorMessage(e); return(false); } //Get all the results just to check for errors. try { LJUD.GetFirstResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { ShowErrorMessage(e); } bool finished = false; while (!finished) { try { LJUD.GetNextResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { ShowErrorMessage(e); } } } //Start the stream. try { LJUD.eGet(u3.ljhandle, LJUD.IO.START_STREAM, 0, ref dblValue, 0); } catch (LabJackUDException e) { ShowErrorMessage(e); return(false); } //The actual scan rate is dependent on how the desired scan rate divides into //the LabJack clock. The actual scan rate is returned in the value parameter //from the start stream command. scanDisplay.Text = String.Format("{0:0.000}", dblValue); sampleDisplay.Text = String.Format("{0:0.000}", 2 * dblValue); // # channels * scan rate // The stream started successfully return(true); }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double numSPIBytesToTransfer; byte[] dataArray = new byte[50]; // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; // Open UE9 try { ue9 = new UE9(LJUD.CONNECTION.USB, "0", true); // Connection through USB //ue9 = new UE9(LJUD.CONNECTION.ETHERNET, "192.168.1.50", true); // Connection through ethernet } catch (LabJackUDException e) { showErrorMessage(e); } try { //First, configure the SPI communication. //Enable automatic chip-select control. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_AUTO_CS, 1, 0, 0); //Do not disable automatic digital i/o direction configuration. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_DISABLE_DIR_CONFIG, 0, 0, 0); //Mode A: CPHA=1, CPOL=1. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_MODE, 0, 0, 0); //125kHz clock. LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_CLOCK_FACTOR, 0, 0, 0); //MOSI is FIO2 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_MOSI_PIN_NUM, 2, 0, 0); //MISO is FIO3 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_MISO_PIN_NUM, 3, 0, 0); //CLK is FIO0 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_CLK_PIN_NUM, 0, 0, 0); //CS is FIO1 LJUD.AddRequest(ue9.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_CS_PIN_NUM, 1, 0, 0); //Execute the requests on a single LabJack. The driver will use a //single low-level TimerCounter command to handle all the requests above. LJUD.GoOne(ue9.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } // Get results until there is no more data available for error checking bool isFinished = false; while (!isFinished) { try { LJUD.GetNextResult(ue9.ljhandle, ref ioType, ref channel, ref dummyDouble, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { isFinished = true; } else { showErrorMessage(e); } } } //This example transfers 4 test bytes. numSPIBytesToTransfer = 4; dataArray[0] = 170; dataArray[1] = 240; dataArray[2] = 170; dataArray[3] = 240; //Transfer the data. The write and read is done at the same time. try { LJUD.eGet(ue9.ljhandle, LJUD.IO.SPI_COMMUNICATION, 0, ref numSPIBytesToTransfer, dataArray); } catch (LabJackUDException e) { showErrorMessage(e); } //Display the read data. Console.Out.WriteLine("dataArray[0] = {0:0.#}\n", dataArray[0]); Console.Out.WriteLine("dataArray[1] = {0:0.#}\n", dataArray[1]); Console.Out.WriteLine("dataArray[2] = {0:0.#}\n", dataArray[2]); Console.Out.WriteLine("dataArray[3] = {0:0.#}\n", dataArray[3]); Console.ReadLine(); // Pause for user }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double numSPIBytesToTransfer; byte[] dataArray = new byte[50]; //Open the LabJack U6. try { u6 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB //First, configure the SPI communication. //Enable automatic chip-select control. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_AUTO_CS, 1, 0, 0); //Do not disable automatic digital i/o direction configuration. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_DISABLE_DIR_CONFIG, 0, 0, 0); //Mode A: CPHA=1, CPOL=1. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_MODE, 0, 0, 0); //125kHz clock. LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_CLOCK_FACTOR, 0, 0, 0); //MOSI is FIO2 LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_MOSI_PIN_NUM, 2, 0, 0); //MISO is FIO3 LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_MISO_PIN_NUM, 3, 0, 0); //CLK is FIO0 LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_CLK_PIN_NUM, 0, 0, 0); //CS is FIO1 LJUD.AddRequest(u6.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SPI_CS_PIN_NUM, 1, 0, 0); //Execute the requests on a single LabJack. The driver will use a //single low-level TimerCounter command to handle all the requests above. LJUD.GoOne(u6.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } //Get all the results just to check for errors. try { LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool finished = false; while (!finished) { try{ LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { if (e.LJUDError == LJUD.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { showErrorMessage(e); } } } //This example transfers 4 test bytes. numSPIBytesToTransfer = 4; dataArray[0] = 175; dataArray[1] = 245; dataArray[2] = 170; dataArray[3] = 240; //Transfer the data. The write and read is done at the same time. try { LJUD.eGet(u6.ljhandle, LJUD.IO.SPI_COMMUNICATION, 0, ref numSPIBytesToTransfer, dataArray); } catch (LabJackUDException e) { showErrorMessage(e); } //Display the read data. Console.Out.WriteLine("dataArray[0] = {0:0.#}\n", dataArray[0]); Console.Out.WriteLine("dataArray[1] = {0:0.#}\n", dataArray[1]); Console.Out.WriteLine("dataArray[2] = {0:0.#}\n", dataArray[2]); Console.Out.WriteLine("dataArray[3] = {0:0.#}\n", dataArray[3]); Console.ReadLine(); // Pause for user }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; double valueAIN = 0; //Analog Voltage Value LJUD.CHANNEL tempChannel = 0; //Channel which the TC/LJTIA is on (AIN0). // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; double tcVolts = 0, cjTempK = 0, pTCTempK = 0; LJUD.THERMOCOUPLETYPE tcType = LJUD.THERMOCOUPLETYPE.K; //Set the temperature sensor to a k type thermocouple //Possible Thermocouple types are: //B = 6001 //E = 6002 //J = 6003 //K = 6004 //N = 6005 //R = 6006 //S = 6007 //T = 6008 //Offset calibration: The nominal voltage offset of the LJTick is //0.4 volts. For improved accuracy, though, you should measure the //overall system offset. We know that if the end of the TC is at the //same temperature as the cold junction, the voltage should be zero. //Put the end of the TC near the LJTIA to make sure they are at the same //temperature, and note the voltage measured by FIO4. This is the actual //offset that can be entered below. double offsetVoltage = 0.4; //Open the first found LabJack U6 via USB. try { u6 = new U6(LJUD.CONNECTION.USB, "0", true); // Connection through USB } catch (LabJackUDException e) { showErrorMessage(e); } //Constantly acquire temperature readings until a key is pressed bool keyPressed = false; while (!keyPressed) { ioType = 0; channel = 0; tcVolts = 0; cjTempK = 0; pTCTempK = 0; try { //Add analog input requests. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, (LJUD.CHANNEL)tempChannel, 0, 0, 0); //Add request for internal temperature reading -- Internal temp sensor uses //analog input channel 14. LJUD.AddRequest(u6.ljhandle, LJUD.IO.GET_AIN, 14, 0, 0, 0); //Execute all requests on the labjack u6.ljhandle. LJUD.GoOne(u6.ljhandle); //Get all the results. The first result should be the voltage reading of the //temperature channel. LJUD.GetFirstResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } //Get the rest of the results. There should only be one more on the request //queue. bool finished = false; while (!finished) { if (ioType == LJUD.IO.GET_AIN) { if (channel == tempChannel) { valueAIN = dblValue; } if (channel == (LJUD.CHANNEL) 14) { cjTempK = dblValue; } } try { LJUD.GetNextResult(u6.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { if (e.LJUDError == LJUD.LJUDERROR.NO_DATA_AVAILABLE) { finished = true; } else if (e.LJUDError > LJUD.LJUDERROR.MIN_GROUP_ERROR) { finished = true; } else { showErrorMessage(e); } } } //Display Voltage Reading Console.Out.WriteLine("Analog {0:0}: {1:0.######}\n", (int)tempChannel, valueAIN); //Display the internal temperature sensor reading. This example uses //that value for cold junction compensation. Console.Out.WriteLine("U6 internal sensor: {0:0.0} deg K\n", (double)cjTempK); //To get the thermocouple voltage we subtract the offset from the AIN //voltage and divide by the LJTIA gain. tcVolts = (valueAIN - offsetVoltage) / 51; //Convert TC voltage to temperature. LJUD.TCVoltsToTemp(tcType, tcVolts, cjTempK, ref pTCTempK); //Display Temperature Console.Out.WriteLine("Thermocouple sensor: {0:0.0} deg K\n\n", pTCTempK); Thread.Sleep(1500); // Short pause keyPressed = Win32Interop._kbhit() != 0; // If a key was hit break out of the loop } }
public void performActions() { double dblValue = 0; //Open the first found LabJack U3. try { u3 = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB } catch (LabJackUDException e) { showErrorMessage(e); } try { //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //Set the Data line to FIO4, which is the default anyway. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SHT_DATA_CHANNEL, 4, 0); //Set the Clock line to FIO5, which is the default anyway. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.SHT_CLOCK_CHANNEL, 5, 0); //Set FIO6 to output-high to provide power to the EI-1050. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 6, 1, 0); } catch (LabJackUDException e) { showErrorMessage(e); } /* * //Use this code if only a single EI-1050 is connected. * // Connections for one probe: * // Red (Power) FIO6 * // Black (Ground) GND * // Green (Data) FIO4 * // White (Clock) FIO5 * // Brown (Enable) FIO6 * * try * { * //Now, an add/go/get block to get the temp & humidity at the same time. * //Request a temperature reading from the EI-1050. * LJUD.AddRequest (u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); * * //Request a humidity reading from the EI-1050. * LJUD.AddRequest (u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); * * //Execute the requests. Will take about 0.5 seconds with a USB high-high * //or Ethernet connection, and about 1.5 seconds with a normal USB connection. * LJUD.GoOne (u3.ljhandle); * * //Get the temperature reading. * LJUD.GetResult (u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg K\n",dblValue); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg C\n",(dblValue-273.15)); * Console.Out.WriteLine("Temp Probe A = {0:0.###} deg F\n",(((dblValue-273.15)*1.8)+32)); * * //Get the humidity reading. * LJUD.GetResult (u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); * Console.Out.WriteLine("RH Probe A = {0:0.###} percent\n\n",dblValue); * } * catch (LabJackUDException e) * { * showErrorMessage(e); * } * * //End of single probe code. */ ///* //Use this code if two EI-1050 probes are connected. // Connections for both probes: // Red (Power) FIO6 // Black (Ground) GND // Green (Data) FIO4 // White (Clock) FIO5 // // Probe A: // Brown (Enable) FIO7 // // Probe B: // Brown (Enable) DAC0 try { //Set FIO7 to output-low to disable probe A. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 7, 0, 0); //Set DAC0 to 0 volts to disable probe B. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_DAC, 0, 0.0, 0); //Set FIO7 to output-high to enable probe A. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 7, 1, 0); //Now, an add/go/get block to get the temp & humidity at the same time. //Request a temperature reading from the EI-1050. LJUD.AddRequest(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); //Request a humidity reading from the EI-1050. LJUD.AddRequest(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); //Execute the requests. Will take about 0.5 seconds with a USB high-high //or Ethernet connection, and about 1.5 seconds with a normal USB connection. LJUD.GoOne(u3.ljhandle); //Get the temperature reading. LJUD.GetResult(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg K\n", dblValue); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg C\n", (dblValue - 273.15)); Console.Out.WriteLine("Temp Probe A = {0:0.###} deg F\n", (((dblValue - 273.15) * 1.8) + 32)); //Get the humidity reading. LJUD.GetResult(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); Console.Out.WriteLine("RH Probe A = {0:0.###} percent\n\n", dblValue); //Set FIO7 to output-low to disable probe A. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_DIGITAL_BIT, (LJUD.CHANNEL) 7, 0, 0); //Set DAC0 to 3.3 volts to enable probe B. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_DAC, 0, 3.3, 0); //Since the DACs on the U3 are slower than the communication speed, //we put a delay here to make sure the DAC has time to rise to 3.3 volts //before communicating with the EI-1050. Thread.Sleep(30); //Wait 30 ms. //Now, an add/go/get block to get the temp & humidity at the same time. //Request a temperature reading from the EI-1050. LJUD.AddRequest(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, 0, 0, 0); //Request a humidity reading from the EI-1050. LJUD.AddRequest(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, 0, 0, 0); //Execute the requests. Will take about 0.5 seconds with a USB high-high //or Ethernet connection, and about 1.5 seconds with a normal USB connection. LJUD.GoOne(u3.ljhandle); //Get the temperature reading. LJUD.GetResult(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_TEMP, ref dblValue); Console.Out.WriteLine("Temp Probe B = {0:0.###} deg K\n", dblValue); Console.Out.WriteLine("Temp Probe B = {0:0.###} deg C\n", (dblValue - 273.15)); Console.Out.WriteLine("Temp Probe B = {0:0.###} deg F\n", (((dblValue - 273.15) * 1.8) + 32)); //Get the humidity reading. LJUD.GetResult(u3.ljhandle, LJUD.IO.SHT_GET_READING, LJUD.CHANNEL.SHT_RH, ref dblValue); Console.Out.WriteLine("RH Probe B = {0:0.###} percent\n\n", dblValue); //Set DAC0 to 0 volts to disable probe B. LJUD.ePut(u3.ljhandle, LJUD.IO.PUT_DAC, 0, 0.0, 0); //If we were going to loop and talk to probe A next, we would //want a delay here to make sure the DAC falls to 0 volts //before enabling probe A. Thread.Sleep(30); //Wait 30 ms. } catch (LabJackUDException e) { showErrorMessage(e); } //End of dual probe code. //*/ Console.ReadLine(); // Pause for user }
public void performActions() { LJUD.IO ioType = 0; LJUD.CHANNEL channel = 0; double dblValue = 0; // Variables to satisfy certain method signatures int dummyInt = 0; double dummyDouble = 0; double[] dummyDoubleArray = { 0 }; try { //Open the first found LabJack U3. u3 = new U3(LJUD.CONNECTION.USB, "0", true); // Connection through USB //Start by using the pin_configuration_reset IOType so that all //pin assignments are in the factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //First requests to configure the timer and counter. These will be //done with and add/go/get block. //Set the timer/counter pin offset to 4, which will put the first //timer/counter on FIO4. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_COUNTER_PIN_OFFSET, 4, 0, 0); //Use the 48 MHz timer clock base with divider. Since we are using clock with divisor //support, Counter0 is not available. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, (double)LJUD.TIMERCLOCKS.MHZ48_DIV, 0, 0); //LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_BASE, LJUD.TIMERCLOCKS.MHZ24_DIV, 0, 0); //Use this line instead for hardware rev 1.20. //Set the divisor to 48 so the actual timer clock is 1 MHz. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_DIVISOR, 48, 0, 0); //LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.TIMER_CLOCK_DIVISOR, 24, 0, 0); //Use this line instead for hardware rev 1.20. //Enable 1 timer. It will use FIO4. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_CONFIG, LJUD.CHANNEL.NUMBER_TIMERS_ENABLED, 1, 0, 0); //Configure Timer0 as 8-bit PWM. Frequency will be 1M/256 = 3906 Hz. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_MODE, 0, (double)LJUD.TIMERMODE.PWM8, 0, 0); //Set the PWM duty cycle to 50%. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_TIMER_VALUE, 0, 32768, 0, 0); //Enable Counter1. It will use FIO5 since 1 timer is enabled. LJUD.AddRequest(u3.ljhandle, LJUD.IO.PUT_COUNTER_ENABLE, 1, 1, 0, 0); //Execute the requests. LJUD.GoOne(u3.ljhandle); } catch (LabJackUDException e) { showErrorMessage(e); } //Get all the results just to check for errors. try { LJUD.GetFirstResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { showErrorMessage(e); } bool finished = false; while (!finished) { try { LJUD.GetNextResult(u3.ljhandle, ref ioType, ref channel, ref dblValue, ref dummyInt, ref dummyDouble); } catch (LabJackUDException e) { // If we get an error, report it. If the error is NO_MORE_DATA_AVAILABLE we are done if (e.LJUDError == UE9.LJUDERROR.NO_MORE_DATA_AVAILABLE) { finished = true; } else { showErrorMessage(e); } } } try { //Wait 1 second. Thread.Sleep(1000); //Request a read from the counter. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_COUNTER, (LJUD.CHANNEL) 1, ref dblValue, dummyDoubleArray); //This should read roughly 4k counts if FIO4 is shorted to FIO5. Console.Out.WriteLine("Counter = {0:0.0}\n", dblValue); //Wait 1 second. Thread.Sleep(1000); //Request a read from the counter. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_COUNTER, (LJUD.CHANNEL) 1, ref dblValue, dummyDoubleArray); //This should read about 3906 counts more than the previous read. Console.Out.WriteLine("Counter = {0:0.0}\n", dblValue); //Reset all pin assignments to factory default condition. LJUD.ePut(u3.ljhandle, LJUD.IO.PIN_CONFIGURATION_RESET, 0, 0, 0); //The PWM output sets FIO4 to output, so we do a read here to set //it to input. LJUD.eGet(u3.ljhandle, LJUD.IO.GET_DIGITAL_BIT, (LJUD.CHANNEL) 4, ref dblValue, dummyDoubleArray); } catch (LabJackUDException e) { showErrorMessage(e); } Console.ReadLine(); // Pause for user }