Using quadrature encoders with PXI-6025

Hi!,
We are using an encoder for position data. The encoder gives A and B pulses which are phase shifted by 90 deg.
Grating Pitch = 40 microns
We make the connection to our PXI-6025 as such:
Channel A pulse goes to PFI 8 (GPCTR_Source)
Channel B pulse goes to DIO6 (GP_Up_Down)
Ground goes to DGND
We are able to increment/decrement the counter on our 6025 for every 40 micron movement
However, we are unable to quad the input and increment/decrement for every 10 microns. How do we achieve this?
We have an electronic circuit which converts the 40 micron A and B pulse from the encoder into 4 pulses spaced at 10 microns. But, using this single pulse mode does not allow for up/down counting.
We are using LV-7.1
, NI-DAQ 7.2 and Win2000 prof.
Looking forward to some quick help.
Thanks,
Gurdas
Gurdas Singh
PhD. Candidate | Civil Engineering | NCSU.edu

There's one tedious way that might work if you only need to post-process the data. However there are several possible problems.
The idea is to perform buffered semi-period measurements with both the counters on the 6025. Once you've collected all the needed semi-period data, perform a cumulative sum of each array so you end up with timestamps for all the transitions. Then you'll need to go through them to distinguish (+) from (-) direction quadrature transitions and generate a cumulative position array.
I don't think there's another way -- only semiperiod measurements will react to both edges of an incoming pulse train. However, it *is* possible in principle to get your 4x factor in resolution. Now for the problem list:
1. Your 6025E only has 1 DMA channel. One of the counters will have to be configured to use interrupts, which in turn will limit the maximum encoder rate you can track. I wouldn't count on tracking better than single digits of kHz, and you may not even be able to achieve that much.
2. The last time I did semiperiods on an E-series board, there was no way to specify which edge would mark the first recognized transition. If the input was low when you started, the first transition recorded would be a rising edge; if high, then a falling edge.
Knowledge of the initial state of the inputs is critical for your software quadrature decoding. I think the solution I used was to parallel wire the A&B channels to a couple DIO pins which I inspected before any encoder motion started. If your encoder jitters or vibrates about its nominal position however, you're probably hosed.
Are you sure you can't use the LS7084 to replace your other external circuit? The alternatives are either going to be trouble-prone gimmicks like I described above or the purchase of new DAQ equipment.
If you have budget for new DAQ equipment from NI, I'd suggest you look into one of the following:
1. Low-cost M series multi-function board
These have 2 32-bit counters onboard that are capable of quadrature decode. Each counter gets its own DMA channel for buffered acquisition. Plus you get a bunch of analog in, timed digital i/o, and can get analog outs. The boards are $475 with 2 analog outputs, $375 with none.
2. dedicated counter/timer board
The 6601 is cheaper at $295, but is limited to 1 DMA channel and has a slower onboard timing clock. The 6602 costs about double that but gives you somewhat more than double capability.
-Kevin P.

Similar Messages

  • Wrong results using quadrature encoders with NI DAQCard-6036E

         Hello,
    I'm experiencing some troubles using two quadrature encoders with a NI multifunction I/O.
    The encoders are Micro-Epsilon WDS-7500-P115-CR-TTL. They are incremental encoders in TTL logic. They are connected to a HP laptop running Windows XP Professional. The connection is via the multifunction I/O NI DAQCard-6036E. Each encoder is connected to the DAQ board with four wires: +5V, DGND, track A, track B. I used the system in my office for a while and everything was fine. Then I moved it in another place and now it shows a fuzzy behaviour.
    I made the following tests:
    Test 1) I connect track A&B to analog inputs on the DAQ card. Then I use SignalExpress v2.5 to perform a DAQmx analog input acquisition. The waveforms I get are exactly as expected.
    Test 2) I connect track A to the counter source and I leave track B disconnected. I use SignalExpress v2.5 to set a DAQmx edge counter, with the "Count up" option enabled. Also this test is fine. When I pull the encoder cable I get +N counts and when I release the cable it goes back to zero position, giving other +N counts.
    Test 3) I connect track A to the counter source and track B to P0.6 (or P0.7 for the second encoder), which is the pin used to control the count direction. I use SignalExpress v2.5 to set a DAQmx edge counter, with "Count up". In this way the DAQ should ignore track B and count always up. Actually it does, but the count rate in one direction is double with respect to the count rate in the other direction. This means that when I pull the encoder cable I get +N counts and when I put it back to initial position I get other +2N counts. In this way the counter indicates +3N at the end, while it should be +2N.
    Test 4) I connect track A to the counter source and track B to P0.6 (or P0.7 for the second encoder). I use SignalExpress v2.5 to set an "Externally controlled" DAQmx edge counter. Now I get +N counts when I pull the encoder and -2N counts when I put it back to zero position. In this way the counter indicates -N  at the end, while it should be zero.
    Test 5) I repeat test 4 using LabWindows/CVI v8.1 and I get the same result.
    Test 6) I swap lines A&B. Now track B is connected to the counter source and track A goes to P0.6 (or P0.7 for the second encoder). Using SignalExpress to perform an "External controlled" count, I get +2N counts when I pull the encoder and -N counts when I put it back to zero. So, at the end the counter indicates +N, but it should be zero.
    Do you have any idea on how to solve the problem? Thank you very much in advance.

    A few things:
    1. I'm not from NI and won't try to speak for them.  But I don't believe these forums are meant as a primary means of support, probably not an *official* means of support at all.  Most of the folks here (like me) are NI's more-or-less satisfied customers, not employees.   If you buy a service contract, you can get instant phone support.  If you rely on free support from the forums, I think you'll get good help most of the time, but there's just no guarantee. 
    2. "I just got a [email] reply from MicroEpsilon.  The encoders work fine."   Um.  Based on what, exactly?  Of *course* they will expect their own stuff to be just fine, and in fact I very much suspect they're right.  But NI will expect their board to be just fine, and I expect they're right too.  Or at least it was fine *before* you hooked things up.  Leading us to #3.
    3.  Part of the app note on Quad Encoders on E-series boards warns against connecting differential encoder outputs directly to your board.  I think it mentions that a 24V differential (for example) can damage the board.  But even a low-voltage differential signal isn't electrically *compatible* with your counter inputs.  Your first posting claimed that the encoders produced TTL.  Your June 30 post referred to inverted A and B signals for rejecting common mode noise over long transmission lines.  These are classic code words that scream "differential output", *not* TTL.  So now we can start addressing some specific tech issues.
    4. Your E-series board is not inherently capable of handling true quadrature, as the app note says.  (The newer M-series multifunction boards *do* have the capability.)  You can get kinda sorta close, but you'll be at risk of count errors due to direction changes or during vibrations when otherwise stationary.
    5. You will also need some type of differential to TTL conversion on your (A, /A) and (B, /B) pairs.
    6. You will need a common "ground" reference for all your digital signals (probably not a true earth ground).  So the ground for your conversion circuit and its TTL outputs must be tied to your DAQ board digital ground.  Also the return terminal from any related external power supply.  Sounds like failure to do this had been an issue with a past implementation of yours so perhaps it's an additional factor at play this time too?
    7.  What are you trying to measure?  For what purpose?  What decision is made from the data?  How much do you care about its accuracy?  These are leading questions, but I'm suggesting that meeting schedule with an unreliable app that produces untrustworthy data just might not be the best goal to strive for right now.  If you care to maintain accurate position count despite direction changes or vibrations, you *need* something more than your E-series board.  If you want reliable edge counting operation with *any* DAQ board, you *need* electrically compatible signals.
    -Kevin P.

  • Using Quadrature encoders

    Hi,
    I'm using a quadrature encoders with a PCI6025E board to measure an angle,
    I want to use the COUNTER1 so I have connected line A of the encoder to PFI_3 and Line B of the encoder to LINE DIO7.
    I have configure the 6025E with this code to read the counter 1 value :
    status = GPCTR_Control(1, ND_COUNTER_1, ND_RESET);
    status = GPCTR_Set_Application(1, ND_COUNTER_1, ND_SIMPLE_EVENT_CNT);
    status = GPCTR_Change_Parameter(1, ND_COUNTER_1, ND_SOURCE, ND_PFI_3);
    status = GPCTR_Change_Parameter(1, ND_COUNTER_1, ND_UP_DOWN,ND_HARDWARE);
    status = GPCTR_Control(1, ND_COUNTER_1, ND_PROGRAM);
    All the status code return by this functions are 0 and so OK.
    But when I Get the counter value with GPCTR_Wathch().
    When i tur
    n the encoder in one way it count up well, but when i turn the encoder in the other way (down) I read a count that is is two times more than the count up (count down = 2 * count up) !!!!
    Does someone have meet this problem before?
    Any solution to solve this problem ?
    Thanks.
    dpasssounaud

    Hello,
    Your programmation seems to be OK. And the connections too.
    Please, test the program in the attached file and tell me about the results.
    Sanaa T
    National Instruments
    Attachments:
    Mes_Ang.zip ‏5 KB

  • Measure Angular Position using quadrature encoders

    Hi I’m new to LabView and NI and would like to know whether the angular position, measured using two quadrature encoders can be measured (and interfaced with LabView) using the following National Instruments hardware:
    NI cRIO-9014 (CompactRIO Real-Time Controller)
    NI-9403
    NI-9215
    NI-9263
    If it can be done I would really appreciate some pointers or suggestions of how to start either setting the hardware up or writing the LabView program.
    Many Thanks
    Alex

    Hi Alex
    Welcome to the world of LabVIEW and NI. You're off to a great start with the hardware and software that you already have. It sounds like you just need a bit of extra knowledge to get you started. A great place to look for help is in the LabVIEW  Find Examples.. This can be found on the LabVIEW splash screen pictured in the attached image.
    For your specific set up I would also suggest navigating to the following links:
    NI CompactRIO Starter Kit and Hardware Setup Wizard Frequently Asked Questions (FAQ)
    It may well be an idea for you to attend one of our customer education courses which would really give you a headstart in your application. Information regarding this can be found here:
    LabVIEW Real-Time training
    I hope this information is of some help to get you started.
    Kind regards,
    Daniel T
    Applications Engineer
    National Instruments UK & Ireland
    Attachments:
    Find examples.PNG ‏253 KB

  • RPM Measurement using Quadrature Encoder and PXI 6602 counter

    Hi,
    I am on a project at work where I need to verify the speed (in RPM) of an unloaded motor which can operate up to 1400 rpm.  After doing some research, i determined that a quadrature encoder could be used to make the measurement.  I am looking at this encoder  http://sine.ni.com/nips/cds/view/p/lang/en/nid/205321.
    I have a PXI 6602 counter/timer module in which I would like to interface to the quadrature encoder.  I would like to create a VI that allows me to calculate the speed using the encoder.  Can someone provide me with details of what needs to be in the VI or an example which can do this?  At the most basic level, i want to calculate the speed on demand.  After doing this, i would like to figure out how to quickly calculate the speed so that i can determine response time of the speed changing within sub-millisecond resolution (1 ms resolution max).
    Further, i created a VI that allows me to change the pulse width of a 100 Hz pulse train at run-time which tells the motor controller the desired speed.  I would like to be able to use this VI to change the speed of the motor and the first VI (that I am seeking help about) to calculate the response time (time between the initial speed and settling at the new setpoint).
    I am familiar with the NI example finder, but have not been able to find an example that I can use.
    Thanks,
    Gary

    Hey Gary,
    I think for you setup, you should try using the Meas Dig Frequency - Low Freq 1 ctr. You can find it by searching example finder with 'low freq'. This vi tells you the frequency of a digital signal by sampling between two pulses and inverting the time between pulses. If you hook up your encoder to a counter and have that counter specified in the vi, it will be able to give you on demand readings of frequency (you can do some multiplication to get the rpm value, freq*60/pulses per revolution of encoder). A simple way to take continuous readings is to put a while loop around the daqmx read and the data output of the read. You can also replace the numeric indicator to a waveform chart to graphically display the change of frequency or rpm readings over time.
    You should be able to integrate this as two separate tasks with the pulse train vi you created earlier.
    Hope this helps
    Luke W

  • Multirate sampling using CLK IN with PXIe-5922

    Hi
    I am working in an application where I need to change the sampling rate of an acquisition between 500 ks and 5 Ms without stopping the acquisition. The idea is to be acquiring continuously and be able to change the sampling frequency live depending on external events
    I was thinking about doing this using a PXIe-5922 and controlling its sampling frequency using the external sample clock input (maybe I would have to change the decimation factor by software as well?) connected to a signal generator (5404?) or some other clock generator whose frequency I can change without stopping the signal (maybe some specific development on PXI-7833R). My concerns are:
    Reading the 5922 spes I am not sure if I can change its sampling frequency between those values (500 kHz and 5 Mhz) using the external sample clock input without stopping the acquisition (my experience with other DAQ is that when you have to do any programming of the instrument the acquisition stops during the programming phase)
    If the above can be done, I guess my second problem will be to determine in the acquired data where a change of the sampling frequency has happened (as the driver will not know if I am using an external clock)… but I am not yet much worried because of this J
    I have not buy the hardware yet until I am sure I am in the right way... so any help will be much appreciated
    Best regards
    Guillermo

    Guillermo,
    Keep in mind the Reference Clock is used to generate the internal Sample Clock.  Changing the frequency of the Reference Clock will result in the same Sample Clock frequency.  Also, changing the Reference Clock frequency should not be done while acquiring since the device's clock circuitry needs to be configured based on the Reference Clock frequency.  I don't think this solution will produce desirable results for these reasons.  Unfortunately, the 5922 does not accept an external Sample clock from the Clock In terminal since the Sample Clock needs to be extremely high quality to meet the device's specifications.
    Do you really need to run continuously across different sampling rates, or could you afford a small amount of reconfiguration time between frequencies?  If you can, then you can also avoid the additional complication of not knowing where in your acquisition the sampling rate changed.  Could your application run continuously, then reconfigure the sampling rate when a trigger is received?
    Jeff B.
    NI R&D Group Manager

  • Using PCI-6025E with quadrature encoder.

    Hi,
    i'm presently trying to figure out if i can use the PCI-6025E Card to count up/down with a quadrature encoder with no additionnal hardware. I know my answer lies in a document called "Using Quadrature Encoders with E Series DAQ Boards document " but it is not presently available on the ni website.
    Can any1 either confirm me that i can do this or send me the document?
    Thank you,
    Max

    This link seems to confirm that you can
    Link
    Randall Pursley

  • Quadrature encoder with PCI-6259 DAQ board (driver for QNX)

    where can I find any example for connecting Quadrature Encoders with M Series DAQ Boards ?
    The only more or less suitable example I found in nimseries DDK, is
    "Count pulses from an external source using an external signal to control
    the count direction" (nimseries\Examples\gpctex2.cpp).
    But this example is not working correctly with Quadrature Encoders
    (encoders with  two shifted on 90 degrees phases A&B).
    i.e. in case of using this example code I get some extra count while encoder is on vibrant motor
    what means enums
    typedef enum {
           kG0_Up_DownHardware          = 2,
           kG0_Up_DownHardware_Gate     = 3,
    } tG0_Up_Down;
    and
    typedef enum {
           kG0_Encoder_Counting_ModeId          = 1,
    } tId;
    in (nimseries\ChipObjects\tTIO.h) ?
    What initalization procedure I need to work with Quadrature Encoders?
    I have PCI-6259 DAQ device
    and I'm writing programm under QNX6 operating system

    Hello alexey_3269,
    If you want to read a quadrature encoder start with gpctex1.cpp and follow the thread.
    I give you my code:
    BEGIN CODE
    ==========
    boardGpct->G0_Mode.writeG0_Load_Source_Select(tTIO​::tG0_Mode::kG0_Load_Source_SelectLoad_A);
    boardGpct->G0_Load_A.writeRegister(InitialCount);
    boardGpct->G0_Command.writeG0_Load(1);
    boardGpct->G0_Load_B.writeRegister(0);
    boardGpct->G0_Load_A.writeRegister(0);
    boardGpct->G0_Input_Select.setG0_Source_Select(9); //see above for choices, PFI8=9, 100 kHZ=18
    boardGpct->G0_Input_Select.setG0_Source_Polarity(1​); //0=CCW, 1=CW
    //If using 80 MHz timebase
    boardGpct->G0_MSeries_Counting_Mode.writeG0_MSerie​s_Alternate_Synchronization(1);
    boardGpct->G0_MSeries_Counting_Mode.setG0_MSeries_​Encoder_Counting_Mode(3);  //3 for X4 encoder counting
    boardGpct->G0_MSeries_Counting_Mode.flush();
    //Enable Input Pins
    boardGpct->G0_MSeries_ABZ.setG0_A_Select(9);  //PFI8=9,
    boardGpct->G0_MSeries_ABZ.setG0_B_Select(21); //PFI10=21
    boardGpct->G0_MSeries_ABZ.setG0_Z_Select(10); //PFI9=10 
    boardGpct->G0_MSeries_ABZ.flush();
    boardGpct->G0_Mode.setG0_Gate_Polarity(1); //invert=1
    boardGpct->G0_Mode.setG0_Output_Mode(tTIO::tG0_Mod​e::kG0_Output_ModePulse);
    boardGpct->G0_Mode.setG0_Loading_On_Gate(tTIO::tG0​_Mode::kG0_Loading_On_GateNo_Reload);
    boardGpct->G0_Mode.setG0_Loading_On_TC(tTIO::tG0_M​ode::kG0_Loading_On_TCRollover_On_TC);
    boardGpct->G0_Mode.setG0_Gating_Mode(tTIO::tG0_Mod​e::kG0_Gating_ModeLevel_Gating); //kG0_Gating_ModeGating_Disabled
    boardGpct->G0_Mode.setG0_Gate_On_Both_Edges(tTIO::​tG0_Mode::kG0_Gate_On_Both_EdgesBoth_Edges_Disable​d);
    boardGpct->G0_Mode.setG0_Trigger_Mode_For_Edge_Gat​e(tTIO::tG0_Mode::kG0_Trigger_Mode_For_Edge_GateGa​te_Starts_TC_Stops);
    boardGpct->G0_Mode.setG0_Stop_Mode(tTIO::tG0_Mode:​:kG0_Stop_ModeStop_On_Gate);
    boardGpct->G0_Mode.setG0_Counting_Once(tTIO::tG0_M​ode::kG0_Counting_OnceNo_HW_Disarm);
    boardGpct->G0_Mode.setG0_Reload_Source_Switching(t​TIO::tG0_Mode::kG0_Reload_Source_SwitchingAlternat​e);
    boardGpct->G0_Mode.flush();
    boardGpct->G0_Command.setG0_Up_Down(tTIO::tG0_Comm​and::kG0_Up_DownHardware); //kG0_Up_DownSoftware_Down
    boardGpct->G0_Command.setG0_Bank_Switch_Enable(tTI​O::tG0_Command::kG0_Bank_Switch_EnableBank_X);
    boardGpct->G0_Command.setG0_Bank_Switch_Mode(tTIO:​:tG0_Command::kG0_Bank_Switch_ModeGate);
    boardGpct->G0_Command.flush();
    boardGpct->Interrupt_G0_Enable.setG0_TC_Interrupt_​Enable(0);
    boardGpct->Interrupt_G0_Enable.setG0_Gate_Interrup​t_Enable(0);
    boardGpct->Interrupt_G0_Enable.flush();
    END CODE
    ========
    I hope this code is appropriate to you.
    FV1234

  • Can I connect a SCXI 1000 with PCI 6025 ?

    Can I connect a SCXI 1000 with PCI 6025 and use Virtual Banch with PCI 6025 ?

    Bley,
    Yes, you can use your PCI-6025E and SCXI-1000 with Virtual Bench. Do you have a more specific concern? Have you tried this setup, and it is not working?
    Spencer S.

  • Quadrature Encoder measurements with PXI-6143 S-Series DAQ

    Has anyone used a S-series PXI-6143 DAQ to take encoder position measurements? I believe there are 2 counters available, if you have any examples of how to access and read from these counters it would be greatly appreciated.

    Hi Bentup,
    Measuring a quadrature encoder on your device is actually going to be a bit different than on an M series device.  The STC-2 chip, which is used in the M series, allows for A and B inputs specifically for encoder signals (used in the Angular Encoder task).  The original STC-1 chip which is used in E series and most S series boards (including your 6143) does not have these same inputs.  Instead, you may must a Count Digital Events task (taking advantage of the up/down line of the counter).  The Angular Encoder task is not supported on STC-1 devices.
    The article that lab_boy linked earlier actually mentions how to use an encoder with an E series device once you scroll down a bit (here's the link again).  This same procedure should apply to your S series--connect the A output of your encoder to the source of the Counter (this is the signal that you are counting).  Connect B to the up/down line of the counter (P0.6 and P0.7 for counter 0 and 1 respectively). 
    The downside with this method is that it is more susceptible to vibrations or noise on the encoder lines. If this is a problem for you, you can look into an external encoder conditioner like the one mentioned in the article.  I hope this helps!
    Best Regards,
    John
    John Passiak

  • How can I use the NI PXI-6508 with Lab View 7? what are the first steps to get started??How can I use the channels with lab view 7????

    I have a 8 slot PXI system with 2 NI PXI 6508 and 1 DMM 4070 in it. I want to get started with programming the digital I/O cards (6508)! How can I use this cards with LabView 7?what is the best way to get started, or where can I get examples showing how to use the several channels?
    Thanks!
    Philipp

    Philipp,
    The best way to get started is to decide if you want to use traditional NI-DAQ or NI-DAQmx. Recently we released NI-DAQ 7.1 which provides NI-DAQmx support for the PXI-6508. In my opinion, NI-DAQmx is more efficient and much easier to use.
    To get started with examples, simply launch LabVIEW and go to Help>>Find Examples. Then expand Hardware Input and Output>>DAQmx and select the appropriate digital group for your application. This should help get you started.
    Please repost if you need addition assistance. Good luck with your application!

  • Can I use SH68-68S cable with PXI-4351?

    I'm trying to figure out which cables are actually compatible with PXI-4351 and TC-2190
    Will a SH68-68S work?
    thanks!

    Hey Grocket,
    I apologize for the delay in any response.
    It appears that the TC 2190 is only compatible with the SH68-68 cable. The product manual only suggests using that cable.
    The SH68-68-S is only compatible with TBX-68S, CB-68LP, and NI 2501/NI 2503.
    Let us know if there is anything else we can clarify for you!
    Happy Holidays! 
    J Newk
    Systems Engineer
    National Instruments

  • Huge latency reading quadrature encoders

    I'm using a PCI-6601 to read two quadrature encoders on a pan-tilt mechanism. The software uses the DAQmx C interface and polls the encoder positions at 200Hz. The problem is that there appears to be a huge latency on the order of ~50msec between when the encoders move and when the positions being read out reflect the movement. That can't be normal.... is it?
    I am able to get data off the DAQ at the 200Hz rate, and the values all look reasonable except that they're time delayed by the aforementioned 50ms. So I'm getting a resolution of at least 5ms, just time-shifted. The first thought was that the values were being buffered somehow, but there doesn't appear to be any buffer, at least that I can find. As I understand it quadrature input shouldn't be being buffered in the first place, and in any case a buffer should be read out with the call to DAQmxReadCounterF64 (the DAQ returns only 1 value), and indeed explicitly setting the input buffer via DAQmxCfgInputBuffer does nothing. 
    To double check the results I tested NI's sample code for reading quadrature encoders (http://zone.ni.com/devzone/cda/epd/p/id/5735) and I get the same latency (minus the ~5ms that was caused by the 200Hz timer, as the sample code polls in a tight loop.)
    Any idea of what might be going on here?
    Thanks!
    Gene

    Hi Gene,
    I just wanted to make sure you were indeed using DAQmx (since you linked the DAQmx Base example).  I might expect the DAQmx Base version of the code to take longer to execute, but re-reading your post it sounds like the problem isn't with the code keeping up but rather that the values themselves are delayed by ~50 ms.
    A buffer would only be allocated if you configure sample clock timing on your encoder task.  The example you linked doesn't do this, so I'll assume your code doesn't either.  It's probably worth noting that you can configure a hardware-timed sample clock so you can deterministically sample the count register at regular intervals, but this isn't going to help with latency.
    So taking a step back for a moment, I am now curious on how you are measuring the 50 ms latency.  To verify a 50 ms delay would require measuring the actual time difference between the start of the counter task and the first pulse of the encoder and then comparing the measured time with the time you are seeing in software (assuming ~5 ms per sample from your 200 Hz polling loop).  I would not expect a 50 ms latency in your measurement, so it's probably worth elaborating on exactly what you are seeing and how you are characterizing it.
    Best Regards,
    John Passiak

  • Internal error: "memory.cpp", line 593 with PXI 8175

    Hi,
    I have created a program with Labview RT 7.0 which makes acquisition, storage and display of data with PXI controllers 8175.
    I used Datasocket for the data display on a deported computer.
    Because of the number of the Datasocket tags used, instead of sending values all the time, I'm sending value for the deported computer only if the user needs to see it.
    For example : if the user needs to see data, so only Datasocket tags for data display will be active, and if the user needs to see parameters values, so only parameters datasockets tags will be active. And, if the display program is in "standby" mode, almost all datasocket aren't active.
    So when the user needs to see data values, he opens the data values window of the display program, and then, the datasockets tags for data value are now active, but : sometimes at this moment, the PXI stops with an "internal error "memory.cpp" line 593"!
    The only solution is to manually reboot the PXI, the programmatically reboot doesn't work in this case of error. But it is far away from the displaying computer.
    The error happens regularly after a 2 weeks period of standby. So I though about a memory overflow, I checked all the arrays, and none of them is growing to the infinity.
    If someone knows about this problem, I will be very happy to learn about how to get rid of it!!!
    Best Regards,
    G Liagre
    Best regards,
    G Liagre

    Hi Rob, Hi Matthieu,
    Thank you for your reply.
    I found in the database many reply about this error, but none of them were helpfull for me.
    I tryed your link to the knowledge data base, but the error described there is for dll association in LabView and interface nodes.
    I didn't used any interface node in my code.
    The problem is that I cannot test my program on the PXI because I don't have access to it rightnow (only by remote desktop, and with a 56k modem..)
    Let me give you a part of this huge code.
    I suspect this part of the code to be the one which create the problem, but it's not sure.
    If you find something obviously wrong, tell me!
    Best regards,
    G Liagre
    Best regards,
    G Liagre
    Attachments:
    Communication.zip ‏931 KB

  • Quadrature encoder with a non-NI board

    I am attempting use an encoder with a non-NI board (Measurement Computing) and I am unsure how to interface the encoder output from the board with LabView. I have the VIs for the board which allow the board to interface with LabView,. I essentially need a VI to decode the quadrature, the ones in the tutorials were not very helpful or insightful.

    Hello Mystery,
    Take a look at the section “Velocity and Acceleration Calculations” in this devzone.  While the article itself applies to CompactRIO, the equations used in the above section can help you determine how to convert the counter output into a velocity measurement. 
    Does the counter value increase when you rotate the encoder in one direction and decrease when you rotate in the other direction?  This is essentially position measurement.  By knowing the number of ticks per revolution as well as the starting position of the encoder, you can determine the current rotation position.  For velocity, there is a little more to the measurement.  The concept relies on taking a counter measurement in a periodic manner.  Then you can use the number of encoder pulses that have occurred over that period of time to calculate velocity.  The document I linked about shows how to convert the number of encoder pulses over a fixed period of time into RPM which can be later converted into angular velocity.  Hope this helps. 
    Regards,
    Browning G
    FlexRIO R&D

Maybe you are looking for

  • CS5.5 on Mountain Lion (PowerPC error)

    Hellow all,  I'm hoping someone might be able to advise me on this. I am installing CS5.5 Design Premium on Mac OSX v10.8.2 Mountain Lion.  The Mac is mid-2011 3.1GHz Intel Core i5.  The problem is I keep receiving the error message "You can't open t

  • Ipod touch 5th gen front camera/flashlight stopped working?

    when i open up the camera app it just freeze and turns me back to main menu. flashlight didnt work either i did a research on the forums and foudn some solutions, and i managed to get the front camera one time to work. but i couldnt get it anymore. w

  • Where is the dads.conf for Apex

    I have installed 11.0.2 on windows 32bit. I have installed the APEX software. I can get to the instace admin pages using the URL http://localhost:8080/apex But I cannot find the dads.conf on my c drive .. I did a search on the whole drive. From what

  • Error al iniciar Photoshop

    Cuando inicio el Photoshop CS 2 (9) recivo el siguiente error: "could not initialize Photoshop because the file could not be found" Lo mismo me pasa con el CS (version 8 ). el ImageReady funciona perfectamente, pero no puedo trabajar con Phtoshop. de

  • Interface connectivity ALE

    We are setting up an interface between ERP and  decentralised WMS system.. Both the systems are SAP systems but belong to two different companys' what kind of interface will be suitable for this... I meant will ALE/BAPI interface be sufficient...? Wh