Bit::Manip - Functions to simplify bit string manipulation
use Bit::Manip qw(:all); my $b; # bit string $b = 128; # 10000000 # toggle a bit off and on $b = bit_tog($b, 4); # 10010000 $b = bit_tog($b, 4); # 10000000 # turn a bit off, then back on $b = bit_off($b, 7); # 0 $b = bit_on($b, 7); # 10000000 # get the value of a range of bits... # in this case, we'll print the value of bits 4-3 $b = 0b00111000; (56) print bit_get($b, 4, 3); # 3 # set a range of bits... # let's set bits 4-2 to binary 101 $b = 0b10000000; my $num_bits = 3; # 0b101 in the call is 3 bits $b = bit_set($b, 2, $num_bits, 0b101); # 10010100 # clear some bits $b = 0b11111111; $num_bits = 3; $lsb = 3; $b = bit_clr($b, $lsb, $num_bits); # 11000111 # helpers my ($num_bits, $lsb) = (3, 2); print bit_mask($num_bits, $lsb); # 28, or 11100 print bit_bin(255); # 11111111 (same as printf("%b", 255);)
Provides functions to aid in bit manipulation (get, set, clear, toggle) etc. Particularly useful for embedded programming and writing device communication software.
Currently, up to 32-bit integers are supported.
Note that if your machine isn't capable of compiling C code, there's a pure Perl version as well, aptly named Bit::Manip::PP.
Use the :all tag (eg: use Bit::Manip qw(:all);) to import the following functions into your namespace, or pick and choose individually:
:all
use Bit::Manip qw(:all);
bit_get bit_set bit_clr bit_tog bit_on bit_off bit_bin bit_count bit_mask
Retrieves the value of specified bits within a bit string.
Parameters:
$data
Mandatory: Integer, the bit string you want to send in. Eg: 255 for 11111111 (or 0xFF).
255
11111111
0xFF
$msb
Mandatory: Integer, the Most Significant Bit (leftmost) of the group of bits to collect the value for (starting from 0 from the right, so with 1000, so you'd send in 3 as the start parameter for the bit set to 1). Must be 1
1000
3
1
$lsb
Optional: Integer, the Least Significant Bit (rightmost) of the group of bits to collect the value for (starting at 0 from the right). A value of 0 means return the value from $msb through to the very end of the bit string. A value of 1 will capture from $msb through to bit 1 (second from right). If $msb is equal to $lsb, we'll return just that bit.
0
Return: Integer, the modified $data param.
Allows you to set a value for specific bits in your bit string.
Mandatory: Integer, the bit string you want to manipulate bits in.
Mandatory: Integer, the least significant bit (rightmost) in the bit range you want to manipulate. For example, if you wanted to set a new value for bits 7-5, you'd send in 5.
7-5
5
$nbits
Mandatory: Integer, the number of bits you're sending in. We need this param in the event your leading bit is a zero. For example, if you're sending in 0b111 or 0b001, this param would be 3.
0b111
0b001
$value
Mandatory: Integer, the value that you want to change the specified bits to. Easiest if you send in a binary string (eg: 0b1011 in Perl).
0b1011
Example:
You have an 8-bit register where the MSB is a start bit, and the rest of the bits are zeroed out:
my $data = 0b10000000; # (0x80, or 128)
The datasheet for the hardware you're writing to requires you to set bits 6-4 to 111 in binary (always start from bit 0, not 1):
6-4
111
10000000 ^^^ ^ 6-4 0
Code:
my $x = bit_set($data, 4, 3, 0b111); # (0x07, or 7) printf("%b\n", $x); # prints 11110000
Clear (unset to 0) specific bits in the bit string.
Mandatory: Integer, the least significant bit (rightmost) in the bit range you want to manipulate. For example, if you wanted to clear bits 7-5, you'd send in 5.
Mandatory: Integer, the number of bits you're wanting to clear, starting from the $lsb bit, and clearing the number of bits to the left.
Returns the modified bit string.
See "bit_tog".
AKA: bit_toggle().
bit_toggle()
Toggles a single bit. If it's 0 it'll toggle to 1 and vice-versa.
Mandatory: Integer, the number/bit string to toggle a bit in.
$bit
Mandatory: Integer, the bit number counting from the right-most (LSB) bit starting from 0.
Sets a single bit (sets to 1), regardless of its current state. This is just a short form of setting a single bit with bit_set.
Unsets a single bit (sets to 0), regardless of its current state. This is just a short form of clearing a single bit with bit_set.
Returns the binary representation of a number as a string of ones and zeroes.
Mandatory: Integer, the number you want to convert.
Returns either the total count of bits in a number, or just the number of set bits (if the $set, parameter is sent in and is true).
$set
$num
Mandatory: Unsigned integer, the number to retrieve the total number of bits for. For example, if you send in 15, the total number of bits would be 4, likewise, for 255, the number of bits would be 16.
15
4
16
Optional: Integer. If this is sent and is a true value, we'll return the number of *set* bits only. For example, for 255, the set bits will be 8 (ie. all of them), and for 8, the return will be 1 (as only the MSB is set out of all four of the total).
8
Return: Integer, the number of bits that make up the number if $set is 0, and the number of set bits (1's) if $set is true.
Generates a bit mask for the specific bits you specify.
Mandatory: Integer, the number of bits to get the mask for.
Mandatory: Integer, the LSB at which you plan on implementing your change.
Return: Integer, the bit mask ready to be applied.
Steve Bertrand, <steveb at cpan.org>
<steveb at cpan.org>
Copyright 2017 Steve Bertrand.
This program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as published by the Free Software Foundation; or the Artistic License.
See http://dev.perl.org/licenses/ for more information.
To install Bit::Manip, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Bit::Manip
CPAN shell
perl -MCPAN -e shell install Bit::Manip
For more information on module installation, please visit the detailed CPAN module installation guide.