high frequency screen x linux

cputool - limit and control cpu utilization of any process in linux

One of the critical areas under Linux performance monitoring has to be CPU usage and system load. There are several Linux performance monitoring tools to keep an eye on how things are unfolding on a system.

CPUTool is a simple yet powerful command-line tool for limiting and controlling CPU utilization of any process to a given limit and allows the interruption of process execution if the system load overreach a defined threshold.

In order to limit CPU usage, cputool sends the SIGSTOP and SIGCONT signals to processes and this is determined by the system load. It relies on the /proc pseudo-filesystem to read PIDs and their CPU usage measures.

The --cpu-limit or -c flag is used to set a usage percentage for a process or group of processes and -p to specify a PID. The following command will limit the dd command (PID 8275) to 50% use of one CPU core:

TecMint is the fastest growing and most trusted community site for any kind of Linux Articles, Guides and Books on the web. Millions of people visit TecMint! to search or browse the thousands of published articles available FREELY to all.

The cputool is probably fine for some processes, but not for all of them. The 'dd' command is stopped when operated with cputool and this can be seen if the dd command is being run in the background and then issued a jobs command.

Good concern, we stated it as a range because after limiting CPU usage to a given percentage, the value will not just remain exactly at what you have set. It keeps on changing but remains either slightly lower or higher that the set value.

4.7. softirqs and tasklets - understanding the linux kernel, 3rd edition [book]

We mentioned earlier in the section "Interrupt Handling" that several tasks among those executed by the kernel are not critical: they can be deferred for a long period of time, if necessary. Remember that the interrupt service routines of an interrupt handler are serialized, and often there should be no occurrence of an interrupt until the corresponding interrupt handler has terminated. Conversely, the deferrable tasks can execute with all interrupts enabled. Taking them out of the interrupt handler helps keep kernel response time small. This is a very important property for many time-critical applications that expect their interrupt requests to be serviced in a few milliseconds.

Linux 2.6 answers such a challenge by using two kinds of non-urgent interruptible kernel functions: the so-called deferrable functions [*] (softirqs and tasklets ), and those executed by means of some work queues (we will describe them in the section "Work Queues" later in this chapter).

Softirqs and tasklets are strictly correlated, because tasklets are implemented on top of softirqs. As a matter of fact, the term softirq, which appears in the kernel source code, often denotes both kinds of deferrable functions. Another widely used term is interrupt context : it specifies that the kernel is currently executing either an interrupt handler or a deferrable function.

Softirqs are statically allocated (i.e., defined at compile time), while tasklets can also be allocated and initialized at runtime (for instance, when loading a kernel module). Softirqs can run concurrently on several CPUs, even if they are of the same type. Thus, softirqs are reentrant functions and must explicitly protect their data structures with spin locks. Tasklets do not have to worry about this, because their execution is controlled more strictly by the kernel. Tasklets of the same type are always serialized: in other words, the same type of tasklet cannot be executed by two CPUs at the same time. However, tasklets of different types can be executed concurrently on several CPUs. Serializing the tasklet simplifies the life of device driver developers, because the tasklet function needs not be reentrant.

Marks a deferrable function as pending to be run the next time the kernel schedules a round of executions of deferrable functions. Activation can be done at any time (even while handling interrupts).

Selectively disables a deferrable function so that it will not be executed by the kernel even if activated. Well see in the section "Disabling and Enabling Deferrable Functions" in Chapter 5 that disabling deferrable functions is sometimes essential.

Executes a pending deferrable function together with all other pending deferrable functions of the same type; execution is performed at well-specified times, explained later in the section "Softirqs.

Activation and execution are bound together: a deferrable function that has been activated by a given CPU must be executed on the same CPU. There is no self-evident reason suggesting that this rule is beneficial for system performance. Binding the deferrable function to the activating CPU could in theory make better use of the CPU hardware cache. After all, it is conceivable that the activating kernel thread accesses some data structures that will also be used by the deferrable function. However, the relevant lines could easily be no longer in the cache when the deferrable function is run because its execution can be delayed a long time. Moreover, binding a function to a CPU is always a potentially dangerous operation, because one CPU might end up very busy while the others are mostly idle.

The main data structure used to represent softirqs is the softirq_vec array, which includes 32 elements of type softirq_action. The priority of a softirq is the index of the corresponding softirq_action element inside the array. As shown in Table 4-9, only the first six entries of the array are effectively used. The softirq_action data structure consists of two fields: an action pointer to the softirq function and a data pointer to a generic data structure that may be needed by the softirq function.

Another critical field used to keep track both of kernel preemption and of nesting of kernel control paths is the 32-bit preempt_count field stored in the thread_info field of each process descriptor (see the section "Identifying a Process" in Chapter 3). This field encodes three distinct counters plus a flag, as shown in Table 4-10.

The first counter keeps track of how many times kernel preemption has been explicitly disabled on the local CPU; the value zero means that kernel preemption has not been explicitly disabled at all. The second counter specifies how many levels deep the disabling of deferrable functions is (level 0 means that deferrable functions are enabled). The third counter specifies the number of nested interrupt handlers on the local CPU (the value is increased by irq_enter( ) and decreased by irq_exit( ); see the section "I/O Interrupt Handling" earlier in this chapter).

There is a good reason for the name of the preempt_count field: kernel preemptability has to be disabled either when it has been explicitly disabled by the kernel code (preemption counter not zero) or when the kernel is running in interrupt context. Thus, to determine whether the current process can be preempted, the kernel quickly checks for a zero value in the preempt_count field. Kernel preemption will be discussed in depth in the section "Kernel Preemption" in Chapter 5.

The in_interrupt( ) macro checks the hardirq and softirq counters in the current_thread_info( )->preempt_count field. If either one of these two counters is positive, the macro yields a nonzero value, otherwise it yields the value zero. If the kernel does not make use of multiple Kernel Mode stacks, the macro always looks at the preempt_count field of the thread_info descriptor of the current process. If, however, the kernel makes use of multiple Kernel Mode stacks, the macro might look at the preempt_count field in the thread_info descriptor contained in a irq_ctx union associated with the local CPU. In this case, the macro returns a nonzero value because the field is always set to a positive value.

The last crucial data structure for implementing the softirqs is a per-CPU 32-bit mask describing the pending softirqs; it is stored in the _ _softirq_pending field of the irq_cpustat_t data structure (recall that there is one such structure per each CPU in the system; see Table 4-8). To get and set the value of the bit mask, the kernel makes use of the local_softirq_pending( ) macro that selects the softirq bit mask of the local CPU.

The open_softirq( ) function takes care of softirq initialization. It uses three parameters: the softirq index, a pointer to the softirq function to be executed, and a second pointer to a data structure that may be required by the softirq function. open_softirq( ) limits itself to initializing the proper entry of the softirq_vec array.

If in_interrupt() yields the value 1, it jumps to step 5. This situation indicates either that raise_softirq( ) has been invoked in interrupt context, or that the softirqs are currently disabled.

Checks for active (pending) softirqs should be perfomed periodically, but without inducing too much overhead. They are performed in a few points of the kernel code. Here is a list of the most significant points (be warned that number and position of the softirq checkpoints change both with the kernel version and with the supported hardware architecture):

If the system uses an I/O APIC, when the smp_apic_timer_interrupt( ) function finishes handling a local timer interrupt (see the section "Timekeeping Architecture in Multiprocessor Systems" in Chapter 6)

If pending softirqs are detected at one such checkpoint (local_softirq_pending() is not zero), the kernel invokes do_softirq( ) to take care of them. This function performs the following actions:

If in_interrupt( ) yields the value one, this function returns. This situation indicates either that do_softirq( ) has been invoked in interrupt context or that the softirqs are currently disabled.

If the size of the thread_union structure is 4 KB, it switches to the soft IRQ stack, if necessary. This step is very similar to step 2 of do_IRQ( ) in the earlier section "I/O Interrupt Handling; of course, the softirq_ctx array is used instead of hardirq_ctx.

If the soft IRQ stack has been effectively switched in step 3 above, it restores the original stack pointer into the esp register, thus switching back to the exception stack that was in use before.

The _ _do_softirq( ) function reads the softirq bit mask of the local CPU and executes the deferrable functions corresponding to every set bit. While executing a softirq function, new pending softirqs might pop up; in order to ensure a low latency time for the deferrable funtions, _ _do_softirq( ) keeps running until all pending softirqs have been executed. This mechanism, however, could force _ _do_softirq( ) to run for long periods of time, thus considerably delaying User Mode processes. For that reason, _ _do_softirq( ) performs a fixed number of iterations and then returns. The remaining pending softirqs, if any, will be handled in due time by the ksoftirqd kernel thread described in the next section. Here is a short description of the actions performed by the function:

Invokes local_bh_disable( ) to increase the softirq counter. It is somewhat counterintuitive that deferrable functions should be disabled before starting to execute them, but it really makes a lot of sense. Because the deferrable functions mostly run with interrupts enabled, an interrupt can be raised in the middle of the _ _do_softirq( ) function. When do_IRQ( ) executes the irq_exit( ) macro, another instance of the _ _do_softirq( ) function could be started. This has to be avoided, because deferrable functions must execute serially on the CPU. Thus, the first instance of _ _do_softirq( ) disables deferrable functions, so that every new instance of the function will exit at step 1 of do_softirq( ).

Clears the softirq bitmap of the local CPU, so that new softirqs can be activated (the value of the bit mask has already been saved in the pending local variable in step 2).

For each bit set in the pending local variable, it executes the corresponding softirq function; recall that the function address for the softirq with index n is stored in softirq_vec[n]->action.

If pending is not zeroat least one softirq has been activated since the start of the last iterationand the iteration counter is still positive, it jumps back to step 4.

In recent kernel versions, each CPU has its own ksoftirqd/n kernel thread (where n is the logical number of the CPU). Each ksoftirqd/n kernel thread runs the ksoftirqd( ) function, which essentially executes the following loop:

When awakened, the kernel thread checks the local_softirq_pending() softirq bit mask and invokes, if necessary, do_softirq( ). If there are no softirqs pending, the function puts the current process in the TASK_INTERRUPTIBLE state and invokes then the cond_resched() function to perform a process switch if required by the current process (flag TIF_NEED_RESCHED of the current thread_info set).

Softirq functions may reactivate themselves; in fact, both the networking softirqs and the tasklet softirqs do this. Moreover, external events, such as packet flooding on a network card, may activate softirqs at very high frequency.

The potential for a continuous high-volume flow of softirqs creates a problem that is solved by introducing kernel threads. Without them, developers are essentially faced with two alternative strategies.

The first strategy consists of ignoring new softirqs that occur while do_softirq( ) is running. In other words, the do_softirq( ) function could determine what softirqs are pending when the function is started and then execute their functions. Next, it would terminate without rechecking the pending softirqs. This solution is not good enough. Suppose that a softirq function is reactivated during the execution of do_softirq( ). In the worst case, the softirq is not executed again until the next timer interrupt, even if the machine is idle. As a result, softirq latency time is unacceptable for networking developers.

The second strategy consists of continuously rechecking for pending softirqs. The do_softirq( ) function could keep checking the pending softirqs and would terminate only when none of them is pending. While this solution might satisfy networking developers, it can certainly upset normal users of the system: if a high-frequency flow of packets is received by a network card or a softirq function keeps activating itself, the do_softirq( ) function never returns, and the User Mode programs are virtually stopped.

The ksoftirqd/n kernel threads try to solve this difficult trade-off problem. The do_softirq( ) function determines what softirqs are pending and executes their functions. After a few iterations, if the flow of softirqs does not stop, the function wakes up the kernel thread and terminates (step 10 of _ _do_softirq( )). The kernel thread has low priority, so user programs have a chance to run; but if the machine is idle, the pending softirqs are executed quickly.

Tasklets are the preferred way to implement deferrable functions in I/O drivers. As already explained, tasklets are built on top of two softirqs named HI_SOFTIRQ and TASKLET_SOFTIRQ. Several tasklets may be associated with the same softirq, each tasklet carrying its own function. There is no real difference between the two softirqs, except that do_softirq( ) executes HI_SOFTIRQs tasklets before TASKLET_SOFTIRQs tasklets.

Tasklets and high-priority tasklets are stored in the tasklet_vec and tasklet_hi_vec arrays, respectively. Both of them include NR_CPUS elements of type tasklet_head, and each element consists of a pointer to a list of tasklet descriptors. The tasklet descriptor is a data structure of type tasklet_struct, whose fields are shown in Table 4-11.

When set, this indicates that the tasklet is pending (has been scheduled for execution); it also means that the tasklet descriptor is inserted in one of the lists of the tasklet_vec and tasklet_hi_vec arrays.

When set, this indicates that the tasklet is being executed; on a uniprocessor system this flag is not used because there is no need to check whether a specific tasklet is running.

Lets suppose youre writing a device driver and you want to use a tasklet: what has to be done? First of all, you should allocate a new tasklet_struct data structure and initialize it by invoking tasklet_init( ); this function receives as its parameters the address of the tasklet descriptor, the address of your tasklet function, and its optional integer argument.

The tasklet may be selectively disabled by invoking either tasklet_disable_nosync( ) or tasklet_disable( ). Both functions increase the count field of the tasklet descriptor, but the latter function does not return until an already running instance of the tasklet function has terminated. To reenable the tasklet, use tasklet_enable( ).

To activate the tasklet, you should invoke either the tasklet_schedule( ) function or the tasklet_hi_schedule( ) function, according to the priority that you require for the tasklet. The two functions are very similar; each of them performs the following actions:

Adds the tasklet descriptor at the beginning of the list pointed to by tasklet_vec[n] or tasklet_hi_vec[n], where n denotes the logical number of the local CPU.

Invokes raise_softirq_irqoff( ) to activate either the TASKLET_SOFTIRQ or the HI_SOFTIRQ softirq (this function is similar to raise_softirq( ), except that it assumes that local interrupts are already disabled).

Finally, lets see how the tasklet is executed. We know from the previous section that, once activated, softirq functions are executed by the do_softirq( ) function. The softirq function associated with the HI_SOFTIRQ softirq is named tasklet_hi_action( ), while the function associated with TASKLET_SOFTIRQ is named tasklet_action( ). Once again, the two functions are very similar; each of them:

If it is set, a tasklet of the same type is already running on another CPU, so the function reinserts the task descriptor in the list pointed to by tasklet_vec[n] or tasklet_hi_vec[n] and activates the TASKLET_SOFTIRQ or HI_SOFTIRQ softirq again. In this way, execution of the tasklet is deferred until no other tasklets of the same type are running on other CPUs.

Checks whether the tasklet is disabled by looking at the count field of the tasklet descriptor. If the tasklet is disabled, it clears its TASKLET_STATE_RUN flag and reinserts the task descriptor in the list pointed to by tasklet_vec[n] or tasklet_hi_vec[n]; then the function activates the TASKLET_SOFTIRQ or HI_SOFTIRQ softirq again.

[*] These are also called software interrupts, but we denote them as deferrable functions to avoid confusion with programmed exceptions, which are referred to as software interrupts " in Intel manuals.

introduction to linsmith

linSmith is a Smith Charting program, mainly designed for educational use. As such, there is an emphasis on capabilities that improve the 'showing the effect of'-style of operation. Postscript output It's main features are: Definition of multiple load impedances (at different frequencies) Addition of discrete (L, C, parallel and series LC, and transformer) and line components (open and closed stubs, line segments) Connection in series and parallel Easy experimentation with values using scrollbars A 'virtual' component switches from impedance to admittance to help explaining (or understanding) parallel components The chart works in real impedances (not normalized ones) Direct view of the result on the screen Ability to generate publication quality Postscript output A 'log' file with textual results at each intermediate step Load and circuit configuration is stored separately, permitting several solutions without re-defining the other (this may actually change to single files - I'm not quite convinced here) Some distributions have made packages available for easier installation. Be aware that they may be outdated. In that case, consider compiling compiling your own, it's not really that difficult! Thanks This program was written with the help of the GIMP toolkit (GTK+), a marvelous piece of work, and uses the gnome-print library to generate Postscript output. Of course, it was developed on Linux, using the gcc compiler suite and the Glade GUI development system. Graphics items were designed using the GIMP itself. I'd like to thank Georg Baum for convincing me to publish the program, and for his help with the packaging. Also thanks to Once (WanShi) Shuiqing for reporting bugs and translating into Chinese (see image). Chinese translation A reference to linSmith appeared in an article in High Frequency Electronics of Jan/2009 by Anthony Bichler. Thanks! Thanks to SourceForge for the downloading and management services. A note about Tucows I've had some remarks about the fact that the Tucows listing is not updated regularly, and is always lagging behind. A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

Postscript output It's main features are: Definition of multiple load impedances (at different frequencies) Addition of discrete (L, C, parallel and series LC, and transformer) and line components (open and closed stubs, line segments) Connection in series and parallel Easy experimentation with values using scrollbars A 'virtual' component switches from impedance to admittance to help explaining (or understanding) parallel components The chart works in real impedances (not normalized ones) Direct view of the result on the screen Ability to generate publication quality Postscript output A 'log' file with textual results at each intermediate step Load and circuit configuration is stored separately, permitting several solutions without re-defining the other (this may actually change to single files - I'm not quite convinced here) Some distributions have made packages available for easier installation. Be aware that they may be outdated. In that case, consider compiling compiling your own, it's not really that difficult! Thanks This program was written with the help of the GIMP toolkit (GTK+), a marvelous piece of work, and uses the gnome-print library to generate Postscript output. Of course, it was developed on Linux, using the gcc compiler suite and the Glade GUI development system. Graphics items were designed using the GIMP itself. I'd like to thank Georg Baum for convincing me to publish the program, and for his help with the packaging. Also thanks to Once (WanShi) Shuiqing for reporting bugs and translating into Chinese (see image). Chinese translation A reference to linSmith appeared in an article in High Frequency Electronics of Jan/2009 by Anthony Bichler. Thanks! Thanks to SourceForge for the downloading and management services. A note about Tucows I've had some remarks about the fact that the Tucows listing is not updated regularly, and is always lagging behind. A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

Definition of multiple load impedances (at different frequencies) Addition of discrete (L, C, parallel and series LC, and transformer) and line components (open and closed stubs, line segments) Connection in series and parallel Easy experimentation with values using scrollbars A 'virtual' component switches from impedance to admittance to help explaining (or understanding) parallel components The chart works in real impedances (not normalized ones) Direct view of the result on the screen Ability to generate publication quality Postscript output A 'log' file with textual results at each intermediate step Load and circuit configuration is stored separately, permitting several solutions without re-defining the other (this may actually change to single files - I'm not quite convinced here) Some distributions have made packages available for easier installation. Be aware that they may be outdated. In that case, consider compiling compiling your own, it's not really that difficult!

Some distributions have made packages available for easier installation. Be aware that they may be outdated. In that case, consider compiling compiling your own, it's not really that difficult!

Thanks This program was written with the help of the GIMP toolkit (GTK+), a marvelous piece of work, and uses the gnome-print library to generate Postscript output. Of course, it was developed on Linux, using the gcc compiler suite and the Glade GUI development system. Graphics items were designed using the GIMP itself. I'd like to thank Georg Baum for convincing me to publish the program, and for his help with the packaging. Also thanks to Once (WanShi) Shuiqing for reporting bugs and translating into Chinese (see image). Chinese translation A reference to linSmith appeared in an article in High Frequency Electronics of Jan/2009 by Anthony Bichler. Thanks! Thanks to SourceForge for the downloading and management services. A note about Tucows I've had some remarks about the fact that the Tucows listing is not updated regularly, and is always lagging behind. A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

This program was written with the help of the GIMP toolkit (GTK+), a marvelous piece of work, and uses the gnome-print library to generate Postscript output. Of course, it was developed on Linux, using the gcc compiler suite and the Glade GUI development system. Graphics items were designed using the GIMP itself. I'd like to thank Georg Baum for convincing me to publish the program, and for his help with the packaging. Also thanks to Once (WanShi) Shuiqing for reporting bugs and translating into Chinese (see image). Chinese translation A reference to linSmith appeared in an article in High Frequency Electronics of Jan/2009 by Anthony Bichler. Thanks! Thanks to SourceForge for the downloading and management services. A note about Tucows I've had some remarks about the fact that the Tucows listing is not updated regularly, and is always lagging behind. A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

I'd like to thank Georg Baum for convincing me to publish the program, and for his help with the packaging. Also thanks to Once (WanShi) Shuiqing for reporting bugs and translating into Chinese (see image).

Thanks to SourceForge for the downloading and management services. A note about Tucows I've had some remarks about the fact that the Tucows listing is not updated regularly, and is always lagging behind. A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

A note about Tucows I've had some remarks about the fact that the Tucows listing is not updated regularly, and is always lagging behind. A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

I've had some remarks about the fact that the Tucows listing is not updated regularly, and is always lagging behind. A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

A non-paying free software entry at Tucows normally takes 40 - 60 days to get to the top of the waiting list - more if some mistake is made at the presentation. Of course, as I don't get paid for the software, I cannot afford to pay for 'preferencial' treatment. (Note: Updating Tucows now takes around 200 (!) days. I've given given up...) This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

This is also the reason for the fact that linSmith is not rated. The rating has to be paid for... Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

Local copies Archivo Tamao Contenido linsmith-0.99.30.tar.gz 1.1 MB Last published version linsmith-0.99.31.tar.gz 1.1 MB Development Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

Wish list Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

Things I'd like to add: Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

Arrows to the connecting lines and arcs Labels to the impedances Input of impedances as S-parameters (maybe Y-parameters too) Optional lines through points indicating wavelengths Export the numeric impedance list to a text file (csv?) Export of a screen shot of the map (but not just the visible part) to an image file Make the points moveable by dragging them on the chart (the handler is already in place) Some kind of auto-optimization? Automatically generate a legend of the colors used. 123413 (c) John Coppens ON6JC/LW3HAZ mail

high frequency buzz (sound) with mostly white screen - ars technica openforum

Does anyone know the cause(s) of a high frequency sound that occurs on monitors for certain screens (this seems mostly when white but not always)? It seems to happen on both my new Samsung 900IFT and an old CTX 17" and with different vid cards. It seems to be helped by turning the contrast down (and hence monitor related), but then it doesn't seem to be set up right to me anyway.Related, what's the best procedure for adjusting a monitor, I never seem to have much luck with it?dlr(2)

The high-frequency sound is caused by inverse microphonics in the flyback transformer. The plates that make up the core of the FT are slightly moving and rubbing against one another, causing the sound. It's greatest when there's lots of white on the screen because that's when the amplitude of the signal applied to the FT is greatest, which causes more movement and hence more sound. Switch to a higher resolution and the sound will probably increase in pitch, possibly to ultrasonic. The only other way to get rid of it is to stick flat toothpicks between the plates of the transformer core, something that ordinary mortals should probably not attempt. View image: /infopop/emoticons/icon_wink.gif

White (and also red) commonly cause this effect. When a monitor isn't properly shielded, and that monitor approaches 100 IRE (think of that as brightness), that high video signal "leaks out" and into the audio, where it manifests itself as a whine or a buzz depending on the frequency (the color being shown) and the amount of leakage (how bright the screen is, and thus how much leakage occurrs).Happens alot in television, especially in live shots via satellite. Guy gets in front of the camera wearing a white or red shirt/jacket/whatever and there's a buzz.

Sounds like there is nothing to try except switching to a higher res (already at 85hz), me being a mere mortal and all View image: /infopop/emoticons/icon_biggrin.gif . Thanks for the great answers, as is always the case at Ars (sorry feeling a bit of attachment given the financial troubles going on now).dlr(2)

2021 Cond Nast. All rights reserved Use of this Site constitutes acceptance of our User Agreement (updated 1/1/20) and Privacy Policy and Cookie Statement (updated 1/1/20) and Ars Technica Addendum (effective 8/21/2018). Ars may earn compensation on sales from links on this site. Read our affiliate link policy. Your California Privacy Rights | Do Not Sell My Personal Information The material on this site may not be reproduced, distributed, transmitted, cached or otherwise used, except with the prior written permission of Cond Nast. Ad Choices

activity: low pass and high pass filters [analog devices wiki]

As in all the ALM labs we use the following terminology when referring to the connections to the M1000 connector and configuring the hardware. The green shaded rectangles indicate connections to the M1000 analog I/O connector. The analog I/O channel pins are referred to as CA and CB. When configured to force voltage / measure current -V is added as in CA-V or when configured to force current / measure voltage -I is added as in CA-I. When a channel is configured in the high impedance mode to only measure voltage -H is added as CA-H.

The impedance of an inductor is proportional to frequency and the impedance of a capacitor is inversely proportional to frequency. These characteristics can be used to select or reject certain frequencies of an input signal. This selection and rejection of frequencies is called filtering, and a circuit which does this is called a filter.

If a filter passes high frequencies and rejects low frequencies, then it is a high-pass filter. Conversely, if it passes low frequencies and rejects high ones, it is a low-pass filter. Filters, like most things, aren't perfect. They don't absolutely pass some frequencies and absolutely reject others. A frequency is considered passed if its magnitude (voltage amplitude) is within 70% or 1/sqrt(2) of the maximum amplitude passed and rejected otherwise. The 70% frequency is called corner frequency, roll-off frequency or half-power frequency.

Frequency Response: It is a graph of magnitude of the output voltage of the filter as a function of the frequency. It is generally used to characterize the range of frequencies in which the filter is designed to operate within.

2. Set the channel A AWG Min value to 0.5 and Max value to 4.5V to apply a 4Vp-p sine wave centered on 2.5 V as the input voltage to the circuit. From the AWG A Mode drop down menu select the SVMI mode. From the AWG A Shape drop down menus select Sine. From the AWG B Mode drop down menu select the Hi-Z mode.

3. From the ALICE Curves drop down Menu select CA-V, and CB-V for display. From the Trigger drop down menu select CA-V and Auto Level. Set the Hold Off to 2 (mSec). Adjust the time base until you have at approximately two cycles of the sine wave on the display grid. From the Meas CA drop down menu select P-P under CA-V and do the same for CB. Also from the Meas CA menu select A-B Phase.

4. Start with a low frequency, 50 Hz, and measure output voltage CB-V peak to peak from the scope screen. It should be same as channel A output. Increase the frequency of channel A in small increments until the peak-peak voltage of channel B is roughly 0.7 times the peak to peak voltage for channel A. Compute the 70 % of Vp-p and obtain the frequency at which this happens on the Oscilloscope. This gives the cut-off (roll-off) frequency for the constructed Low Pass RC filter.

3. Start with a high frequency 20 KHz and measure output voltage CB-V peak to peak from the scope screen. It should be same as channel A output. Lower the frequency of channel A in small increments until the peak-peak voltage of channel B is roughly 0.7 times the peak to peak voltage for channel A. Compute the 70 % of Vp-p and obtain the frequency at which this happens on the Oscilloscope. This gives the cut-off (roll-off) frequency for the constructed High Pass RL filter.

Calculate the Cut-off frequencies for the RC low pass and RL high pass filter using equations (1) and (2). Compare the computed theoretical values to the ones obtained from the experimental measurements and provide a suitable explanation for any differences.

The ALICE desk-top Bode Plotting software can make generating frequency and phase response plots much easier. Using the low pass RC circuit in figure 1, with R1=100 and C1=1.0 uF, we can sweep the input frequency from 10 Hz to 5000 Hz and plot the signal amplitude of both channel A and B and the relative phase angle between channel B and A.

Set AWG channel A Min value to 1.086 and Max value to 3.914. This will be a 1 Vrms (0 dBV) amplitude centered on the 2.5V middle of the analog input range. Set AWG A mode to SVMI and Shape to Sine. Set AWG channel B to Mode Hi-Z. Be sure the Sync AWG check box is selected.

Use the Start Frequency entry to set the frequency sweep to start at 100 Hz and use the Stop Frequency entry to the sweep to stop at 20000 Hz. Select CHA as the channel to sweep. Also use the Sweep Steps button to enter the number of frequency steps, use 100 as the number.

You should now be able to press the green Run button and run the frequency sweep. After the sweep is completed you should see something like the screen shot in figure A1. You may want to use the LVL and dB/div buttons to optimize the plots to best fit the screen grid.

Some cookies are required for secure log-ins but others are optional for functional activities. Our data collection is used to improve our products and services. We recommend you accept our cookies to ensure youre receiving the best performance and functionality our site can provide. For additional information you may view the cookie details. Read more about our privacy policy.

dslogic series dreamsourcelab

Oscilloscope is wonderful for analyzing periodic voltage and noise changes; Logic analyzer only record low/high status, and is much better at analyzing process of digital communications and complex protocols.

IC, UART, SPI, CAN, IS, JTAG, 1-Wire link layer, DMX512, PWM, Parallel, SWD, USB PD, USB signalling, SWIM, SD card (SD mode), PS/2, MDIO, Stepper motor, Timing, Z80, AC 97, Counter, IR NEC, IR RC-5, AM230x, AUD, AVR PDI, CEC, DALI, DCF77, DSI, EM4100, EM4305, GPIB, Gray code, Guess bitrate, Jitter, LPC, Maple bus, MCS-48, Microwire, Miller, Morse, OOK, Qi, RC encode, RGB LED (WS281x), SDA2506, S/PDIF, ST7735, T55xx, TI TLC5620, Wiegand

LIN, 24xx EEPROM, 93xx EEPROM, USB request, USB packet, 1-Wire network layer, AVR ISP, nRF24L01(+), RGB LED (SPI), SD card (SPI mode), SPI flash/EEPROM, Modbus, MIDI, IC demux, IC filter, ARM ETMv3, ARM ITM, ARM TPIU, ATSHA204A, DS1307, EDID, LM75, MLX90614, MXC6225XU, Nunchuk, RTC-8564, TI TCA6408A, XFP, JTAG / EJTAG, JTAG / STM32, CFP, DS243x, DS28EA00, Oregon, OOK visualisation, ADE77xx, ADF435x, ADNS-5020, MAX7219, MRF24J40, RFM12, SSI32, PAN1321

hacking rfid tags is easier than you think: black hat | eweek

UPDATED SEPT. 28, 2016: In the last three years, much has changed in RFID technology. In 2013, 125KHz RFID proximity badges were the default in nearly all deployments, but thats no longer the case in 2016.

In a follow-up interview, Francis Brown, managing partner at security firm Bishop Fox, noted that since 2013, he has seen many organizations make the switch to newer, more secure high-frequency contactless card systems. Despite increased efforts and progress made by some companies in recent years to upgrade to more secure contactless card systems, the large majority of physical access control systems out there are still legacy 125KHz proximity card deployments, he said.

I think my 2013 talk really hit home for a lot of people, and finally broke the inertia and motivated companies to take corrective action and protect themselves, Brown told eWEEK. It ended up getting a lot of attention, especially when the hit show, Mr. Robot, ended up using the Tastic RFID Thief to pull off their biggest hack against Evil Corp. in Season 1 [July 2015].

The same Tastic RFID Thief tool that Brown built in 2013 still works in 2016. The original attack focused on the 125KHz RFID system, but since 2013, Bishop Fox has demonstrated how it can be used to attack newer high-frequency badge systems like those for HID iCLASS access control systems, Brown said.At Defcon 23 in 2015, Brown released additional tools for RFID hacking of badges, readers and controllers. Bishop Fox maintains a web page where it lists the current tools that are available.Bishop Fox demonstrated its Danger Drone airborne hacking technology at the Black Hat USA 2016 security conference. Its a tool that Brown unabashedly admits has been used for RFID badge stealing, too.Ill admit, the Danger Drone isnt as practical of a tool for RFID badge stealing when compared to walking by someone with the stealthy Tastic RFID Reader hidden in a messenger bag, Brown said. However, it is a bit more fun. Im sure you can imagine scenarios where we have the drone flying by unsuspecting business folks, getting within the couple feet necessary to get a read on their proximity badges and scaring the crap out of them. On a more serious note, Brown said that the Danger Drone was originally conceived as a possible alternative to RFID badge hacking attacks altogether. The Tastic RFID Thief was designed to steal badge info, so that Bishop Fox researchers could create a cloned card and then enter a target facility in order to gain physical access to restricted internal networks and devices. While the Tastic RFID Thief approach has been effective for Bishop Fox thus far, Brown said that with the Danger Drone, his company could eliminate its physical exposure and risk of being apprehended.Rather than breaking in and plugging in, we could instead land on the roof, hack the WiFi and obtain the same unauthorized access to a target buildings internal network, Brown said.Heres eWEEKs Original Report From July 31, 2013:

LAS VEGASRadio-frequency identification tags are widely deployed around the world and commonly used for building security system cards. As it turns out, those RFID security cards might not be all that secure.

That is the conclusion of Francis Brown, managing partner at security firm Bishop Fox, who detailed his research on RFID hacking on July 31 at the Black Hat security conference here. In an interview with eWEEK, Brown said he started out doing his RFID research focused on a specific requirement: He needed to break in to a building.

Although there are multiple types of RFID technologies, the focus of Browns efforts is on the 125KHz frequency, which is the primary technology used for badge readers and physical security systems in buildings.

To aid in the silent theft of RFID information from unassuming passersby, Brown developed an open-source Arduino-based tool. Arduino is an open-source electronic prototyping platform often used by artists, designers and others.

What I basically did, is take a long-range reader, that is typically meant for parking garages, to collect the RFID data, Brown said. Normally, youd run a wire from the reader down a pole and into a building with a computer that makes the decision on whether the badge is valid or not.

The number-one catch with the RFID badge sleeve is that some of them work and some of them dont, Brown said. My recommendation is that before you buy them, make sure you test them out to make sure they actually work.

Property of TechnologyAdvice. Terms of Service | Privacy Notice | Advertise | California - Do Not Sell My Information 2021 TechnologyAdvice. All Rights Reserved Advertiser Disclosure: Some of the products that appear on this site are from companies from which TechnologyAdvice receives compensation. This compensation may impact how and where products appear on this site including, for example, the order in which they appear. TechnologyAdvice does not include all companies or all types of products available in the marketplace.

will a low pixel response time (1-8ms) high frequency (120-144hz) ips laptop screen have the same low pixel response time run at 60hz as well? - displays - linus tech tips

I want to replace my slow very high pixel response time IPS laptop screen because motion blur is unbearable. I am not sure my GPUs support the high frequencies (120-144Hz), so I may need to run it at 60Hz. I want to make sure the low pixel response time is also present at 60Hz.

Not always. And, a lot of times it's only achievable when using the highest overdrive setting which can cause serious overshoot. You should try to find reviews from trusted sources to know for sure.

CPU:AMD Ryzen 9 5900X Cooler:Noctua NH-U12S chromax.black Motherboard:MSI MEG X570 Unify RAM:G.skill Ripjaws V 2x16GB 3600MHz CL16 Graphics Card:ASUSGeForce RTX 3060 Ti TUF Gaming Boot Drive:500GB WD Black SN750 M.2 NVMe SSD Game Drive:2TB Crucial MX500 SATA SSD PSU:EVGA SuperNova 650 G+ 650W 80+ Gold Case:Fractal Design Meshify C Monitor:MSI Optix MAG342CQR 34 UWQHD 3440x1440 144Hz

Also remember, a Display will always run at the set refresh rate indicated under your display settings unless variable refresh is enabled. So u can play at 60fps while refreshing at 120hz for example, with Vsync enabled to remove tearing.

If however u enable Gsync or FreeSync and run at 60fps, THEN your display with refresh at the given Frame rate. When this happens ull likely end up slowing down the pixel response. Should this be the case, u can tune any overdrive settings available to that frequency to overcome said slower pixel response.

However once u exit the specific game ur playing, and play a different game with higher FPS, that overdrive setting will likely be to high resulting in overshoot or possibly to low resulting in a slower pixel response that would could be achieved with a higher overdrive setting.

gpu stuck at max memory clock! - graphics cards - linus tech tips

Reinstalling the graphics driver doesn't always make a difference as there are always files left over scattered throughout the system. I would check in the driver itself if there is a high-performance option there that got checked somehow. I haven't had an AMD card in quite some time, but there should be something of that sort. Another thing to check is if you accidentally pressed the dual-BIOS button of that card. It has a legacy and UEFI mode. Could be something with that.

CPU: AMD Ryzen 9 - 3900x @ 4.4GHz with a Custom Loop | MBO:ASUS Crosshair VI Extreme| RAM:4x4GB Apacer 2666MHz overclocked to 3933MHz with OCZ Reaper HPC Heatsinks| GPU: PowerColor Red Devil 6900XT | SSDs:Intel 660P 512GB SSD and Intel 660P 1TB SSD| HDD: 2x WD Black 6TB and Seagate Backup Plus 8TB External Drive| PSU: Corsair RM1000i | Case: Cooler Master C700P Black Edition |Build Log:here

Reinstalling the graphics driver doesn't always make a difference as there are always files left over scattered throughout the system. I would check in the driver itself if there is a high-performance option there that got checked somehow. I haven't had an AMD card in quite some time, but there should be something of that sort. Another thing to check is if you accidentally pressed the dual-BIOS button of that card. It has a legacy and UEFI mode. Could be something with that.

CPU: AMD Ryzen 9 - 3900x @ 4.4GHz with a Custom Loop | MBO:ASUS Crosshair VI Extreme| RAM:4x4GB Apacer 2666MHz overclocked to 3933MHz with OCZ Reaper HPC Heatsinks| GPU: PowerColor Red Devil 6900XT | SSDs:Intel 660P 512GB SSD and Intel 660P 1TB SSD| HDD: 2x WD Black 6TB and Seagate Backup Plus 8TB External Drive| PSU: Corsair RM1000i | Case: Cooler Master C700P Black Edition |Build Log:here

how to get buffer from avaudioengine's installtap at high frequency - techinplanet

I am looking to render audio waveform on screen like iOS voice memo app, so I am using AVAudioEngine and installed Tap on input node. But it gives fastest call back on 0.1sec frequency , I need to get buffer data on faster frequency , so that can draw more and more waveform on screen for smooth and realtime visualisation.

I think you misunderstand how to handle this. Instead of getting very small amounts of new data at a high frequency, you should factor your code to get a larger chunk of data on a longer time interval.

You can then set up your display code to start an animation to animate in a graph of the new data over the time interval you are given. 1/10th of a second is actually a pretty short time interval for an animation.

Asked By: Anonymous I have a setupController and model hook in my route. The model.find(param) holds a ajax call to the rails backend. What happens is that my model hook fires and calls to the backend. But before the...

Asked By: Anonymous How do I allow users to input something in the terminal when JS is running? This is what Im trying to do to be more specific. Hello, What is your Name? > Theodore Oh, Hello Theodore! I...

Asked By: Anonymous I have two lists with several columns. Some columns are different, but many are the same and are in different order. How can I compare List1 to List2, and (for example) delete row 34 of List1 because...

Asked By: Anonymous I am trying to create a simple server (.Net Core 5.0), that communicates with PostgreSQL DB (v 13.1) via Npgsql + Npgsql.EntityFramework. I have code that creates a new user, grants some rights and...

Asked By: Anonymous I installed rustup with brew command but still says that rustup command is not found. I am not sure if I am missing any installation step. Any help would be appreciated. Solution Answered By:...