wfm | Web File/Content Management Application with GIT integration | File Utils library

You can pass arguments between destinations with Bundle:

In the Akka Documentation on Classic Dispatchers, it notes:

The dispatcher you specify in withDispatcher and the dispatcher property in the deployment configuration is in fact a path into your configuration. So in this example it’s a top-level section, but you could for instance put it as a sub-section, where you’d use periods to denote sub-sections, like this: "foo.bar.my-dispatcher"

In the configuration above, the dispatcher path is "akka.wfm-dispatcher", so that's the string you'll need to use to look it up. Alternatively, you can put the dispatcher configuration at the top level rather than inside the akka section, and look it up as "wfm-dispatcher".

Also note that the code above won't actually use your custom dispatcher to run these actors. To configure the actor to run with your dispatcher (assuming the configuration file is unchanged), you can use:

Try:

Not so sure what the problem is - I feel that from your question you should know the answer...

I'd use color aesthetic instead, because there are not many shapes that have a fill.

And there is a scale_(*aes*)_manual for each aesthetic. I have added this, although the values 1:6 are pretty random.

looks like you are close. Like MrFlick said without your client ID and starting a case with Xero API tech support (email api@xero.com with your client id and dat of log) its hard to know for sure.

One tip might be it, your redirect URI has to match exactly same value that is in your https://developer.xero.com/myapps/details?appId= dashboard including an end slash.

Also - what is the body of the 400 error, there should be something like

There is a lot that I don't know about radio. But I think I can say a couple things about the basics of modulation and the problem at hand given the modicum of physics that I have and the experience of coding an FM synthesizer.

First off, I think you might find it easier to work with the source signal's PCM data points if you convert them to normalized floats (ranging from -1f to 1f), rather than working with shorts.

The target frequency of the receiver, 510-1700 kHz (AM radio) is significantly faster than the sample rate of the source sound (presumably 44.1kHz). Assuming you have a way to output the resulting data, the math would involve taking a PCM value from your signal, scaling it appropriately (IDK how much) and multiplying the value against the PCM data points generated by your carrier signal that corresponds to the time interval.

For example, if the carrier signal were 882 kHz, you would multiply a sequence of 20 carrier signal values with the source signal value before moving on to the next source signal value. Again, my ignorance: the tech may have some sort of smoothing algorithm for the transition between the source signal data points. I really don't know about that or not, or at what stage it occurs.

For FM, we have carrier signals in the MHz range, so we are talking orders of magnitude more data being generated per each source signal value than with AM. I don't know the exact algorithm used but here is a simple conceptual way to implement frequency modulation of a sine that I used with my FM synthesizer.

Let's say you have a table with 1000 data points that represents a single sine wave that ranges between -1f to 1f. Let's say you have a cursor that repeatedly traverses the table. If the cursor advanced exactly 1 data point at 44100 fps and delivered the values at that rate, the resulting tone would be 44.1 Hz, yes? But you can also traverse the table via intervals larger than 1, for example 1.5. When the cursor lands in between two table values, one can use linear interpolation to determine the value to output. The cursor increment of 1.5 would result in the sine wave being pitched at 66.2 Hz.

What I think is happening with FM is that this cursor increment is continuously varied, and the amount it is varied depends on some sort of scaling from the source signal translated into a range of increments.

The specifics of the scaling are unknown to me. But suppose a signal is being transmitted with a carrier of 10MHz and ranges ~1% (roughly from 9.9 MHz to 10.1 MHz), the normalized source signal would have some sort of algorithm where a PCM value of -1 match an increment that traverses the carrier wave causing it to produce the slower frequency and +1 match an increment that traverses the carrier wave causing it to produce the higher frequency. So, if an increment of +1 delivers 10 MHz, maybe a source wave PCM signal of -1 elicits a cursor increment of +0.99, a PCM value of -0.5 elicits an increment of +0.995, a value of +0.5 elicits an increment of +1.005, a value of +1 elicits a cursor increment of 1.01.

This is pure speculation on my part as to the relationship between the source PCM values and how that are used to modulate the carrier frequency. But maybe it helps give a concrete image of the basic mechanism?

(I use something similar, employing a cursor to iterate over wav PCM data points at arbitrary increments, in AudioCue (a class for playing back audio data based on the Java Clip), for real time frequency shifting. Code line 1183 holds the cursor that iterates over the PCM data that was imported from the wav file, with the variable idx holding the cursor increment amount. Line 1317 is where we fetch the audio value after incrementing the cursor. Code lines 1372 has the method readFractionalFrame() which performs the linear interpolation. Real time volume changes are also implemented, and I use smoothing on the values that are provided from the public input hooks.)

Again, IDK if any sort of smoothing is used between source signal values or not. In my experience a lot of the tech involves filtering and other tricks of various sorts that improve fidelity or processing calculations.

The exception that you're seeing indicates that the producer is unable to communicate with the Event Hubs service. Despite identifying the correct ports, it appears that your VPN is not routing the request.

Most often, when we see this behavior, it is due to an environment blocking raw TCP traffic. You may want to consider trying with web sockets to see if that helps. To do so, you'll need to specify a set of options when creating your client. The basic form looks like:

See if this works for you (written in python (i dont's know .net)

I found this How do I close a tkinter window? and a comment from Bryan Oakley which gave me what I needed. For the problem tab (TAB B) I added a destroy button with the command=quit which works fine. Will need to add that to all other tabs too.