Shift registers and state machines

Similar Questions

• event and state machine

  Hello

  I have a problem when I want to set up an event in my state machine.

  The state machine is reading communication series through different States 10 +.

  The problem came when I tried to add an event inside the State number 10. In the number of State 9 code seems to work only partially (an option button is not possible to change the value on).

  It seems almost that it is frozen but when I select the code I can see it works well (option button isn't).

  It is strange that when I remove the event in condition 10 all is well again? The event code is not yet performed yet because it is in the frame after!

  Any thoughts?

  I'm under LabView 2013 on a Windows 7 PC.

  I'm trying to figure out which of the two cases is the one who seems to hang if the name would be better than a number.

  When using am event structure you don't we want to use a local variable.  In fact, you should only use local variables on rare occasions that they break the flow of data.  The event structure is fine for the entry.  The problem is the way you treat things after that the button is pressed.  Again, I think you have to look at a design model of producer/consumer with a machine of the State in queue.

  The best way to have a writing occur only after a button must have the code for writing in a case that is active when the button is true and is simply empty, when it has the value false.

• active enum entries, enums disabled in control and state machine accessibility

  Background:

  I have an enum of entry that can be anything.

  In the vi, some enum States are 'disabled '.

  The enum led a state machine that defines the output.

  Question:

  If an entry corresponds to a "off State" it will create an exit?

  A 'disabled' in an enumeration element applies only to the dropdown list control allows you to manually select an option.  The program itself does not pay attention to State on or off selection passed around the nodes or son.

• creation of structures: state machine with controls

  Hello, I wonder if someone can help me with something. I have a sequence, followed by the event structure / while loop.

  someone can help me. I want to create a STATE MACHINE.

  Here's a basic outline of the current structure, I. and this is what I want it to be. I wonder if its possible and how.

  I'm using labview 7.0.

  Thank you

  

  This is what I want?

  

  I looked at your Executive VI.  I don't have an easy way to save in LV 7 now so I'll try to describe in words how I would approach this mess.

  I think it can be done with two loops, a structure of the event, a case structure and not global or local variables.  In fact, there is probably some small business structures and lines inside some of the case, but nothing like as layers of ~ 12 nesting, you're struggling now.

  Look at the design model of producer/consumer (events) as a starting point.

  The loop of producer (event loop) will have the structure of the event.  It will be a case for each control that requires immediate action.  Those that I could identify: get telemetry, side, open Journal printing, abandon, press tank Mode (?) Temp tank (?), Scan, Stop, wait, Step (?) unique, continue and Execute. Most of the buttons must be set on the mechanical action of locking and placed terminals in the case of the event appropriate. So no local population is necessary to reset them.  Those with (?) have no event.  You can have a case of timeout to display Date and time, eliminating which (painful to my eyes) loop.  I don't know about the other stuff in the case of a timeout, but most likely, it is up to the other loop.  If the room 1, 2,... buttons change during trips, they may also need event.  Inside of each event is exactly one element: the Enqueue function.  Create an enum command and make it a typedef. Enqueue this enum value. The queue will be read in the loop of consumer where all the action happens.

  The consumer is your state machine. It has a Dequeue function to get a new order for the structure of the event.  It has several shift registers to transfer data from one case to the other.  These removes your global and local variables.  I'd shift for each of the following registers: the State (typedef enum), cluster of error, temperature (table), pressure (table), results (table), Stat results (table grapes) and a big cluster Indicators_Flags (typedef).  The cluster Indicators_Flags everything that is in the cluster you initialize in the black image sequence (and then never reuse) would have more all indicators except the berries in Maj separate records as well as all your globals and no status indicator, you might need.

  The structure of matter is the heart of the state machine.  All shift registers through it.  It will be the case for what the program does.  Everything in this black initialization setting in about 15 cases of Init.  The while loop to the right of the boot image goes away, but the case inside to become some of the cases of the state machine.  Chassis temperature cycling code goes into 1-3 cases. Mode code pump and read the pressure of your case of timeout event are 1-3 cases.  Code of telemetry: 2 cases.  Print the Page before: 1 case.  Excel code.  Abandonment of code.  Temperature and pressure cycling code of main program: 5-20 cases.  Graphics, record in file: more cases.  Break: 1-2 cases.

  I would like to make a list on paper anyway, you think that you may need and allows to create a typedef enum to control cases.  By making a typedef, it is easy to change without running all over the code looking for the constant in all cases of change.  Enum names will appear on the structure of matter as strings.  Create the loop, shift registers and the structure of the case.  Moving is part of both the original thread can duplicate the case until you have a case for each value in the enumeration of the State.  (Do not use the case of the mark for each value option because it will empty cases that you will then need to wire through.)

  Then copy code from various places in your existing code in the case in the new VI.  Try to avoid copying inhabitants that it will create new controls.  Name bundle to get data in and out of the big bend cluster registry and use ungroup by name.  This provides a free documentation of the data used.

  Check in a month when you have other problems. This will not be a quick fix.  But it will be useful to have a program that works and is easy to manage.

  Lynn

• In the state machine loop counter

  Hi all

  I have a state machine, and one State in particular is very busy.  I want to State in a loop several times.  I thought about that, but I don't like them.  Let me know if you have a better idea.

  1 Add a registry to offset as a counter for the State.  The State will keep looping to himself, while decrementing the counter.  If the counter is reset, it will go to the next State.  If this isn't the case, it will keep the loop.  I don't like this, because I'll have to add a register to offset.  If I have a little more State requiring a different number of iteration, I'll have to add a counter for that State.  My main VI will be too shift registers.

  2. Add a loop around the code in my case for iteration.  I do not, because too many wires will be going in and out of the loop.  I don't want to do cluster either.

  Yik

  jyang72211 wrote:

  Node of a feedback by counter I need?

  Yik

  With precision.  See this example, each State 5 times before moving earrings.  Beats having 5 shift registers and all of these threads passing through other cases.

• Cluster vs multiple Shift Registers

  I had a question about good coding practices.

  Say you have several elements (numeric values, strings,... whatever) you need to iterate between the loops.

  Is it better to make a registry change for each item?
  Or cluster, and then move the cluster to a single shift register?

  It is faster than the other? Or better/worse for another reason?

  Cory,

  Yes.  and no.

  I usually create a large cluster of typedef I call indicators and flags (InF).  I put most of the things that need to be passed around with that.  The cluster of error, the State enum and large data tables are usually in separate shift registers.  Table L: shift registers and data are at the top of the loop and error and SRs of the State are at the bottom.  Most of the code goes between them.  Given the help of bundle/Unbundle documents name to which the data is used in a case.  The InF cluster is usually not displayed on the Panel before and may exist only in a Subvi to save space of block diagram.  The data are unbundled indicators as needed for display to the user.

  If you have a situation where speed is concerned, separate data that must be processed everything quickly and optimize for that.  Strings and arrays within the cluster probably cause some memory interesting distribution issues since they change size, that can be an argument in favour of that separates them.

  Lynn

• Closure of a state machine in queue event with several parallel loops

  I am trying to find the best way to stop a program that consists of an architecture of State machine in line waiting for event with several parallel loops. Can anyone recommend the best way to achieve this in my attached VI? (To browse the forum, this seems to be a frequently asked question, but I have not found a solution that works for me.)

  I look forward to any comments on my as well code, if someone is willing to offer it.

  My program needs:

  If the user press the 'Stop' button, the program should prompt the user with "are you sure you want to stop the program?" and then return to a State of rest or move forward to stop the program. In addition if there is an error, the program should prompt the user to ' clear the error and continue, or stop the program. Then back to the idle state or move forward to stop the program.

  Architectural details:

  The program consists of 3 parallel loops: (1) a loop of event management that places different States of a queue of the State, (2) a State Machine that enters the State that is removed from the queue of the State and (3) a loop error/Shutdown, which deals with errors in the error queue management.

  During normal shutdown, where running handling loop in the case of event 'Program.Shutdown' and 'Shutdown' and the 'Idle' States are added to the queue of the State. In the state machine, the State of 'Stop' is invoked. Special "5000" error code is added to the queue of the error. In the loop of error handling and stopping, "5000" error triggered a prompt that asks the user if they want to stop the program. If the user chooses not to stop, a notifier StopNotif is sent to the State of 'Stop' and 'Program.Shutdown' event case with notification 'Go '. If the user decides to stop, the Notifier sends the notification "Stop". Loop and event management State Machine ends when they receive the notification "Stop".

  In case of error, the program behaves in the same way: If the user chooses to clear the error and continue, the program returns to the status "pending".

  HOWEVER - if the user chooses to stop the program, the program crashes. The author of the notification that is sent to stop the loop of events and State Machine management cannot be read because event Program.Shutdown and the stop State (which contain the function "Waiting to notify") are not active.

  I was able to activate the stop State by Queuing in the loop of error/Shutdown management. But I don't know how to activate the "Program.Shutdown" event by program and thus access the function "Waiting to notify" inside.

  I tried to put the function "Waiting to notify" outside the structure of the event, so the event-handling loop never ends. Placing timeouts on the "wait for declaring" and the structure of the event makes the programme of work, but I want to avoid using timeouts because I don't want to turn my event program into a program of polling stations. I would also avoid using variables or nodes property to stop loops, because that requires the creation of a control/indicator for something that the user does not need to interact with.

  Thank you!

  First of all, close the notifier outside loops with your queues.  Second, you must use a user event to send the message to the event structure loop so that it stop in the case of the stop on an error.

• Register to offset State Machine

  Home is a state machine, I created to illustrate a problem I have with a larger program.  It doesn't do much, but the concept is the same.

  I created two buttons program (run & abortion).  If I cancel countdown (suspension on the resting State), then select run it begins the countdown of the previous counter value.  I need to start the countdown to 1 min.

  The shift of the state machine register abandon everything in value during the last loop by selecting the button.  I need state machine while the loop shift register reset whenever the run button is selected in the standby mode.

  THX

  There is no "loop of inactivity.  You have a slow case.  Instead of wiring by the count of the left shift register.  It is enough to feed a constant to the wire that goes to the shift register on the right side.

• queue and notifying with state machine

  I'm trying to implement a declarant and a queue to collect data that is running on a state machine in two separate loops.  I'm new to the whole and methods notifier queue and I think I'm really close to make it work as I want.  When I start the computer the first time that State everything works and it is what I expected.  When I try to restart the test and do it again she acts like the queue has been cleared and it will not connect anything to the queue.  I use the queue as a buffer for the data collected between iterations of the loop of State machine.  I empty the queue and add all the data in a table.  The declarer seems to work in all situations as I want.  I have attached a simplified version of what I'm trying to do.  Any ideas? Thank you.

  After the execution of your code (I had to make my own custom control to the States because you include not yours) and some survey values, here's the conclusion that I came to:

  It is not your queue.

  It's your math.

  In your upper loop, put sensors on the values you use to trigger the 'True' case (specifically, put a probe on the values to enter your service "superior or equal to") and then watch their values that you run your code.  The value that is coming through the shift register is your problem.  He isn't getting back to zero when you restart the test.  The first time you run your program, the value is zero.  For subsequent iterations, it's everything the last calculated deflection was.  Run your button 'force' down to zero once your test is over and look at what this value.

  Thus, when you restart your test without having to restart your program, you start with a nonzero value for calculated arrow.  Is to prevent your delta never exceed 0.001 in., and therefore your 'Real' case never executes.  So nothing ever shows in your queue.  You do not put anything in your queue.

  The reason why you go to your "complete" State in the lower loop when you hit 0.3 in flexion is because the current value of the 'deviation' is passed through your Notifier and is not dependent on the previous value of the way your queue is.  So you can always hit deflection 0.3 in., without calculated being greater than 0.001 in. delta.

  Try to reset this registry offset value in your greater than zero loop every time that you restart the test, and your program will probably work.

  And Ravens Fan has a point about the complexity.  It usually does.

• Need help with while loop and shift registers

  I have a broad set of data and required to read data at maybe 200 samples at a time to process these samples through my VI and have add and concatenate a file separate lvm.  The part where I am confused is the shift registers. How can I limit the number of samples read in an iteration? How do the while loop to stop when all data are read in?

  I have attached my diagram, there may be something wrong with my technique?

  This will give you an idea.  There are a lot of other (probably more effective) methods.  It is a basic solution, quick and dirty to help you grasp the overall concept.

• State machine, controls, and indicators

  Hey everybody,

  I'm working on the conversion of a VI to use a state machine architecture. In other words, there are several buttons that trigger States through a structure of the event in the standby mode. Two States need write values in the same set of indicators, but the rest should be left alone. Several States also contain a Subvi, which takes a cluster entry. The cluster is composed of about 10 digital/boolean controls. I wonder what is the best way to deal with these two problems. I could use local variables or references, but that seems to be discouraged for most cases. I do not have access to the VI himself at the present time, but it might send more later if necessary.

  You could go with the local population, in this case it should be ok, or have an update-state indicator.

  I have probably to take the easy road and go with local to a simple state machine.

  /Y

• How to start and stop the video capture in a state machine

  Hello

  I am a student of neuroscience and this is what I try to do: 1) trigger a camera to GigE (200 FPS), 2) start the video capture, 3) triggers a light that stays on for x milliseconds, 4) trigger a valve that will blow an air puff, 5) stop the tone and the valve at the same time and 5) stop the video capture 1 second after 4). For this, my VI is a state machine, with a State for each trigger (ex, 1 State for trigger camera 1 State of light of trigger, ect) and a statement to "stop" and a "time-out State." Everything worked except the video acquisition - the program could trigger the camera but only acquire a frame, because it was not running in a while loop and this is my first question: for an acquisition video is it always necessary to have a while loop?
  I guess the answer is Yes, so I built a loop of 'consumer' for the camera. A queue of the pre-trial 'trigger camera' in the loop of producer, I was then able to start the video capture, but now the problem is to stop it at the right time. I have an another queue in the State of 'stop' in the loop of the producer, but is not able to start the State 'stop' in the loop of consumer, I think that maybe it's because the loop of consumer gets "stuck" in the whole loop.

  I hope you can help me, the VI is attached. Thank you!

  Hello

  First of all, in your loop producer: STATE 'Stop', you use the flushing line, then there is no need to use 'item queue at the opposite end. You can use the enqueue function.

  Secondly, you said "I moved the command stop inside the while loop as you said, but it did not work. But if you look closely, you moved "Enqueue function" inside the while loop. Instead you should use Dequeue function. Please, look at the picture I posted an orderly manner.

  And remove the circled (i.e. function. Enqueue function loop of consumption, where I wrote 'Why stop here').

  Try now.

• State machine with acquisition different modes/loops

  Hi all

  I did a machine design to State (as described here) to organize three (mutually exclusive) process / States: idle, measurement of calibration and continuous measurement. Calibration must be performed before measurement, because the result of the calibration is used for measurement. The data entry is a camera that should run continuously, also in rest mode.

  The problem however is that this state of calibration and continuous measurement (should) have another method of data acquisition. The measure is continuous and the images are processed in real time. To calibrate a number N of images should be accumulated and treated (simply create a background image).

  In the state machine as I have now (see attached image), I have the acquisition of vision outside the state machine in order to have a live view at any time. The problem now is that the inner loop in the State of calibration (the loop that must accumulate the framework) accumulates of course that the first framework N times, it is not question for all new managers during this State.

  Of course, I could fix this with an if/else statement in the first calibration mode accumulate images (if I< n,="" accumulate="" frame="" in="" buffer="" and="" continue),="" but="" i="" am="" not="" convinced="" that="" having="" a="" lot="" of nested="" loops="" is="" the most="" elegant="" way="" to="" do="">

  This also got me thinking, is the state machine, as I built it here all the best way to manage these two processes/acquisition modes? Or are there better ways to do this?

  Contributions and comments are very much appreciated!

  Note: I know that loop as scheduled now in State calibration is wrong with shift registers. It was a test before I realized that the fault was in the interweaving of the state machine altogether.

  Please do not attach pictures, but rather post executable code, screws (easier) or as extracts from LabVIEW (which became the screw when you drag in a block diagram).  If you have more than three attachments, compress the folder and attach the ZIP file.

  I was once describing a system similar to yours, and one of my students, who was a computer science major, said "it's not a State Machine."  I had a similar situation to yours, where I had a procurement process which took time and a 'Stateful' routine that does different things with data (in your case, use it for calibration, waiting to 'Go', absorbent, etc.).

  I understood that it was correct.  I ' D 'opposite' model, with the Acquisition, always running and "driving", the calendar and make 'Appropriate Action' on each set of data, where the Action could (and did) vary according to other conditions.  So I renamed my state machine 'Action engine', and everyone was happy.

  So I won't bother looking at your code (a quick glance showed me that I have only would be frustrated by the limited view), but will give you a suggestion for an alternative architecture.

  You want to (ideally) two parallel loops.  A single loop simply acquires the data (images) at some rate.  For each Image, it signals the loop else it's time to 'Action' on the acquired data (to do this, use a queue or the notifier).  You want that engine of the Action to perform independently the Acquisition loop, just in case a particular Action takes, say, 1.2 times sample to complete - you don't want 'Miss' samples!.

  The loop of the engine of the Action is a unique, appropriate Action at the time, on the newly acquired data.  If you are in the 'State' calibration, the Action will be "add to the calibration.  When you have accumulated enough data to do calibration, set the following Action to (for example) 'wait to start the Signal.  When you receive the Signal to begin, take Action to "acquire, process and save data.  And so on.

  As it happens, I did my code exactly in this way, but it was the idea General - Acquisition was the 'King', he ran the clock and led the ' Machine/Action State engine' to 'do the right thing, appropriate to the time' with the data.  See if this type of model is appropriate in your situation.

  Bob Schor

• Timing of a State Machine in the States

  Hi LabView community.

  I'm running a state machine (attached) in which I want to measure the duration that the VI is running in several States. The VI is used to take spectra of power of various samples. My scheduled execution goes like this: the user selects on the front panel, how many times they would like to see the data taken. After pressing start on the front panel, a timer starts. When the machine is in State of 'Waiting', I would like to have the VI wait the amount of time the user has selected the amount of time that has elapsed since the user pressed start. So, for example, if the user wanted a spectrum taken every 15 minutes and the time since the departure was 13 minutes, I would like the program to wait for 2 minutes, then repeat.

  If someone could help me with this, it would be much appreciated!

  Thank you in advance.

  You just need to save in a shift register either time has begun the activity.  Or the sum of the amount of time that has already elapsed.

  PS: You used a large number of local variables and none of your terminals.  Good number of these local variables should also be so shift registers.

• Shift registers loop when the chain is connected to the registers

  Hello everyone! I just need to know how these shifts of registers. For example a photo added, I have a stacked sequence structure. Some time ago in a loop with inside case structures. As you can see, there is registry to offset looping with initial string and on the right side of passage registry there is string "entry". So my question is when we run the VI, to check the error case it is going to start from initial case and then transmit the information to the case of entry into the structure of the case. So basically, I need to know how the shift registers can be used with the structures of the case and while loop.

  

  http://www.NI.com/Tutorial/9330/en/

  With this you can post a photo that is executable code.  For us looking at your code is not better than watching a photo with text in Notepad.

  That being said here is some information on shift registers.

  http://www.NI.com/getting-started/LabVIEW-Basics/shift-registers

  https://zone.NI.com/reference/en-XX/help/371361H-01/lvconcepts/shift_registers_concepts/

  To simplify your code, I highly recommend getting rid of the outer sequence structure.  Stacked sequence structures serve generally to cause new problems to users, and sequence variables compound which.  If you want the code to run before the main States are called, you can have a status of initializing in your state machine and do be more manageable.