Free kommando xy software for linux

QtDSO is a frontend for the Velleman PCS64i digital oscilloscope. The project provides a fully featured oscillocope mode (including XY plot and math) and a highly configurable spectrum analyzer mode. It has been tested with the Velleman scope and didnt show problems here.

If you encounter problems with your scope at home, dont use QtDSO. I will not take ANY responsibility on your hardware.
QtDSO is kind of "works for me" software. Im using it, I like it the way it is and it seems to be quite stable. It still needs some improvements but does its job quite well.
QtDSO is distributed under the terms of the GNU Public License, version 2.

My special thanks to Martin Bammer who gave me a valuable hint how to read data from the scope (Unfortunately the manual didnt provide schematics for the opto coupler part. This caused some head scratching on my side.). Also thanks to Velleman for providing me with detailed information.

Image::Xpm is a Perl module that can load, create, manipulate and save xpm image files.

SYNOPSIS

use Image::Xpm;

my $j = Image::Xpm->new(-file, Camel.xpm);

my $i = Image::Xpm->new(-width => 10, -height => 16);

my $h = $i->new; # Copy of $i

$i->xy(5, 8, red); # Set a colour (& add to palette if necessary)
print $i->xy(9, 3); # Get a colour

$i->xy(120, 130, #1256DD);
$i->xy(120, 130, $i->rgb2colour(66, 0x4D, 31));

$i->vec(24, #808080); # Set a colour using a vector offset
print $i->vec(24); # Get a colour using a vector offset

print $i->get(-width); # Get and set object attributes
$i->set(-height, 15);

$i->load(test.xpm);
$i->save;

# Changing just the palette
$i->add_colours(qw(red green blue #123456 #C0C0C0));
$i->del_colour(blue);

This class module provides basic load, manipulate and save functionality for the xpm file format. It inherits from Image::Base which provides additional manipulation functionality, e.g. new_from_image(). See the Image::Base pod for information on adding your own functionality to all the Image::Base derived classes.

new()
my $i = Image::Xpm->new(-file => test.xpm);
my $j = Image::Xpm->new(-width => 12, -height => 18);
my $k = $i->new;

We can create a new xpm image by reading in a file, or by creating an image from scratch (all the pixels are white by default), or by copying an image object that we created earlier.

If we set -file then all the other arguments are ignored (since theyre taken from the file). If we dont specify a file, -width and -height are mandatory and -cpp will default to 1 unless specified otherwise.

-file

The name of the file to read when creating the image. May contain a full path. This is also the default name used for loading and saveing, though it can be overridden when you load or save.

-width

The width of the image; taken from the file or set when the object is created; read-only.

-height

The height of the image; taken from the file or set when the object is created; read-only.

-cpp

Characters per pixel. Commonly 1 or 2, default is 1 for images created by the module; read-only.

See the example for how to change an images cpp.

-hotx

The x-coord of the images hotspot; taken from the file or set when the object is created. Set to -1 if there is no hotspot.

-hoty

The y-coord of the images hotspot; taken from the file or set when the object is created. Set to -1 if there is no hotspot.

-ncolours

The number of unique colours in the palette. The image may not be using all of them; read-only.

-cindex

An hash whose keys are colour names, e.g. #123456 or blue and whose values are the palette names, e.g. , #, etc; read-only. If you want to add more colours to the image itself simply write pixels with the new colours using xy; if you want to add more colours to the palette without necessarily using them in the image use add_colours.

-palette

A hash whose keys are the palette names, e.g. , #, etc. and whose values are hashes of colour type x colour name pairs, e.g. c => red, etc; read-only. If you want to add more colours to the image itself simply write pixels with the new colours using xy; if you want to add more colours to the palette without necessarily using them in the image use add_colours.

-pixels

A string of palette names which constitutes the data for the image itself; read-only.

-extname

The name of the extension text if any; commonly XPMEXT; read-only.

-extlines

The lines of text of any extensions; read-only.

-comments

An array (possibly empty) of comment lines that were in a file that was read in; they will be written out although we make no guarantee regarding their placement; read-only.
get()

my $width = $i->get(-width);
my ($hotx, $hoty) = $i->get(-hotx, -hoty);

Get any of the objects attributes. Multiple attributes may be requested in a single call.

See xy and vec to get/set colours of the image itself.

set()
$i->set(-hotx => 120, -hoty => 32);

Set any of the objects attributes. Multiple attributes may be set in a single call; some attributes are read-only.

See xy and vec to get/set colours of the image itself.

xy()
$i->xy(4, 11, #123454); # Set the colour at point 4,11
my $v = $i->xy(9, 17); # Get the colour at point 9,17

Get/set colours using x, y coordinates; coordinates start at 0. If the colour does not exist in the palette it will be added automatically.

When called to set the colour the value returned is characters used for that colour in the palette; when called to get the colour the value returned is the colour name, e.g. blue or #f0f0f0, etc, e.g.

$colour = xy($x, $y); # e.g. #123456
$cc = xy($x, $y, $colour); # e.g. !

We dont normally pick up the return value when setting the colour.

vec()
$i->vec(43, 0); # Unset the bit at offset 43
my $v = $i->vec(87); # Get the bit at offset 87

Get/set bits using vector offsets; offsets start at 0. The offset of a pixel is ((y * width * cpp) + (x * cpp)).

The sort of return value depends on whether we are reading (getting) or writing (setting) the colour - see xy for an explanation.

rgb2colour() and rgb2color()
$i->rgb2colour(0xff, 0x40, 0x80); # Returns #ff4080
Image::Xpm->rgb2colour(10, 20, 30); # Returns #0a141e

Convenience class or object methods which accept three integers and return a colour name string.

load()
$i->load;
$i->load(test.xpm);

Load the image whose name is given, or if none is given load the image whose name is in the -file attribute.

save()
$i->save;
$i->save(test.xpm);

Save the image using the name given, or if none is given save the image using the name in the -file attribute. The image is saved in xpm format.

add_colours() and add_colors()
$i->add_colours(qw(#C0C0DD red blue #123456));

These are for adding colours to the palette; you dont need to use them to set a pixels colour - use xy for that.

Add one or more colour names either as hex strings or as literal colour names. These are always added as type c colours; duplicates are ignored.

NB If you just want to set some pixels in colours that may not be in the palette, simply do so using xy since new colours are added automatically.

del_colour() and del_color()
$i->del_colour(green);

Delete a colour from the palette; returns undef if the colour isnt in the palette, false (0) if the colour is in the palette but also in the image, or true (1) if the colour has been deleted (i.e. it was in the palette but not in use in the image).

Math::NumberCruncher Perl module contains a collection of useful math-related functions.

SYNOPSIS

It should be noted that as of v4.0, there is now an OO interface to Math::NumberCruncher. For backwards compatibility, however, the previous, functional style will always be supported.

# OO Style

use Math::NumberCruncher;

$ref = Math::NumberCruncher->new();

# From this point on, all of the subroutines shown below will be available # through $ref (i.e., ( $high,$low ) = $ref->Range( @array )). For the sake # of brevity, consult the functional documentation (below) for the use # of specific functions.

# Functional Style

use Math::NumberCruncher;

($high, $low) = Math::NumberCruncher::Range(@array);
$mean = Math::NumberCruncher::Mean(@array);
$median = Math::NumberCruncher::Median(@array [, $decimal_places]);
$odd_median = Math::NumberCruncher::OddMedian(@array);
$mode = Math::NumberCruncher::Mode(@array);
$covariance = Math::NumberCruncher::Covariance(@array1, @array2);
$correlation = Math::NumberCruncher::Correlation(@array1, @array2);
($slope, $y_intercept) = Math::NumberCruncher::BestFit(@array1, @array2 [, $decimal_places]);
$distance = Math::NumberCruncher::Distance($x1,$y1,$z1,$x2,$y2,$z2 [, $decimal_places]);
$distance = Math::NumberCruncher::Distance($x1,$y1,$x1,$x2 [, $decimal_places]);
$distance = Math::NumberCruncher::ManhattanDistance($x1,$y1,$x2,$y2);
$probAll = Math::NumberCruncher::AllOf(0.3,0.25,0.91,0.002);
$probNone = Math::NumberCruncher::NoneOf(0.4,0.5772,0.212);
$probSome = Math::NumberCruncher::SomeOf(0.11,0.56,0.3275);
$factorial = Math::NumberCruncher::Factorial($some_number);
$permutations = Math::NumberCruncher::Permutation($n);
$permutations = Math::NumberCruncher::Permutation($n,$k);
$roll = Math::NumberCruncher::Dice(3,12,4);
$randInt = Math::NumberCruncher::RandInt(10,50);
$randomElement = Math::NumberCruncher::RandomElement(@array);
Math::NumberCruncher::ShuffleArray(@array);
@unique = Math::NumberCruncher::Unique(@array);
@a_only = Math::NumberCruncher::Compare(@a,@b);
@union = Math::NumberCruncher::Union(@a,@b);
@intersection = Math::NumberCruncher::Intersection(@a,@b);
@difference = Math::NumberCruncher::Difference(@a,@b);
$gaussianRand = Math::NumberCruncher::GaussianRand();
$ways = Math::NumberCruncher::Choose($n,$k);
$binomial = Math::NumberCruncher::Binomial($attempts,$successes,$probability);
$gaussianDist = Math::NumberCruncher::GaussianDist($x,$mean,$variance);
$StdDev = Math::NumberCruncher::StandardDeviation(@array [, $decimal_places]);
$variance = Math::NumberCruncher::Variance(@array [, $decimal_places]);
@scores = Math::NumberCruncher::StandardScores(@array [, $decimal_places]);
$confidence = Math::NumberCruncher::SignSignificance($trials,$hits,$probability);
$e = Math::Numbercruncher::EMC2( "m512", "miles" [, $decimal_places] );
$m = Math::NumberCruncher::EMC2( "e987432" "km" [, $decimal_places] );
$force = Math::NumberCruncher::FMA( "m12", "a73.5" [, $decimal_places] );
$mass = Math::NumberCruncher::FMA( "a43", "f1324" [, $decimal_places] );
$acceleration = Math::NumberCruncher::FMA( "f53512", "m356" [, $decimal_places] );
$predicted_value = Math::NubmerCruncher::Predict( $slope, $y_intercept, $proposed_x [, $decimal_places] );
$area = Math::NumberCruncher::TriangleHeron( $a, $b, $c [, $decimal_places] );
$area = Math::NumberCruncher::TriangleHeron( 1,3, 5,7, 8,2 [, $decimal_places] );
$perimeter = Math::NumberCruncher::PolygonPerimeter( $x0,$y0, $x1,$y1, $x2,$y2, ... [, p$decimal_places]);
$direction = Math::NumberCruncher::Clockwise( $x0,$y0, $x1,$y1, $x2,$y2 );
$collision = Math::NumberCruncher::InPolygon( $x, $y, @xy );
@points = Math::NumberCruncher::BoundingBox_Points( $d, @p );
$in_triangle = Math::NumberCruncher::InTriangle( $x,$y, $x0,$y0, $x1,$y1, $x2,$y2 );
$area = Math::NumberCruncher::PolygonArea( 0, 1, 1, 0, 2, 0, 3, 2, 2, 3 [, p$decimal_places] );
$area = Math::NumberCruncher::CircleArea( $diameter [, $decimal_places] );
$circumference = Math::NumberCruncher::Circumference( $diameter [, $decimal_places] );
$volume = Math::NumberCruncher::SphereVolume( $radius [, $decimal_places] );
$surface_area = Math::NumberCruncher::SphereSurface( $radius [, $decimal_places] );
$years = Math::NumberCruncher::RuleOf72( $interest_rate [, $decimal_places] );
$volume = Math::NumberCruncher::CylinderVolume( $radius, $height [, $decimal_places] );
$volume = Math::NumberCruncher::ConeVolume( $lowerBaseArea, $height [, $decimal_places] );
$radians = Math::NumberCruncher::deg2rad( $degrees [, $decimal_places] );
$degrees = Math::NumberCruncher::rad2deg( $radians [, $decimal_places] );
$Fahrenheit = Math::NumberCruncher::C2F( $Celsius [, $decimal_places] );
$Celsius = Math::NumberCruncher::F2C( $Fahrenheit [, $decimal_places] );
$cm = Math::NumberCruncher::in2cm( $inches [, $decimal_places] );
$inches = Math::NumberCruncher::cm2in( $cm [, $decimal_places] );
$ft = Math::NumberCruncher::m2ft( $m [, $decimal_places] );
$m = Math::NumberCruncher::ft2m( $ft [, $decimal_places] );
$miles = Math::NumberCruncher::km2miles( $km [, $decimal_places] );
$km = Math::NumberCruncher::miles2km( $miles [, $decimal_places] );
$lb = Math::NumberCruncher::kg2lb( $kg [, $decimal_places] );
$kg = Math::NumberCruncher::lb2kg( $lb [, $decimal_places] );
$RelativeStride = Math::NumberCruncher::RelativeStride( $stride_length, $leg_length [, $decimal_places] );
$RelativeStride = Math::NumberCruncher::RelativeStride_2( $DimensionlessSpeed [, $decimal_places] );
$DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed( $RelativeStride [, $decimal_places] );
$DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed_2( $ActualSpeed, $leg_length [, $decimal_places]);
$ActualSpeed = Math::NumberCruncher::ActualSpeed( $leg_length, $DimensionlessSpeed [, $decimal_places] );
$eccentricity = Math::NumberCruncher::Eccentricity( $half_major_axis, $half_minor_axis [, $decimal_places] );
$LatusRectum = Math::NumberCruncher::LatusRectum( $half_major_axis, $half_minor_axis [, $decimal_places] );
$EllipseArea = Math::NumberCruncher::EllipseArea( $half_major_axis, $half_minor_axis [, $decimal_places] );
$OrbitalVelocity = Math::NumberCruncher::OrbitalVelocity( $r, $a, $M [, $decimal_places] );
$sine = Math::NumberCruncher::sin( $x [, $decimal_places] );
$cosine = Math::NumberCruncher::cos( $x [, $decimal_places] );
$tangent = Math::NumberCruncher::tan( $x [, $decimal_places] );
$arcsin = Math::NumberCruncher::asin( $x [, $decimal_places] );
$arccos = Math::NumberCruncher::acos( $x [, $decimal_places] );
$arctan = Math::NumberCruncher::atan( $x [, $decimal_places] );
$cotangent = Math::NumberCruncher::cot( $x [, $decimal_places] );
$arccot = Math::NumberCruncher::acot( $x [, $decimal_places] );
$secant = Math::NumberCruncher::sec( $x [, $decimal_places] );
$arcsec = Math::NumberCruncher::asec( $x [, $decimal_places] );
$cosecant = Math::NumberCruncher::csc( $x [, $decimal_places] );
$arccosecant = Math::NumberCruncher::acsc( $x [, $decimal_places] );
$exsecant = Math::NumberCruncher::exsec( $x [, $decimal_places] );
$versine = Math::NumberCruncher::vers( $x [, $decimal_places] );
$coversine = Math::NumberCruncher::covers( $x [, $decimal_places] );
$haversine = Math::NumberCruncher::hav( $x [, $decimal_places] );
$grouped = Math::NumberCruncher::Commas( $number );
$SqrRoot = Math::NumberCruncher::SqrRoot( $number [, $decimal_places] );
$square_root = Math::NumberCruncher::sqrt( $x [, $decimal_places] );
$root = Math::NumberCruncher::Root( 55, 3 [, $decimal_places] );
$root = Math::NumberCruncher::Root2( 55, 3 [, $decimal_places] );
$log = Math::NumberCruncher::Ln( 100 [, $decimal_places] );
$log = Math::NumberCruncher::log( $num [, $decimal_places] );
$num = Math::NumberCruncher::Exp( 0.111 [, $decimal_places] );
$num = Math::NumberCruncher::exp( $log [, $decimal_places] );
$Pi = Math::NumberCruncher::PICONST( $decimal_places );
$E = Math::NumberCruncher::ECONST( $decimal_places );
( $A, $B, $C ) = Math::NumberCruncher::PythagTriples( $x, $y [, $decimal_places] );
$z = Math::NumberCruncher::PythagTriplesSeq( $x, $y [, $decimal_places] );
@nums = Math::NumberCruncher::SIS( [$start, $numbers, $increment] );
$inverse = Math::NumberCruncher::Inverse( $number [, $decimal_places] );
@constants = Math::NumberCruncher::CONSTANTS( all [, $decimal_places] );
$bernoulli = Math::NumberCruncher::Bernoulli( $num [, $decimal_places] );
@bernoulli = Math::NumberCruncher::Bernoulli( $num );

GDS2 is a module for quickly creating programs to read and/or write GDS2 files.

Create Method

new - open gds2 file

usage:
my $gds2File = new GDS2(-fileName => "filename.gds2"); ## to read
my $gds2File2 = new GDS2(-fileName => ">filename.gds2"); ## to write

fileNum - file number...

usage:

close - close gds2 file

usage:

$gds2File -> close;
-or-
$gds2File -> close(-markEnd=>1); ## experimental -- some systems have trouble closing files
$gds2File -> close(-pad=>2048); ## experimental -- pad end with s till file size is a
## multiple of number. Note: old reel to reel tapes on Calma
## systems used 2048 byte blocks

High Level Write Methods

printInitLib() - Does all the things needed to start a library, writes HEADER,BGNLIB,LIBNAME,and UNITS records

The default is to create a library with a default unit of 1 micron that has a resolution of 1000. To get this set uUnit to 0.001 (1/1000) and the dbUnit to 1/1000th of a micron (1e-9). usage: $gds2File -> printInitLib(-name => "testlib", ## required -isoDate => 0|1 ## (optional) use ISO 4 digit date 2001 vs 101 -uUnit => real number ## (optional) default is 0.001 -dbUnit => real number ## (optional) default is 1e-9 );

## defaults to current date for library date

note:

remember to close library with printEndlib()
printBgnstr - Does all the things needed to start a structure definition

usage:

$gds2File -> printBgnstr(-name => "nand3" ## writes BGNSTR and STRNAME records
-isoDate => 1|0 ## (optional) use ISO 4 digit date 2001 vs 101
);

note:

remember to close with printEndstr()

printPath - prints a gds2 path
usage:
$gds2File -> printPath(
-layer=>#,
-dataType=>#, ##optional
-pathType=>#,
-width=>#.#,
-unitWidth=>#, ## (optional) directly specify width in data base units (vs -width which is multipled by resolution)
-xy=>@array, ## array of reals
-xyInt=>@array, ## array of internal ints (optional -wks better if you are modifying an existing GDS2 file)
);

note:
layer defaults to 0 if -layer not used
pathType defaults to 0 if -pathType not used
pathType 0 = square end
1 = round end
2 = square - extended 1/2 width
4 = custom plus variable path extension...
width defaults to 0.0 if -width not used
printBoundary - prints a gds2 boundary
usage:
$gds2File -> printBoundary(
-layer=>#,
-dataType=>#,
-xy=>@array, ## array of reals
-xyInt=>@array, ## array of internal ints (optional -wks better if you are modifying an existing GDS2 file)
);

note:
layer defaults to 0 if -layer not used
dataType defaults to 0 if -dataType not used
printSref - prints a gds2 Structure REFerence
usage:
$gds2File -> printSref(
-name=>string, ## Name of structure
-xy=>@array, ## array of reals
-xyInt=>@array, ## array of internal ints (optional -wks better than -xy if you are modifying an existing GDS2 file)
-angle=>#.#, ## (optional) Default is 0.0
-mag=>#.#, ## (optional) Default is 1.0
-reflect=>0|1 ## (optional)
);

note:
best not to specify angle or mag if not needed
printAref - prints a gds2 Array REFerence
usage:
$gds2File -> printAref(
-name=>string, ## Name of structure
-columns=>#, ## Default is 1
-rows=>#, ## Default is 1
-xy=>@array, ## array of reals
-xyInt=>@array, ## array of internal ints (optional -wks better if you are modifying an existing GDS2 file)
-angle=>#.#, ## (optional) Default is 0.0
-mag=>#.#, ## (optional) Default is 1.0
-reflect=>0|1 ## (optional)
);

note:
best not to specify angle or mag if not needed
printText - prints a gds2 Text
usage:
$gds2File -> printText(
-string=>string,
-layer=>#, ## Default is 0
-textType=>#, ## Default is 0
-font=>#, ## 0-3
-top, or -middle, -bottom, ##optional vertical presentation
-left, or -center, or -right, ##optional horizontal presentation
-xy=>@array, ## array of reals
-xyInt=>@array, ## array of internal ints (optional -wks better if you are modifying an existing GDS2 file)
-x=>#.#, ## optional way of passing in x value
-y=>#.#, ## optional way of passing in y value
-angle=>#.#, ## (optional) Default is 0.0
-mag=>#.#, ## (optional) Default is 1.0
-reflect=>#, ## (optional) Default is 0
);

note:

best not to specify reflect, angle or mag if not needed

The concept is similar to an internet browser. But it is intended for the use in industrial process visualization.
It is based on Qt http://www.trolltech.com which is a platform independent GUI toolkit. ProcessViewBrowser is platform independent, because only posix calls and Qt are used. ProcessViewBrowser runs on Linux/Unix, OpenVMS and Windows.
The browser can display nearly all standard Qt widgets (labels, buttons, editfields, comboboxes, ...) and other widgets for bmp images, diagram widgets for displaying xy-graphs, OpenGL and VTK.
The widgets can be arranged on your masks. You can specify the position and size of the widgets.You can place one widget on top of another widget. I have seen many process visualization systems, which define their masks in the clients (I think this is not the right way to go).
Instead of this, the masks in ProcessViewBrowser are defined in the appropriate process computer itself. The user can jump from one process computer to the other and see all masks. When masks are updated nothing has to be done in the clients.
Main features:
- Client/Server
- Qt Widgets
- Custom Widgets
- platform independent
- 3D Graphics
- pvbuilder
- Design by Qt Designer
- C/C++, Python, Perl, PHP, Tcl
- Multithreaded or Inetd
- Unicode support (Chinese, Arabic, Cyrillic, ...)
- Support for ssh-urls
- Connections to Fieldbuses
- Connections to PLCs
- Manage background processes
- Central event log
- GPL License

Clichart is an application intended for quick summarization and visualization of data, especially from system logs. It provides tools to extract and manipulate tabular summary data from text files, and to generate and view simple charts from tabular data on the command line
Main features:
- Display charts in a window, save them to disk (JPEG or PNG), or both
- Accept data in comma- or whitespace-separated formats
- Read data from a file, or have it piped into its standard input
- Display XY line charts, with the X axis based on dates, times or values. The Y axis must be simple values (integer or decimal)
- Be used interactively, or driven via scripts
- Generate summary data based on counts, averages, minimum, maximum of input fields
- Generate summary data based on discrete values
- Generate aggregates from tabular data
- Operate in CLI server mode, generating 1 or more charts based on commands passed via standard in (either from another script, or from a command file).
Enhancements:
- This release is mostly a tidy-up, with small bugfixes and improvements in handling errors.
- However, it also allows output from "aggregate" to include simple expressions, adds the ability for "cliserverlib" to locate "clichart" via the PATH (useful for Windows users), and uses the Psyco JIT compiler to speed operation if its installed.

Chart::XMGR is a Perl object for displaying data via XMGR.

SYNOPSIS

use Chart::XMGR;

xmgr($a, { SYMBOL => plus};

use Chart::XMGR ();

$xmgr = new Chart::XMGR;
$xmgr->line($pdl);

$pdl->$xmgr->line;

xmgr($pdl, { LINESTYLE => dotted });

Provides a perl/PDL interface to the XMGR plotting package. Can be used to plot PDLs or Perl arrays.

A simple function interface is provided that is based on the more complete object-oriented interface.

The interface can be implemented using either anonymous pipes or named pipes (governed by the module variable Chart::XMGR::NPIPE). If named pipes are used ($NPIPE = 1) XMGR can be controlled via the pipe and buttons are available for use in XMGR. If an anonymous pipe is used XMGR will not accept button events until the pipe has been closed.

Currently the named pipe option can not support data sets containing 3 or more columns (I havent worked out how to do it anyway!). This means that only TYPE XY is supported. For anonymouse pipe 3 or more columns can be supplied along with the graph type.

The default option is to use the named pipe.