ELAPS | Experimental Linear Algebra Performance Studies | Data Visualization library

Please try this:

You can use SqlFunctions.DateDiff like this :

Firstly, You should study how to use DATEDIFF method in sql via this link

Secondly, In server side (Asp.net MVC), You just return .FirstOrDefault instead of .Tolist. Simply becuz, As i can see, in client side you just get one item ($('#custid').val(data[0].custid);)

Finally, In my opinion, keyup event should combine with Debounce pattern to avoid calling server too much time unnecessarily.

Numbers beginning with a zero are treated as octal and "08" and "09" are invalid octal numbers.
To avoid this, I prefix each part of the time with a "1" and calculate the modulus 100.

Btw. It's not possible to use the %time% directly with CALL, as in some formats the time uses , as separator (like 15:44:08,44).
But the , is also a delimiter.

The answer is really simple: sleep() does not hold the GIL, as there is nothing to be done. You would need to devise some real "work" in order to lock the thread and degrade parallelism.

You don't explain very well how your protocol works (I mean what is your switch supposed to be sending, or if it's sending a state change only once or several times or continuously).

But there are some red flags on your code anyway:

-With data = self.ser.read(size=1).strip() you read 1 byte but immediately you check if you have received 2 bytes. Is there a reason to do that?

-Your timer stop condition works comparing with the NULL character. That should not be a problem, but depending on your particular configuration it might (in some configurations the NULL character is read as something else, so it's wise to make sure you're really receiving it correctly).

-Your timer start condition seems too loose. Whatever you receive on the port, if it's one byte, you start your timer. Again, I don't know if that's the way your protocol works but it seems prone to trouble.

-When you replace your hardware switch with a software emulation it works as intended, but that is not surprising since you're probably imposing the condition. When you read from the serial port you have to deal with real world issues like noise, communication errors or the switch bouncing back and forth from ON to OFF. Maybe for a very simple protocol you don't need to use any error checking method, but it seems wise to at least check for parity errors. I'm not completely sure it would be straight-forward to do that with pyserial; on a quick glance I found this issue that's been open for a while.

-Again, the lack of info on your protocol: should you be using XON-XOFF flow control and two stop bits? I guess you have a reason to do it, but you should be very aware of why and how you're using those.

EDIT: With the comments below I can try to improve a bit my answer. This is just an idea for you to develop: instead of making the stop condition comparing exactly with 0x00 you can count the number of bits set to 1 and stop the counter if it's less or equal to 2. That way you can account for bits that are not received correctly.

You can do the same with the start condition but I don't know what hex value you send.

Credits for the bit counting function go to this question.

From the Unity docs on Time.time

The time at the beginning of this frame (Read Only)

This means that your Time.time will not change over the course of your loop so the difference between currentTime and madBegin will always be 0.

Time.realtimeSinceStartup may be what you're looking for.

You can express the logic using boolean arrays and expressions in numpy without any loops:

You need to group by variable.

p <- p + geom_line(data=df.melted,aes(x=DD,y=value, group = variable),color="black",alpha=0.1,size=0.5)