#debouncing

[erpsolutions]

Debouncing and throttling are techniques in javascript that improve website performance. Often used on functions that need to be called frequently or at regular intervals, they serve as great tools

[ryadel]

Debouncing and Throttling in Angular with RxJS

In this article we'll talk about Debouncing and Throttling, two optimization techniques that we might want to consider whenever we're developing an Angular app that needs features such as autocomplete, real-time filtered searches, and so on: learning how to efficiently use both of them will not only improve our overall knowledge of the Angular (and RxJS) codebase, but will also ensure important performance improvements because it will greatly reduce the number of HTTP requests that our client-side code will issue to the server to retrieve data. Introduction Let's take the following Angular code snippet: As we can see, this is a typical data retrieval method that will fetch a jsonData result from the server using a standard HTTP request using a local http object (most likely an instance of HttpClient instantiated in the constructor using Dependency Injection ) and store it within a local variable; such approach is tipically used by most Angular components (and services) that perform such kind of tasks. Read the full article

[speculatrix]

Virtual printer & more fun with AVR interrupts

Virtual printer & more fun with AVR interrupts

In building my AVR ATMEGA328P-based ‘virtual parallel printer‘, there were two signals that required special treatment. So it was time to revisit interrupts.

The virtual printer prototype

On a Centronics-style parallel port, the host machine sends an ‘init’ or reset signal to the printer to tell it to flush its buffers and set itself to the default state. It also sends a ‘strobe’ signal to tell…

View On WordPress

[ordernexusdev]

SFML Input Debouncing.

As far as I know, SFML doesn't come with input debouncing. When checking for keys pressed, often times whatever action is tied to that event will be repeated multiple times unless some additional state checking is done, like so:

That is exactly what we're going to rectify with this simple code snippet:

#include "SFML_KEYS.h" class InputWrapper{ public:     static bool IsKeyUp(const Key Button){         // Check for this first, before IsKeyPressed, otherwise the state is lost.         return (!KeyPressed(Button) && InputWrapper::KeyStates[Button]);     }     static bool IsKeyPressed(const Key Button, bool CheckOnce = false){         // This is also an update method. If the key strokes aren't checked every iteration         // it could result some actions acting a little 'funky'.         if(KeyPressed(Button)){             // If the button is actively held down.             if(CheckOnce && InputWrapper::KeyStates[Button]){                 return false; // Button has already been pressed the iteration before.             }             // We have a button press!             InputWrapper::KeyStates[Button] = true;             return true;         }         // Button isn't pressed. Return false.         InputWrapper::KeyStates[Button] = false;         return false;     } private:     static bool KeyStates[]; // Array of booleans for key states. }; bool InputWrapper::KeyStates [KEY_COUNT] = { }; // Initialize the array.

This is made to be extendable to any A.P.I., but we'll focus on SFML for now. Essentially, this just stores an array of boolean flags for each key, which can be used afterwards to determine if a key is already being pressed, if it was pressed the previous cycle etc. Let's take a look at the key definition file which we included on line 1:

#ifndef __SFML_KEYS #define __SFML_KEYS #include <SFML\Window\Keyboard.hpp> #include <SFML\Window\Mouse.hpp> /*     Header for SFML-specific keyboard setup. */ #define KEY_COUNT 101 // Must be defined to avoid dynamic memory. enum Key{     Keyboard_Up = sf::Keyboard::Up,     Keyboard_Down = sf::Keyboard::Down,     Keyboard_Left = sf::Keyboard::Left,     Keyboard_Right = sf::Keyboard::Right,          {...} }; bool KeyPressed(const Key Button){     return sf::Keyboard::isKeyPressed(sf::Keyboard::Key(Button)); } #endif

This header defines its own method for checking if a key is pressed, specific to a particular A.P.I., in this case SFML. It also has to use its own enumeration of keys, which I've cut down significantly here to save some space.

When our input wrapper class method for checking the key state is used and the boolean flag to only check it once is set to true, the result speaks for itself:

Keep in mind that the only incomplete piece of code that I've left above is the "Key" enumeration, which you can extend easily if you do decide to use this.

[mikewittmer-blog]

Electronics - Simple AVR Debouncing In C

Electronics – Simple AVR Debouncing In C

Building on the previous post, you can add a basic debouncing process by adding a small delay after the initial pin read and follow that delay with a second read using nested If statements. Here’s a code snippit:

if ((PIND & (1 << PD2)) != 0) { _delay_ms(100); if ((PIND & (1 << PD2)) !=0) { PORTB = 0b00011000; } }

You should experiment with the delay time and find the millisecond…

View On WordPress