Free what is an output device software for linux

Hardware::iButton::Device is a Perl object to represent iButtons.

SYNOPSIS

use Hardware::iButton::Connection;
$c = new Hardware::iButton::Connection "/dev/ttyS0";
@b = $c->scan();
foreach $b (@b) {
print "id: ", $b->id(), ", reg0: ",$b->readreg(0),"n";
}

This module talks to iButtons via the "active" serial interface (anything using the DS2480, including the DS1411k and the DS 9097U). It builds up a list of devices available, lets you read and write their registers, etc.

The connection object is an Hardware::iButton::Connection. The main user-visible purpose of it is to provide a list of Hardware::iButton::Device objects. These can be subclassed once their family codes are known to provide specialized methods unique to the capabilities of that device. Those devices will then be Hardware::iButton::Device::DS1920, etc.

Audio Input-Output Library (libaio) is meant to solve the problem of differing digital audio platforms once and for all.

JACK is unnecessarily complex for most applications, and while libaos support for file output is cool, it limits what the API can do and is therefore inadequate for any kind of real time application.

libaio provides a clean application interface and a simple compile-time driver switching decision, yielding a lightweight way to use the local sound hardware without having to care what it is.

Libaios first sparkle was when I, Hod McWuff (alias, of course), found myself trying to debug ALSA implementations for libao and madplay, and another audio-related project Id been working on. That project needed multiplatform audio support of its own, with latency management, which libao lacked.

It also seemed that libao shouldnt have been trying to be both a hardware abstraction *AND* an output abstraction, and also that it seemed more intuitive as an output (live vs file) abstraction.

Enter libaio. All it does is abstract the local sound hardware platform, to present a clean, uniform interface to playing and capturing digital audio, with facilities for basic latency management. It was written from scratch around its developing ALSA driver, from many many reference sources including libao and Robert Leslies excellent madplay MP3 decoder, and of course the ALSA documentation and examples.

Libaios distinction comes from its build-time decisionmaking. It only compiles and links the best driver available for the given platform. Therefore, selecting and loading a driver no longer applies; and well it shouldnt, theres never more than one correct choice anyway.

Libaio is not intended to replace libao; rather it is intended to supplement it. The key argument is, why would anyone EVER have more than one running sound platform type on any single machine? Sure, they might have ESD or ARTS, but they more resemble file output than a live device. Theres also the OSS emulation in ALSA, but given a good ALSA driver, whod use OSS?

Then theres the fact that applications have to tell libao what "plugin" to use, and all the drivers in libao have different parameters. That means the application has to know more than it should about what it shouldnt have to see. The app shouldnt have to say more than "give me the local device for playback with *** format" or something to that effect, and start writing.

Finally, plugins for stuff like proprietary file formats, ESD et al, but there shouldnt be any need for more than one of (ALSA|OSS|SUN|WIN32|MACOSX ) on any given distribution. Therefore, binary distribution of a compiled-in driver is possible, even preferred.

It is proposed that all of the hardware drivers in libao, and madplay, and several other places, be reviewed and ported to libaio. Then, they can be removed from those packages in favor of an AIO interface.

Installation:

## building
./configure
make


## installing (as root)
make install

XML::Output is a Perl module for writing simple XML documents.

SYNOPSIS

use XML::Output;

open(FH,>file.xml);
my $xo = new XML::Output({fh => *FH});
$xo->open(tagname, {attrname => attrval});
$xo->pcdata(element content);
$xo->close();
close(FH);

ABSTRACT

XML::Output is a Perl module for writing simple XML documents

XML::Output is a Perl module for writing simple XML document. The following methods are provided.

new
$xo = new XML::Output;
Constructs a new XML::Output object.

open
$xo->open(tagname, {attrname => attrval});
Open an element with specified name (and optional attributes)

close
$xo->close;
Close an element

empty
$xo->empty(tagname, {attrname => attrval});
Insert an empty element with specified name (and optional attributes)

pcdata
$xo->pcdata(element content);
Insert text

comment
$xo->comment(comment text);
Insert a comment

xmlstr
print $xo->xmlstr;
Get a string representation of the constructed document

ChatSniff is an easy to use program for Linux that monitors, or "sniffs" networks for AIM, MSN, Yahoo! and Jabber instant messages.
It requires recent versions of python, python-gtk2, python-glade2, and tethereal.
python-pyao (for sound) and gksu are optional, but recommended (the packages require them).
Enhancements:
- Moved to single instance of tethereal
- Removed "any" device from device list
- First time case for net dev selection
- Major HIG/UI adjustments (brad)
- Moved to a single pane view
- Added status bar
- Added auto-start
- Added toolbar
- Major code cleanup
- Packet output cleanup
- Better error dialog formating
- Added versioning to preferences
- Start/stop timestamps
- Help dialog now reflects reality
- No more ugly empty space above first packet
- Sundry minor tweaks

Device::Gsm is a Perl extension to interface GSM phones / modems.

SYNOPSIS

use Device::Gsm;

my $gsm = new Device::Gsm( port => /dev/ttyS1, pin => xxxx );

if( $gsm->connect() ) {
print "connected!n";
} else {
print "sorry, no connection with gsm phone on serial port!n";
}

# Register to GSM network (you must supply PIN number in above new() call)
$gsm->register();

# Send quickly a short text message
$gsm->send_sms(
recipient => +3934910203040,
content => Hello world! from Device::Gsm
);

# Get list of Device::Gsm::Sms message objects
# see `examples/read_messages.pl for all the details
my @messages = $gsm->messages();

Device::Gsm class implements basic GSM functions, network registration and SMS sending.

This class supports also PDU mode to send SMS messages, and should be fairly usable. In the past, I have developed and tested it under Linux RedHat 7.1 with a 16550 serial port and Siemens C35i/C45 GSM phones attached with a Siemens-compatible serial cable. Currently, Im developing and testing this stuff with Linux Slackware 10.2 and a Cambridge Silicon Radio (CSR) USB bluetooth dongle, connecting to a Nokia 6600 phone.

Please be kind to the universe and contact me if you have troubles or you are interested in this.

Please be monstruosly kind to the universe and (if you dont mind spending an SMS) use the examples/send_to_cosimo.pl script to make me know that Device::Gsm works with your device (thanks!).

Recent versions of Device::Gsm have also an utility called autoscan in the bin/ folder, that creates a little profile of the devices it runs against, that contains information about supported commands and exact output of commands to help recognize similar devices.

Be sure to send me your profile by email (if you want to), so I can add better support for your device in the future!

Device::TNC is a Perl module that acts like a generic interface to a TNC.

This module implements a generic interface to a Terminal Node Controller (TNC).

It loads sub classes that provide the low level interface for the appropriate TNC to be used and provides higher level methods to return frames of data to the user is human readable form.

SYNOPSIS

use Device::TNC;
my $tnc_type = KISS;
my %tnc_config = (
port => ($Config{osname} eq "MSWin32") ? "COM3" : "/dev/TNC-X",
baudrate => 9600,
warn_malformed_kiss => 1,
raw_log => "raw_packet.log",
);
my $tnc = new Device::TNC($tnc_type, %tnc_config);
die "Error: Something went wrong connecting to the TNC.n" unless $tnc;

while (1)
{
my $data = $tnc->read_frame();
my $repeaters = join ", ", @{$data->{ADDRESS}->{REPEATERS}};
my $info = join "", @{$data->{INFO}};
print "From: $data->{ADDRESS}->{SOURCE} ";
print "To: $data->{ADDRESS}->{DESTINATION} ";
print "via $repeatersn";
print "Data: $infon";
}
new()
my $type = "KISS";
my %tnc_data = { option => value };
my $tnc = new Device::TNC($type, %tnc_data);

The new method creates and returns a new Device::TNC object that can be used to communicate with a Terminal Node Controller (TNC) of the type passed.

The method requires that the first passed argument be the type of TNC to connect to. This will try and load the appropriate module for the TNC type.
The subsequent options are passed to the module that is loaded to connect to the desired TNC.

For more details on these options see the module documentation for the TNC type.

read_frame()
my $frame_data = $tnc->read_frame();
my %frame_data = $tnc->read_frame();

This method reads a HDLC frame from the TNC and returns a structure as either a hash or a hash reference that contains the fields of the frame.

The structure of the returned data is like the following.

{
INFO => [
/, 0, 6, 4, 6, 5, 8, h, 3, 3, 5, 0, ., 0, 0,
S, \, 1, 5, 1, 1, 2, ., 0, 0, E, O, 2, 2, 6,
/, 0, 0, 0, /, A, =, 0, 0, 0, 1, 1, 1
],
PID => F0,
CONTROL => {
POLL_FINAL => 0,
FIELD_TYPE => UI,
FRAME_TYPE => U
},
ADDRESS => {
DESTINATION => APT311,
REPEATERS => [
WIDE1-1,
WIDE2-2
],
SOURCE => VK2KFJ-7
}
}

While developing this module I only received U (UI) type frames and so development of the code to work with I and S frames didnt really progress. If anyone wants to read I or S frames please let me know and Ill have a look at implementing them. Please create a KISS log of the data and email it to me.

Device::Modem is a Perl extension created to talk to modem devices connected via serial port.

WARNING

This is BETA software, so use it at your own risk, and without ANY warranty! Have fun.

SYNOPSIS

use Device::Modem;

my $modem = new Device::Modem( port => /dev/ttyS1 );

if( $modem->connect( baudrate => 9600 ) ) {
print "connected!n";
} else {
print "sorry, no connection with serial port!n";
}

$modem->attention(); # send `attention sequence (+++)

($ok, $answer) = $modem->dial(02270469012); # dial phone number
$ok = $modem->dial(3); # 1-digit parameter = dial number stored in memory 3

$modem->echo(1); # enable local echo (0 to disable)

$modem->offhook(); # Take off hook (ready to dial)
$modem->hangup(); # returns modem answer

$modem->is_active(); # Tests whether modem device is active or not
# So far it works for modem OFF/ modem ON condition

$modem->reset(); # hangup + attention + restore setting 0 (Z0)

$modem->restore_factory_settings(); # Handle with care!
$modem->restore_factory_settings(1); # Same with preset profile 1 (can be 0 or 1)

$modem->send_init_string(); # Send initialization string
# Now this is fixed to AT H0 Z S7=45 S0=0 Q0 V1 E0 &C0 X4

# Get/Set value of S1 register
my $S1 = $modem->S_register(1);
my $S1 = $modem->S_register(1, 55); # Dont do that if you definitely dont know!

# Get status of managed signals (CTS, DSR, RLSD, RING)
my %signal = $modem->status();
if( $signal{DSR} ) { print "Data Set Ready signal active!n"; }

# Stores this number in modem memory number 3
$modem->store_number(3, 01005552817);

$modem->repeat(); # Repeat last command

$modem->verbose(1); # Normal text responses (0=numeric codes)

# Some raw AT commands
$modem->atsend( ATH0 );
print $modem->answer();

$modem->atsend( ATDT01234567 . Device::Modem::CR );
print $modem->answer();

Device::Modem class implements basic AT (Hayes) compliant device abstraction. It can be inherited by sub classes (as Device::Gsm), which are based on serial connections.