Free 32 bit windows 7 software for linux

MCP2510 Bit Timing Calculator project is a bit timing calculator for the MCP2510.

It is a bit timing calculator which is very easy to use.

All you have to do is to choose the baudrate and the oscilator-frequency.

Sure you can edit and change all setting. You will see a graphical bit timing diagram which show you your current options.

At the end you will get a detailed report of your choosen options. See an example here: mcp2510btn

HowTo

On the first step you have to choose your wished baudrate and the oscilator-frequency.

Second you will get a great table with all avaible baudrate for you oscilator-frequency. The are already choosen some baudrates if your baudrate equals with some on the table. Otherwise you have to select them manually, but you will get deviations to you choosen baudrate. You will the the deviation in percent at the right table.

When you are ready you can go forward to step three.
Here you have first to select your wanted Nominal Bit Time Screenshot 2 [Step 3]and then you can edit/change to values for the single segments of a bit timing.

Bit::Vector is an efficient bit vector, set of integers and "big int" math library.

CLASS METHODS

Version

$version = Bit::Vector->Version();

Word_Bits
$bits = Bit::Vector->Word_Bits(); # bits in a machine word

Long_Bits
$bits = Bit::Vector->Long_Bits(); # bits in an unsigned long

new
$vector = Bit::Vector->new($bits); # bit vector constructor

@veclist = Bit::Vector->new($bits,$count);

new_Hex
$vector = Bit::Vector->new_Hex($bits,$string);

new_Bin
$vector = Bit::Vector->new_Bin($bits,$string);

new_Dec
$vector = Bit::Vector->new_Dec($bits,$string);

new_Enum
$vector = Bit::Vector->new_Enum($bits,$string);

Concat_List
$vector = Bit::Vector->Concat_List(@vectors);
OBJECT METHODS
new
$vec2 = $vec1->new($bits); # alternative call of constructor

@veclist = $vec->new($bits,$count);

Shadow
$vec2 = $vec1->Shadow(); # new vector, same size but empty

Clone
$vec2 = $vec1->Clone(); # new vector, exact duplicate

Concat
$vector = $vec1->Concat($vec2);

Concat_List
$vector = $vec1->Concat_List($vec2,$vec3,...);

Size
$bits = $vector->Size();

Resize
$vector->Resize($bits);
$vector->Resize($vector->Size()+5);
$vector->Resize($vector->Size()-5);

Copy
$vec2->Copy($vec1);

Empty
$vector->Empty();

Fill
$vector->Fill();

Flip
$vector->Flip();

Primes
$vector->Primes(); # Sieve of Erathostenes

Reverse
$vec2->Reverse($vec1);

Interval_Empty
$vector->Interval_Empty($min,$max);

Interval_Fill
$vector->Interval_Fill($min,$max);

Interval_Flip
$vector->Interval_Flip($min,$max);

Interval_Reverse
$vector->Interval_Reverse($min,$max);

Interval_Scan_inc
if (($min,$max) = $vector->Interval_Scan_inc($start))

Interval_Scan_dec
if (($min,$max) = $vector->Interval_Scan_dec($start))

Interval_Copy
$vec2->Interval_Copy($vec1,$offset2,$offset1,$length);

Interval_Substitute
$vec2->Interval_Substitute($vec1,$off2,$len2,$off1,$len1);

is_empty
if ($vector->is_empty())

is_full
if ($vector->is_full())

equal
if ($vec1->equal($vec2))

Lexicompare (unsigned)
if ($vec1->Lexicompare($vec2) == 0)
if ($vec1->Lexicompare($vec2) != 0)
if ($vec1->Lexicompare($vec2) < 0)
if ($vec1->Lexicompare($vec2) Lexicompare($vec2) > 0)
if ($vec1->Lexicompare($vec2) >= 0)

Compare (signed)
if ($vec1->Compare($vec2) == 0)
if ($vec1->Compare($vec2) != 0)
if ($vec1->Compare($vec2) < 0)
if ($vec1->Compare($vec2) Compare($vec2) > 0)
if ($vec1->Compare($vec2) >= 0)

to_Hex
$string = $vector->to_Hex();

from_Hex
$vector->from_Hex($string);

to_Bin
$string = $vector->to_Bin();

from_Bin
$vector->from_Bin($string);

to_Dec
$string = $vector->to_Dec();

from_Dec
$vector->from_Dec($string);

to_Enum
$string = $vector->to_Enum(); # e.g. "2,3,5-7,11,13-19"

from_Enum
$vector->from_Enum($string);

Bit_Off
$vector->Bit_Off($index);

Bit_On
$vector->Bit_On($index);

bit_flip
$bit = $vector->bit_flip($index);

bit_test
contains
$bit = $vector->bit_test($index);
$bit = $vector->contains($index);
if ($vector->bit_test($index))
if ($vector->contains($index))

Bit_Copy
$vector->Bit_Copy($index,$bit);

LSB (least significant bit)
$vector->LSB($bit);

MSB (most significant bit)
$vector->MSB($bit);

lsb (least significant bit)
$bit = $vector->lsb();

msb (most significant bit)
$bit = $vector->msb();

rotate_left
$carry = $vector->rotate_left();

rotate_right
$carry = $vector->rotate_right();

shift_left
$carry = $vector->shift_left($carry);

shift_right
$carry = $vector->shift_right($carry);

Move_Left
$vector->Move_Left($bits); # shift left "$bits" positions

Move_Right
$vector->Move_Right($bits); # shift right "$bits" positions

Insert
$vector->Insert($offset,$bits);

Delete
$vector->Delete($offset,$bits);

increment
$carry = $vector->increment();

decrement
$carry = $vector->decrement();

inc
$overflow = $vec2->inc($vec1);

dec
$overflow = $vec2->dec($vec1);

add
$carry = $vec3->add($vec1,$vec2,$carry);
($carry,$overflow) = $vec3->add($vec1,$vec2,$carry);

subtract
$carry = $vec3->subtract($vec1,$vec2,$carry);
($carry,$overflow) = $vec3->subtract($vec1,$vec2,$carry);

Neg
Negate
$vec2->Neg($vec1);
$vec2->Negate($vec1);

Abs
Absolute
$vec2->Abs($vec1);
$vec2->Absolute($vec1);

Sign
if ($vector->Sign() == 0)
if ($vector->Sign() != 0)
if ($vector->Sign() < 0)
if ($vector->Sign() Sign() > 0)
if ($vector->Sign() >= 0)

Multiply
$vec3->Multiply($vec1,$vec2);

Divide
$quot->Divide($vec1,$vec2,$rest);

GCD (Greatest Common Divisor)
$vecgcd->GCD($veca,$vecb);
$vecgcd->GCD($vecx,$vecy,$veca,$vecb);

Power
$vec3->Power($vec1,$vec2);

Block_Store
$vector->Block_Store($buffer);

Block_Read
$buffer = $vector->Block_Read();

Word_Size
$size = $vector->Word_Size(); # number of words in "$vector"

Word_Store
$vector->Word_Store($offset,$word);

Word_Read
$word = $vector->Word_Read($offset);

Word_List_Store
$vector->Word_List_Store(@words);

Word_List_Read
@words = $vector->Word_List_Read();

Word_Insert
$vector->Word_Insert($offset,$count);

Word_Delete
$vector->Word_Delete($offset,$count);

Chunk_Store
$vector->Chunk_Store($chunksize,$offset,$chunk);

Chunk_Read
$chunk = $vector->Chunk_Read($chunksize,$offset);

Chunk_List_Store
$vector->Chunk_List_Store($chunksize,@chunks);

Chunk_List_Read
@chunks = $vector->Chunk_List_Read($chunksize);

Index_List_Remove
$vector->Index_List_Remove(@indices);

Index_List_Store
$vector->Index_List_Store(@indices);

Index_List_Read
@indices = $vector->Index_List_Read();

Or
Union
$vec3->Or($vec1,$vec2);
$set3->Union($set1,$set2);

And
Intersection
$vec3->And($vec1,$vec2);
$set3->Intersection($set1,$set2);

AndNot
Difference
$vec3->AndNot($vec1,$vec2);
$set3->Difference($set1,$set2);

Xor
ExclusiveOr
$vec3->Xor($vec1,$vec2);
$set3->ExclusiveOr($set1,$set2);

Not
Complement
$vec2->Not($vec1);
$set2->Complement($set1);

subset
if ($set1->subset($set2)) # true if $set1 is subset of $set2

Norm
$norm = $set->Norm();
$norm = $set->Norm2();
$norm = $set->Norm3();

Min
$min = $set->Min();

Max
$max = $set->Max();

Multiplication
$matrix3->Multiplication($rows3,$cols3,
$matrix1,$rows1,$cols1,
$matrix2,$rows2,$cols2);

Product
$matrix3->Product($rows3,$cols3,
$matrix1,$rows1,$cols1,
$matrix2,$rows2,$cols2);

Closure
$matrix->Closure($rows,$cols);

Transpose
$matrix2->Transpose($rows2,$cols2,$matrix1,$rows1,$cols1);

Class::Bits is a Perl module with class wrappers around bit vectors.

SYNOPSIS

package MyClass;
use Class::Bits;

make_bits( a => 4, # 0..15
b => 1, # 0..1
c => 1, # 0..1
d => 2, # 0..3
e => s4 # -8..7
f => s1 # -1..0
);

package;

$o=MyClass->new(a=>12, d=>2);
print "o->b is ", $o->b, "n";

print "bit vector is ", unpack("h*", $$o), "n";

$o2=$o->new();
$o3=MyClass->new($string);

ABSTRACT

Class::Bits creates class wrappers around bit vectors.

Class::Bits defines classes using bit vectors as storage.
Object attributes are stored in bit fields inside the bit vector. Bit field sizes have to be powers of 2 (1, 2, 4, 8, 16 or 32).

There is a class constructor subroutine:

make_bits( field1 => size1, field2 => size2, ...)

exports in the calling package a ctor, accessor methods, some utility methods and some constants:

Sizes can be prefixed by s or u to define signedness of the field. Default is unsigned.

$class->new()

creates a new object with all zeros.

$class->new($bitvector)

creates a new object over $bitvector.

$class->new(%fields)

creates a new object and initializes its fields with the values in %fields.

$obj->new()

clones an object.

$obj->$field()
$obj->$field($value)

gets or sets the value of the bit field $field inside the bit vector.

$class->length
$obj->lenght

returns the size in bits of the bit vector used for storage.

$class->keys
$obj->keys

returns an array with the names of the object attributes

$obj->as_hash

returns a flatten hash with the object attributes, i.e.:
my %values=$obj->as_hash;

%INDEX

hash with offsets as used by vec perl operator (to get an offset in bits, the value has to be multiplied by the corresponding bit field size).

%SIZES

hash with bit field sizes in bits.

%SIGNED

hash with signedness of the fields

Bit fields are packed in the bit vector in the order specified as arguments to make_bits.

Bit fields are padded inside the bit vector, i.e. a class created like

make_bits(A=>1, B=>2, C=>1, D=>4, E=>8, F=>16);

will have the layout

AxBBCxxx DDDDxxxx EEEEEEEE xxxxxxxx FFFFFFFF FFFFFFFF

gjots marshals and organizes text notes in a convenient, hierarchical way.

You can use gjots2 to organise your jottings into a tree structure, adding thoughts and miscellany as you go. You can get it to spit out HTML, XML, postscript, pdf, man etc etc (see the online manual for an example of the HTML conversion).

You can use it to "mind-map" your compositions - write down all your thoughts and then start organising them into a tree. By manipulating the tree you can easily reorder your thoughts and structure them appropriately.

Its a bit like the KDE program kjots but it supports a hierarchy of folders and the folder hierarchy is always visible. Of course, its also written primarily for gnome/GTK-2 rather than KDE.

Critical Mass (aka Critter) is an SDL/OpenGL space shootem up game. Critical Mass project currently runs on Mac OS X, Windows, and Linux.

The latter is my main development platform. Other platforms supported by SDL/OpenGL may also work with a bit of work.

KMilo - Compact Dialog is a KDE patch that makes the default sound dialog look a bit less huge and BLUE.

Tested with 3.5.5 and 3.5.6

This is a project to create 64-bit virtual CPU, create a 64 bit assembler for the CPU and then port C to it, and then create scripts to port GNU/Linux to it.
The aim is to run 64-bit Linux on common 8/16/32 bit CPUs in applications where speed is not an issue.
Enhancements:
- Added C code intended tor a PIC Preliminary documentation More updates to Gambas program