cannot link filestream node duration ooutput pin to lfo node period input pin
hi all,

i am just starting using vvvv and i found it really cool!

i followed the basic tutorials but i think there is something i did not get about the iobox, and pins data types.

right now i created a patch to control a video and do forward/backward reading of the file. everything (kind of) work…
see [creating feedback loops](https://vvvv.org/documentation/creating-feedback-loops).

it’s only the subtype of a datatype. don’t worry about that.

fyi: create an [asstring (value)](https://vvvv.org/documentation/asstring-(value)) and check its sub type for possible subtypes of the datatype “value”
not possible out of the box.

you’ll have to modify the openocd script to e.g. check for the existence of an environment variable like “serial”, and then the script can use that serial to identify the correct stlinkv2. that’s how i’ve implemented a “flash firmware to a specific stlink” some time ago… It' just standard c++ ifstream and ofstream. When the program starts, try to open the file, if it success then read it. hi,

you can use gpi/o to start/pause/stop your program by using field bus.

please see the following setting.

[\_20210611\_134829] > 
> My question is when does this function works improperly and why?
> 
> 
> 


Technically it works improperly when you call it with an input stream or an update stream in input mode. That is, if you use fopen() with a "w" mode, or a "+" mode and you're currently in the process of reading from the stream, or stdin.


In practice, all of the above situations are okie dokie *iff* the compiler supports them (and some do, including Borland and Microsoft compilers). In terms of best practice, fflush() on an input stream is frowned upon.


However, note that calling fflush() on an output stream is both well defined and recommended for things such as forcing a user prompt to display, well...promptly. :)



> 
> Nowadays I use scanf("[^\n]") to flush input stream. Is this ok?
> 
> 
> 


Close. The correct call for scanf() to read up to a newline would be:



```
scanf("%*[^\n]");

```

This isn't complete though, because the newline will still be in the stream. You still need to extract it. One way would be to add an ignored character match in the format string:



```
scanf("%*[^\n]%*c");

```

This might not be as flexible though, if you want to do other stuff like count discarded characters. Another way would be to call getchar() after scanf():



```
scanf("%*[^\n]");
getchar();

```

Finally, there's the far more common (and faster!) method of calling getchar() in a loop. I'll even give you a function that you can call instead of having to write it ad hoc every time:



```
#include <stdio.h>

void clear_line(FILE *in)
{
    int ch;

    /* Do nothing if the stream is in an error state */
    if (ferror(in))
        return;

    /* Make sure any end-of-file  state is cleared */
    clearerr(in);

    /* Extract and discard up to a newline or end-of-file */
    do
        ch = getc(in);
    while (ch != '\n' && ch != EOF);

    /*
        Clear an end-of-file state if we stoped on EOF,
        but leave any legitimate error state for the caller
    */
    if (!ferror(in))
        clearerr(in);
}

```

Note that even this solution is incomplete when compared with what people expect from `fflush(stdin)` because it blocks for input when the stream is empty. fflush(), when flushing input streams is supported, will return without blocking on an empty stream. Unfortunately, there's no portable way to emulate that behavior, but it's fairly simple to just ensure that the stream is never empty when calling clear\_line().



> 
> fflush( std::cout );
> 
> 
> 


Yeah, that won't work. fflush() expects a pointer to FILE, not an std::ostream object. std::ostream has its own flush() member for synchronizing with the destination device.


It's also quite silly to flush cout explicitly prior to accepting input through cin because the two are tied together. As soon as you request input from cin, the tied stream (cout) is automatically flushed. Doing it yourself explicitly isn't harmful, but it *is* redundant.


It's actually a pretty nifty feature of the iostream library. Read more about it starting [here](http://www.cplusplus.com/reference/iostream/ios/tie/). from here [fstrm python receiver](https://github.com/dmachard/python-framestream/blob/main/fstrm/fstrm_codec.py)

# frame streams control frame format - data frame length equals 00 00 00 00

# |||

# | data frame length | 4 bytes |

# ||… tiler\_src\_pad\_buffer\_probe is before the nvmultistreamtiler in the pipeline, so the ntp\_timestamp for each stream is meaningful. your appsink is after nvmultistreamtiler in the pipeline, nvmultistreamtiler will combine multiple streams into one new stream, so ntp\_timestamp in each separated stream m… yes i already tried the uff input order like i mentioned in my post.

in the end i just added an additional layer in my neural network to swap from channel-first, to channel-last after the input has been read so this issue can be closed. well, transferring your data and transferring that and your settings are different. data, such as music, letters, video, pictures can burn to disk or copy/move to external drive. installed applications won't go, you'll have to reinstall from disk or download. on the other hand, you can transfer settings, favorites etc. use files and settings transfer wizard. or laplink software and cable. resolved for now

so i think the symbolic link issues, when installing node red nodes (influxdb etc..) is due to he fact that the cifs network share is to a windows server

i tried a few things tonight but the best i came up with is this

i have set the "flows" env to a new folder and file and then … a couple of things to check:

(1) make sure your file realy exists

(2) your file path does not seem to be correct full path, should it be something like c://users/…

(3) you can also try a relative path, namely, copying your tiff file to the same directory as where you start your jupyter. then, use…