me8100: comparison me8100_test

equal deleted inserted replaced

-:33280ad0f4b2
+:e0b741bb5ce0
 my %Objects = ();
 my $gotSignal = 0;
 my $opt_async = 0;
-sub iohandler($);
+sub _iohandler($);
 sub import { $opt_async = grep { /^:async/ } @_; }
 # Install the signal handler only if we have passed the ':async' tag
 # to the module...
-INIT { $SIG{IO} = \&iohandler if $opt_async; }
+INIT { $SIG{IO} = \&_iohandler if $opt_async; }
 # Create a new object. Open all the named devices (read only)
 # and read the current values (as the driver guarantees the
 # very first read to succeed).
 # The order depends on the order the device names are passed
 $self->{fds} = [@fds];	    # list of fds
 $self->{select} = new IO::Select(@fds);
 $self->{bits} = $idx * 16;
 $self->{inputBits} = $inputBits;
-$self->{oldBits} = "";
+$self->{oldBits} = undef;
 $self->{changedBits} = "";
 $self->{changed} = [split //, "0" x $self->{bits} ];
 return $self;
 }
 # race condition might occur: while we're waiting for the select()
 # to complete, the SIGIO might be catched.  Both, SIGIO as well as
 # the suddenly succeeding select() indicate a possible successful
 # read... But only one of them will be successful!
-my ($self, $timeout) = @_;
+my ($self, %args) = @_;
 {
 	local $SIG{IO} = sub { $gotSignal = $_[0] } if $opt_async;
-	my @ready = $self->{select}->can_read($timeout);
+	my @ready = $self->{select}->can_read($args{timeout});
 	if (!@ready) {
 	    warn "select() returned nothing: $!\n";
 	    return undef;
 	}
 	$self->_read(@ready);
 }
-$gotSignal and iohandler($gotSignal);
+$gotSignal and _iohandler($gotSignal);
-$self->{changedBits} = "";
-$self->{changed} = [ split //, "0" x $self->{bits} ];
 return split //, unpack("b*", $self->{inputBits});
 }
 sub status {
 my $self = shift;
 return split //, unpack("b*", $self->{inputBits});
 }
 # Read *really* from the board and store the result at the proper
 # element of our @inputs array.
-sub _read {
+sub _read($@) {
 my ($self, @fds) = @_;
 my $val;	# bit0-7 bit8-15
 foreach my $fd (@fds) {
 	my $idx = $self->{idx}->{$fd};
 }
 # Now get the difference between the old bits and the current values...
 # and then add these values to the array containing the change counters
+$self->{oldBits} = $self->{inputBits} if not defined $self->{oldBits};
 my $changedBits = $self->{inputBits} ^ $self->{oldBits};
 my @changed = split //, unpack("b*", $changedBits);
 #print STDERR "o: ", unpack("b*", $self->{oldBits}), "\n";
 #print STDERR "n: ", unpack("b*", $self->{inputBits}), "\n";
 $self->{changedBits} |= $changedBits;
 $self->{oldBits} = $self->{inputBits};
 }
-sub iohandler($) {
+sub _iohandler($) {
 # If an interrupt occurs, we've to search for the file descriptor(s)
 # that caused the interrupt.  This is done by a lookup in the module global
 # %Objects hash.  ("fd" -> { fd => XXX, object => XXXX })
 my $signal = shift;
 # I do some magic(?) here, since the key isn't usable a a refence
 # anymore, we stored the reference itself behind the key, as well
 # as the object reference...
-# Now a race condition might occur.  It's possible that an other
-# select() runs too (called in the read() method).
 my $select = new IO::Select(map { $Objects{$_}->{fd} } keys %Objects);
 my @ready = $select->can_read(0);
 foreach (@ready) {
 	my $object = $Objects{$_}->{object};
 };
 sub changed {
 my $self = shift;
+my @changed = @{$self->{changed}};
 my $r = 0;
-wantarray and return @{$self->{changed}};
+$self->{changedBits} = "";
-foreach (@{$self->{changed}}) {
+$self->{changed} = [ split //, "0" x $self->{bits} ];
+wantarray and return @changed;
+foreach (@changed) {
 	$r += $_;
 }
 return $r;
 }
-sub DESTROY
+#sub DESTROY
-{
+#{
-my $self = shift;
+#    my $self = shift;
-delete @Objects{ @{$self->{fds}} };
+#    delete @Objects{ @{$self->{fds} }};
-}
+#}
 #-- Documenation follows
 =head1 NAME
 =item new(I<device>,...)
 Creates a new ME8100 object connected to all the listed devices.
-=item read([I<timeout>])
+=item read(I<[timeout =E<gt> timeout]>)
 Read the input from the devices.  This call is guaranteed to succeede
 on the first run, but every following call will block until the status
 of the input changed.  (This behaviour is due to the driver.)
 A timeout may be passed.
-Every read() resets the register for obtaining the changed bits.
 On success an array of the input bits is returned, otherwise undef.
 =item status()
 Returns an array with the current status of all input bits.
-Never blocks.
+Never blocks.  No side effects.
 =item changed()
-Returns an array containing the number of detected changes per input
+In array context returns an array containing the counts of changes
-bit.
+for every single bit.  In scalar context returns the total number of
+changes.
-=item iohandler(I<signal>)
+Every call resets the counter.
+=item _iohandler(I<signal>)
 For internal use only.
 =item _read()

changeset 32	e0b741bb5ce0
parent 31	33280ad0f4b2