Implementing an 8 bit fixed point register

[nickooooola]

Hello to all
I'm about to write a simulator for a microcontroller in python
(why python? because I love it!!!)

but I have a problem.

The registry of this processor are all 8 bit long (and 10 bit for some
other strange register)
and I need to simulate the fixed point behaviour of the register,
and to access the single bit.

f.x. (this is a pseudo python session, only for understanding)

reg1 = fixed_int(8)
reg2 = fixed_int(10)
reg1[0].set() or
reg1[0] = 1 # or True? how to rapresent a binary bit
reg1[0] 1
reg1[1] 0
reg1[9]

reg2 = 0x7FE # in binary 11111111110 , or 11 bit long
reg2

0x7FE
#or 1111111110, the memorization truncate the upper bits ( or perhaps
generate an exception?)0x00
# truncated again

myprocessor.flags['z']

1
# or True? Z flag indicated an overflow in arithmetic operations

Is possibile to do so in python?

thanks

 

[moogyd]

Hello to all
I'm about to write a simulator for a microcontroller in python
(why python? because I love it!!!)

but I have a problem.

The registry of this processor are all 8 bit long (and 10 bit for some
other strange register)
and I need to simulate the fixed point behaviour of the register,
and to access the single bit.

f.x. (this is a pseudo python session, only for understanding)

reg1 = fixed_int(8)
reg2 = fixed_int(10)
reg1[0].set() or
reg1[0] = 1 # or True? how to rapresent a binary bit
reg1[0] 1
reg1[1] 0
reg1[9]

reg2

0x7FE
#or 1111111110, the memorization truncate the upper bits ( or perhaps
generate an exception?)>>> reg2 += 0x02 #the result is 10000000000, again not contained in 10 bit
0x00
# truncated again>>> myprocessor.flags['z']

1
# or True? Z flag indicated an overflow in arithmetic operations

Is possibile to do so in python?

thanks

I am not sure if it is exactly what you are looking for (it may be a
bit low level), but myHDL may be interesting. It provides low level H/
W simulation capabilities.

http://myhdl.jandecaluwe.com/doku.php


Steven

 

[Mel]

Hello to all
I'm about to write a simulator for a microcontroller in python
(why python? because I love it!!!) [...]
The registry of this processor are all 8 bit long (and 10 bit for some
other strange register)
and I need to simulate the fixed point behaviour of the register,
and to access the single bit.

f.x. (this is a pseudo python session, only for understanding)

reg1 = fixed_int(8)
reg2 = fixed_int(10)
reg1[0].set() or
reg1[0] = 1 # or True? how to rapresent a binary bit
reg1[0] 1
reg1[1] 0
reg1[9]

reg2 = 0x7FE # in binary 11111111110 , or 11 bit long
reg2

0x7FE
#or 1111111110, the memorization truncate the upper bits ( or perhaps
generate an exception?)0x00
# truncated again

myprocessor.flags['z']

1
# or True? Z flag indicated an overflow in arithmetic operations

Is possibile to do so in python?

I did this for a PIC, and generally just used brute force, e.g.

temp = reg2 + 0x02
reg2 = temp & 0xFF
if temp & 0x100:
flags |= CARRY_MASK
else:
flags &= ~CARRY_MASK
if temp & 0xFF:
flags &= ~ZERO_MASK
else:
flags |= ZERO_MASK

Since it was a PIC, and there were only a half-dozen arithmetic/logical
operations, the code stayed in this form. With something bigger, it would
have been attractive to wrap these operations up in a class, as you
suggest.. (just a sketch) ..

class fixed_register (object):
def __init__ (self, size, val=0):
self.mask = ~(-1 << size)
self.ovfmask = 1 << size
self.val = val & self.mask

with appropriate __add__, __sub__, etc. Perhaps __getitem__, __setitem__ to
manipulate bits.

Good Luck, Mel.

 

[nickooooola]

Thanks to all for the responses!

to MEl: I also want to build a pic simulator, but I want to do this as
"python for big project" learning exercise, I have used python in the
past only for small script and now I want to use it for something more
"big".
do you have some code to share?

myhdl seems interesting, I think that I can take a blick on its source
code...I think that must have something like
the 8 bit register class that I need somewhere

I try what you people have said, and if it turns to be something
useful, I report it to the community.

Nicola

Ps
excuse me for my english...

 

[Terry Reedy]

Hello to all
I'm about to write a simulator for a microcontroller in python
(why python? because I love it!!!)

but I have a problem.

The registry of this processor are all 8 bit long (and 10 bit for some
other strange register)
and I need to simulate the fixed point behaviour of the register,
and to access the single bit.

In Python3, I would use a (mutable) bytearray.

IDLE 3.0b1

>>> reg1 = bytearray((0,)*8) # or *10 for 10 bits
>>> reg1 bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00')
>>> reg1[1]=1
>>> reg1[1] 1
>>> tuple(reg1)

(0, 1, 0, 0, 0, 0, 0, 0)

A bytearray subclass could enforce that all 'bits' (stored as bytes) are
0 or 1, have a customized representation to your taste, and add methods
like .flipall().

The overhead of using 8 bytes instead of 1 to hold the object value is
actually small compared to the minimum object size of 16 bytes (on Win32XP).
24

In Python2.x, you can use the array module to make equivalent mutable
arrays of chars.

Terry Jan Reedy

 

[Terry Reedy]

Hello to all
I'm about to write a simulator for a microcontroller in python
(why python? because I love it!!!)

but I have a problem.

The registry of this processor are all 8 bit long (and 10 bit for some
other strange register)
and I need to simulate the fixed point behaviour of the register,
and to access the single bit.

In Python3, I would use a (mutable) bytearray.

IDLE 3.0b1

reg1 = bytearray((0,)*8) # or *10 for 10 bits
reg1 bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00')

reg1[1]=1
reg1[1]

1
tuple(reg1)

(0, 1, 0, 0, 0, 0, 0, 0)

A bytearray subclass could enforce that all 'bits' (stored as bytes) are
0 or 1, have a customized representation to your taste, and add methods
like .flipall().

It seems like implementing ALU operations on such arrays would
be a lot more work than implementing bit-indexing on a type
derived on a more "integer" like base. I'm pretty fuzzy on how
one sub-classes basic things like integers, so maybe I'm all
wet, and adding __getitem__ and __setitem__ to an integer type
isn't even possible.

If one only wants bit operations, then the array approach is easy. If
one only wants int arithmetic and all-bits logic, then int approach is
easy. OP did not completely specify needs.

The problem with the int approach is that ints are immutable.
Therefore, if one wants to subclass int to hide the bit masking for the
bit operations, one must override *every* operation one might use,
including all arithmetic and all-bits logic, even when the int operation
gives the correct answer other than the class of the result.

class bits(int):
....
def __add__(self,other):
return bit(self+other)
....

If one does not,

a,b = bits(1),bits(2)
c = a+b #c is now an int, not a bits

So there is a tendency to not subclass and instead either leave the
extra functionality unmasked in repeated code or to put it in functions
instead.

setters = (1,2,4,8,16,32,64, ..., 2147483648)# slightly pseudocode
unsetters = (~1,~2,~4,...~2147483648) # ditto
def bitset(n, bit): return n | setters[bit]
def bitunset(n,bit): return n & unsetters[bit]

thus not getting the nice reg[n] functionality, nor an easy display of
individual bits without callings *another* function.

One the other hand, with mutable arrays, setting bits is a mutation and
so no override of __setitem__ is required unless one wants to be fancy
and enforce setting to 0 or 1.

It is a trade-off.

Terry Jan Reedy