Quadrature encoder interface to PCI-6229

Using PCI-6229 with LV7.1.
I need to connect an incremental quadrature encoder ( A,B and Z )
signals directly to the card and use the CTR0 to give me the angular
position information. Encoder is a 2500ppr type.
As per the specification summary of the PCI-6229 card, this is
possible. If so which terminals to use ? ( I have also posted a
similiar query in the other hardware forum )
can someone help me out in this ?
Thanks
Raghunathan
Raghunathan
LV2012 to Automate Hydraulic Test rigs.

Dear David,
the search terms that you gave helped a lot also. I could get sample code for checkout of an encoder with LV7.1. Good.
I am not sur eif you have actually worked with the encoder + LV
combination. Normally any optical encoder will produce high
frequency jitter if it happens to stop just at the point of transition
of either the A or B channel . I do suppose that the DAQmx VI
will handle this and not produce spurious counts - or do I need to
configure a filter for the relevant PFI lines ?
Thanks
Raghunathan
Raghunathan
LV2012 to Automate Hydraulic Test rigs.

Similar Messages

FPGA programming for motor control using free downloadable IP cores for PWM and Quadrature encoder interfacing

Hi,
I have a cRIO-9014 with a NI9505 DC brushed servo drive module, and I would like to program the FPGA for PWM and Quadrature encoder interfacing using the intellectual property IP functions mentioned in the "CompactRIO Motor Control Basics Tutorial":
Quadrature Encoder dX Method (FPGA, Use in SCTL).vi
Pulse Width Modulation (FPGA, Use in SCTL).vi
I made a search at ni.com/ipnet but I couldn't find them.
Where can I find free downloadable IP cores for PWM and encoder blocks to include them in my FPGA interface program?
Thanking you in advance,
Manuel
Solved!
Go to Solution.

Found by myself (google search!) at:
https://lumen.ni.com/nicif/us/codepowelecguide/content.xhtml

Read RPM from Quadrature Encoder

Hi Everyone,
I wish to measure the RPM of a shaft using a quadrature encoder and a PCI-6259 card. I've seen a few examples on reading position, which i have managed to get working, but Im not sure on how to get RPM. Any tips or code examples would be greatly appreciated.
Thanks,
David

Hi All-
Thanks for the suggestion DJ, but your VI will not work as it is written using the Traditional (Legacy) NI-DAQ driver and David's M Series card is only compatible with the NI-DAQmx driver.
To answer David's question, it is not possible to directly measure position and count edges at the same time. What you can do is count edges with external Up/Down control (basically the same as a X1 encoder) and then use the edge counting to calculate both frequency and displacement in ticks/degrees/RPM/etc. I have attached an example I did recently that shows how to use an edge count with external Up/Down control (i.e. PFI10 or PFI11 for M Series ctr0 or ctr1, respectively) provided by the 'B' phase signal and the 'A' phase provided to the counter source.
Hopefully this helps-
Tom W
National Instruments
Attachments:
32bit_Cnt_Edges_to_Quad.vi ‏73 KB

How do I use a quadrature encoder as an external clock (PCI 6229)

Hello, ( a similar post has been placed on DAQ forum apologies as I did not know best place)
I have a PCI 6229 M Series data acquisition card. I want to use a quadrature encoder to be the external clock driving the acquisition of a number of signals. I have set up reading 24 signals each time a clock pulse is received using the DAQ assistant and set my external clock to pin pfi8 (I think) this is then connected to an encoder output. This works well enough until the encoder is run too fast when it appears I am either missing pulses or getting bounce.
How can I set up to clock using a quadrature encoder? I have seen a number of questions on this forum regarding quadrature encoders and reverse counting but not on using them as an external clock.
Basically I want to have the stability and "bounceless" nature of using two outputs from a quadrature encoder whilst still using an external clock. Is this just a case of configuring controls to certain pfi's? If so how is it done?
Any help or pointers would be helpful. So far I have managed very nicely by simply using the DAQ assistant and the interface it has would suggest that if configured for a certain pfi pin I could actually still use it.
Thanks in advance.
Kevin

Hi,
Well I've had alook into this for you and I'm not quite sure I understand what you are looking for.
Is it possible for you to phone back in to support?
The reason you are seeing bounce at high speeds, or indeed loss of points, is due to the sampling rate that you have set up.
What you will find is that the trigger will start an aquisition of a number of points at a certain rate. If your sampling rate is too low then you will not finish that sample batch before the next set of samples is recorded.
It is possible to use an external clock into a trigger or digital line, however this will limit the number of samples you can take to the speed of your encoder.
If you increase your sampling rates, and then configure a start trigger from a single input from the encoder you will be able to record a number of samples after a rising/falling edge. (Set the clock as an internal clock)
Hope this helps
AdamB
Applications Engineering Team Leader | National Instruments | UK & Ireland

How to route Quadrature Encoder signal to CC1 using PCIe 1429 + IO extension card

Hi there,
i am currently trying to interface the Basler L304kc to the NI PCIe 1429 + Cameralink IO extension board
I want to operate the camera in Ex-SYNC level controlled mode. I would like to route external Quadrature Encoder signals (connected to the IO extension board) to the CC1 cameralink control of the camera
Currently, I cannot find this option either in MAX or the Camera File Generator.The L304kc camera file only provides pre-defined pulses, or MAX only offers "External","ISO","RSTI" options for the CC1 sources.
Is it possible to route the encoder signal from the IO extension board directly to the CC1 of the camera? Or is there a work-around?
Thanks!
Derek Chan
Application Engineer
Basler Asia Pte Ltd

Hi Alex,
I posted the following (similar) text to the support center but I think it is of common interest:
A) CL-card with ext. board. One can use the ISO, ext. and RS422 encoder inputs and also output cannels ISO and external.
There is also a SMB connector corresponding to the ext. channel 0.
B) with MAX one can define what kind of signals should be routed to CC1 to CC4. As I learned from
this side one cannot use MAX or the Camera File generator but has to do this manually in order to use RS422 encoder triggering!!!
C) on the other side there exists function to route and control signals explicitely, for example
* imgSessionLineTrigSource2 -> what is this good for then? All your manuals are saying that this is done in MAX or the camera file by defining what signal drives the correspondung CC ine?? On the other side there is an example in CVI that does not work ("Trigger Each Line From Encoder") (at least it does not work with the PCIe1430).
D) Can one implement the CC routing from MAX or the camera file manually with the following functions
* imgSessionLineTrigSource2
* imgPulseCreate2
* imgSessionTriggerDrive2
or does MAX use hidden functions ore mechanism to control the CL Cards?
E) I can use one single line to setup scaled encoder triggering
* imgSessionLineTrigSource2(iLS_ZK1_SessionID, IMG_SIGNAL_SCALED_ENCODER, 0, IMG_TRIG_POLAR_ACTIVEH, 0);
but this only starts to work if I reset the encoder position to zero by sending this to the CL card, i.e.
* imgEncoderResetPosition(SessionID);
AND only in positive counting direction!
If I just run though the zero position without a position reset I do not get ExSync on CC1????
Is the information where to route the Scaled encoder to coming from the camera file? Why cannot I simply and explicitely route the scaled encoder
signal to a certain CC line? Why using all those different approaches?
F) now if in addition to E) i use
* imgSessionTriggerDrive2(iLS_ZK1_SessionID, IMG_SIGNAL_EXTERNAL, 0, IMG_TRIG_POLAR_ACTIVEH, IMG_TRIG_DRIVE_SCALED_ENCODER);
to drive ext. 0 (SMB connector) I can see exactly this behavior on the scope. No signal until I reset the encoder counter. Then I get signals as long as the image sequence is running. After the recording the signal disappears.
kind regards, Holger h.baur(at)ivisso.com

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_MSeries_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_Mode::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_Mode::kG0_Loading_On_TCRollover_On_TC);
boardGpct->G0_Mode.setG0_Gating_Mode(tTIO::tG0_Mode::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_Disabled);
boardGpct->G0_Mode.setG0_Trigger_Mode_For_Edge_Gate(tTIO::tG0_Mode::kG0_Trigger_Mode_For_Edge_GateGate_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_Mode::kG0_Counting_OnceNo_HW_Disarm);
boardGpct->G0_Mode.setG0_Reload_Source_Switching(tTIO::tG0_Mode::kG0_Reload_Source_SwitchingAlternate);
boardGpct->G0_Mode.flush();
boardGpct->G0_Command.setG0_Up_Down(tTIO::tG0_Command::kG0_Up_DownHardware); //kG0_Up_DownSoftware_Down
boardGpct->G0_Command.setG0_Bank_Switch_Enable(tTIO::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_Interrupt_Enable(0);
boardGpct->Interrupt_G0_Enable.flush();
END CODE
========
I hope this code is appropriate to you.
FV1234

Do I need extra logic circuit for quadrature encoder using M-series DAQ PCI-6221?

Hi,
I understand that extra logic circuit, say quadrature clock converter LS7083/7084, is needed to enchance the reliability or integrity of the data for E-series board DAQ in accordance to application note: AN084.
This is due to the vibration/jitter of the motor during running.
Currently, I'm using M-series PCI-6221.
Is it this new model itself can eliminate to construct this extra circuit?
Coz I observed error is accumulating after motor rotating certain period of time. It defintely affect the control performance.
Other than using hardware, can we use software to eliminate/mitigate the error?
Please enlighten me. Thanks.
Best regards,
IANES

Hello,
The ap note you are referring to discusses circuitry that conditions the quadrature encoder signals before they get to the DAQ device to eliminate 'false' signals being sent to the DAQ device. The same system would apply to an M Series Device. I am not aware of any way to achieve this functionality in software. FYI, there is some good documentation for counters and counter applications for M Series. Take a look at the attached M Series help file. Hope this helps some.
-Alan A.
Attachments:
M_Series_Help.zip ‏1145 KB

Reading Angles From a Line Driver Quadrature Encoder

I currently have a Quadrature Encoder (Line Drive) and am trying to interface it with a PCI-6602 Counter/Timer Card. I have currently had no luck in correctly hooking it up and reading the angle. Past experience with Quadrature Encoder have all been open collector; I have been able to to successfully hook up an open collector encoder with the 6602.
Any help in hooking up the Line Driver encoder with the PCI6602 would be appreciated.
Thanks.

Justin,
Normally, the mfgr. would include a recommended "Line Receiver" interface circuit for the encoder. I've found that some line-driver encoders actually can be successfully connected directly to the 6602 for quick-and-dirty testing, though you wouldn't want to wire that up arbirtrarily or rely on it for the long term. In any event, it sounds like you'll need to add a line receiver interface.
-Kevin P.

How to calibrate Quadrature Encoder signal

I have PCI-6601 and CB68-LP connector. How can I use these to interpret quadrature signals coming off an optical encoder (to sense the angular position of an-observatory dome). The encoder is 16-bit(don't know what this means in terms of PPR). I want to have a display in Labview that will show me the position of the dome in a fraction of 360 degrees with some reference(true north?), the dome rotation controlled by a three way switch(clockwise-off-anti-clockwise). I don't have much experience with labview and any help will be appreciated.

If the encoder is 16 bit then it would seem that: -
360/65536 = 0.0054931640625° or there abouts.
You can break the project down into two halves nicely.
1) Hardware interfacing.
2) Software read out.
The hardware interfacing means two basic things:
1.1 What is the encoding technique
1.2 How are the signals conditioned for output to an external device.
The software is classic:
2.1 Input
2.2 Process
2.3 Output
The optical encoder could be one of a few types and you need to understand both the signalling / interface and the coding technique to progress further. A good start will be the manufacturers data sheet for the product. Contact the manufacturer.
Once you understand the coding technique you will then know if the unit is absolute or relati
ve. This will then allow you to determine how you can point to true north (easily with an absolute encoder, it always tells you exactly where it is).
If it is a classic quadrature encoder then the relative phase of the reference and movement signals gives you direction. Counting transitions gives you realtive movement. But if the power went off on the PC. you don't know where you are unless you go to a home position! That could be 359° round !!!
Good Luck

Can I use the 'Export Signal Property Node' on a quadrature encoder?

Hi,
So I don't know which counter board I'd be using yet for this (it's used in conjunction with a PCI-6280--the PCI-6280's counter inputs are all taken and so I need another board), but assuming this is possible at all in DAQmx I wouldn't mind knowing whether, say, the PCI-6601 (or any other timer board for that matter) could do this. I'm programming this in LabVIEW 2010 by the way.
I want to have a counter which counts the number of pulses on one channel (I'll call this the 'clock' channel) between when another channel goes from low to high (which I'll call the trigger). It's basically a pulse width measurement, but I only care if there are more than n clock pulses between triggers. I need to have a hardware-timed digital signal which goes from low to high if there are ever more than n pulses between trigger changing state from low to high.
What I am planning to do is this:
Wire 'trigger' to the z-input of the quadrature encoder, and set the z-input value to some arbitrary large value such that, at the quadrature encoder counter task's settings, the counter reaches terminal count in n pulses.
Configure the quadrature encoder counter using DAQmx Export Signal Property Node (tutorial I was looking at is here: http://zone.ni.com/devzone/cda/tut/p/id/5387 ) to toggle a digital channel ('counter event output') from low to high if the counter reaches terminal count (ie, if the encoder reads n pulses).
If the encoder ever reads n pulses on 'clock' between two rising pulses on 'trigger', it sets counter event output high.
Is this possible? Reading through the manual of M series PCI-62xx devices, the index pulse loads the counter with a particular value so it seems like you could conceivably set the counter to the terminal count if you wanted. My only real problem is whether DAQmx Export Signal Property Node works on all counter tasks or just on edge counting tasks.
Thanks in advance for your help. If this isn't possible, I can reply with more details on the problem this is supposed to solve so that you can help me figure out an alternate method.
Solved!
Go to Solution.

There is probably a way to do it, but it it may be easier to use an X-series board for the job. They support a new counter capability for count reset on a digital edge without needing to be configured in encoder position mode. I am not sure exactly how that feature's been implemented however, so maybe it won't make things easier after all.
The plan based on the hoped-for behavior:
1. Configure an X-series counter for pulse generation based on "ticks" of your clock channel.
2. Set both initial delay and low time to the critical # of ticks.
3. Configure for count reset on a digital edge (if possible in pulse generation mode)
4. Configure the count reset value to be the critical # (or possibly 1 less, if possible in pulse generation mode)
5. If you want the output to remain high indefinitely, configure the counter task to use its own output as a
pause trigger, and pause while high.
The way pulse generation works is to preload a # of "low time" ticks into the count register. Then every source edge will decrement the count. When the count reaches terminal count (0), the counter's output is toggled (or can be configured to pulse). The register is then loaded with the # of "high time" ticks and the process continues.
You would be perpetually interrupting the count-down process as long as you got your triggers in time. The count would keep getting reset to the # of low counts, keep decrementing toward 0 without reaching it, and so on. If ever you did reach 0, the output state would toggle high, then the high state would prevent subsequent clock signals from decrementing the count.
You can conceivably do a similar thing with a 6601, but I'm pretty sure you'd need 2 counters working together to get it working.
-Kevin P

Programming quadrature encoder

I'm trying to program a incremental optical encoder with nidaqmx 7.4, with C#, using the PCI-6071e card. I want to measure position, velocity, and acceleration.
As per the "How Do I Use a Quadrature Encoder with My Data Acquisition Board?" document, channel A of the encoder is connected to ctr0_source, channel B is connected to DIO6, and index is connected to ctr1_source.
I'm trying to run the the MeasAngularPositionBuffered_Cont_ExtClk example. However, an exception is thrown when calling myTask.CIChannels.CreateAngularEncoderChannel.
The messagebox says "Selected physical channel does not support the measurement type required by the virtual channel you are creating. Create a channel of measurement type that is supported by the physical channel, or select a physical channel that supports the measurement type"
Also, there is an option in the example program to enable the Z index. How does that program know which channel to read the index pulse?
I'm new at data acqusition, so any other hints regarding optical encoders are appreciated.
Thanks,
Gerry

You also may be able to measure position using the "Count Edges" measurement with an external direction control. This may be enough for your purposes. Just bear in mind that quadrature encoders typically give off noisy signals, so you might have to build an external circuit to clean up the input signals. Let me know if you need more information on doing this with your E Series device.
gus....

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

Quadrature encoder counter with 8 channels

Hi,
I need to acquire the signals (A and B) of four quadrature encoders. The signals have a maximum frequency of about 5kHz and should be read out with about 100 Hz. Is there a device that fulfils these requirements? It seems that a frequency of 5kHz is no problem since e.g. the USB-6008 has a counter for frequencies up to 1 MHz. However, I can't find a simple low-cost device that provides several counters. Does anyone know such a device with 4 or 8 counters?
No other analog or digital channels are necessary, but a USB connection and Matlab support would be ideal.
Thanks in advance.

Depending on your definition of low-cost, the 9171+9401 might suit your needs:
4 counters capable of quadrature encoder measurements (the single counter on the 6008 only does simple edge counting).
USB connection.
MATLAB support via the Data Acquisition Toolbox (according to their website).
I don't believe NI currently has any other option that meets these requirements at a lower cost. If USB isn't mandatory, you could also consider the PCIe-6612 which provides 8 counters.
Best Regards,
John Passiak

Quadrature encoder frequency division dotNet Net VB C#

Hello,
following a long search on this forum, I have decided to start this thread for dotNet developper.
I have a PCI-6602 with a quadrature encoder (A,B,Z). The pulse frequency is average (10kHz).
I am only using A and B channels.
The function I have to implement is to generate an output every N pulses in the forward direction. N being an integer and ranging from 1 to let say 100.
I have no constraint on the output. I am it can be a bit toggling or a pulse generation.
What functions shall I call in MeasurementStudio.Net to implement this ?
How many counters should I use ?
On the register basis, my guess is that I have to pre-load a value in the register.
Then when downcounting the counter reaches 0 this in turn does 2 things:
reloads the counter to its preset value
triggers the output generation (TerminalCount)
Thanks for any help you may bring
NOTEs FOR NI guys:
By the way, in the NI samples, quadrature doesn't work all the way. I nthe sample "CountDigEvents" with CountDirection set to "Externally controlled", backward motion is never displayed. This is because the counter is read as a UInt32.
Solved!
Go to Solution.

Hi,
Your first ideas are pretty good, it should be a good way to implement a solution for your problematic.
I am not used to work with MeasurementStudio, but this is few links which you could use or which could help you with theoretical points:
http://zone.ni.com/devzone/cda/tut/p/id/3167
<link no longer exists>
http://zone.ni.com/devzone/cda/epd/p/id/2999#0requirements
Hope it could help
Mathieu B
National Instruments France
#adMrkt{text-align: center;font-size:11px; font-weight: bold;} #adMrkt a {text-decoration: none;} #adMrkt a:hover{font-size: 9px;} #adMrkt a span{display: none;} #adMrkt a:hover span{display: block;}
Forum Aéronautique, Spatial et Défense. Avec la participation exceptionnelle de Bernard DUPRIEU, Res...

Quadrature encoder interface to PCI-6229

Similar Messages

Maybe you are looking for