Implementing an 8 bit fixed point register
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 110 , or 11 bit long >>> reg2 0x7FE #or 10, the memorization truncate the upper bits ( or perhaps generate an exception?) >>> reg2 += 0x02 #the result is 100, again not contained in 10 bit >>> reg2 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 -- http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
On 1 Jul, 08:57, nickola <[EMAIL PROTECTED]> wrote: > 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 > 110 , or 11 bit long > >>> reg2 > > 0x7FE > #or 10, the memorization truncate the upper bits ( or perhaps > generate an exception?)>>> reg2 += 0x02 #the result is 100, again not > contained in 10 bit > >>> reg2 > > 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 -- http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
nickola wrote: > 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 110 , or 11 bit long reg2 > 0x7FE > #or 10, the memorization truncate the upper bits ( or perhaps > generate an exception?) reg2 += 0x02 #the result is 100, again not contained in 10 bit reg2 > 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. -- http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
On 2008-07-01, nickola <[EMAIL PROTECTED]> wrote:
> 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,
Somebody posted a class that impliments fixed-width integer
types a while back.
> and to access the single bit.
The bitwise operators &, |, ~, ^ all work just like they do in C.
You can write methods to dip those in syntactic sugar if you
want.
> 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 110 , or 11 bit long
reg2
> 0x7FE
> #or 10, the memorization truncate the upper bits ( or perhaps
> generate an exception?)
reg2 += 0x02 #the result is 100, again not contained in 10 bit
reg2
> 0x00
> # truncated again
myprocessor.flags['z']
> 1
> # or True? Z flag indicated an overflow in arithmetic operations
>
> Is possibile to do so in python?
Yes. Everything shown above is possible. If you really want
to get clever, you'll want to read up on the __setattr__,
__getattr__, __getitem__, and __setitem__ object methods.
They'll allow you to define special handling for the semantics
below:
foo.something = x # calls foo.__setattr___('something',x)
x = foo.something # calls foo.__getattr___('something,)
foo[n] = x # calls foo.__setitem__(n,x)
x = foo[n] # calls foo.__getitme__(n)
In the latter two cases, you can support slicing if you want.
That could allows you to grab a "bitfield" out of a register:
x = processor.regA[4:7] # get bits 4,5,6
processor.regA[4:7] # set bits 4,5,6
Just remember that in Python slices are traditionally half-open
intervals -- they don't include the "right" endpoint. That's
going to confuse people who are more used to reading processor
data sheets where bit-ranges are traditionally closed
intervals. You _could_ implment your __[sg]etitem__ slice
handling so that they're treated as closed intervals. That will
be a lot more intuitive to people used to dealing with
microprocessor register definitions, but could confuse an
experienced Python programmer.
Writing methods for __setattr__ and __getattr__ is a little
tricky. It's very easy to end up with infinite recursion. It's
not that hard to fix/avoid, but it takes a while to get the
hang of it.
--
Grant Edwards grante Yow!
at
visi.com
--
http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
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... -- http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
nickola wrote: 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). >>> sys.getsizeof(reg1) 24 In Python2.x, you can use the array module to make equivalent mutable arrays of chars. Terry Jan Reedy -- http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
On 2008-07-01, Terry Reedy <[EMAIL PROTECTED]> wrote: > > > nickola wrote: >> 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. -- Grant Edwards grante Yow! Do you guys know we at just passed thru a BLACK visi.comHOLE in space? -- http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
Grant Edwards wrote: On 2008-07-01, Terry Reedy <[EMAIL PROTECTED]> wrote: nickola wrote: 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 -- http://mail.python.org/mailman/listinfo/python-list
Re: Implementing an 8 bit fixed point register
On 2008-07-01, Terry Reedy <[EMAIL PROTECTED]> wrote: >>> 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. He said he's writing a microprocessor simulator, so he's going to want integer operations, all-bits logical operations, and individual bit acess (by number and by name) and bit-slice access. > The problem with the int approach is that ints are immutable. That dawned on me after I started googling around a little. > 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. Since we're doing fixed-width operations, Python's int operations don't give 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] On a machine with a barrel shifter, it's probably faster to do this: def bitset(n,bit): return n | (1< 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. More importantly, I presume that slices are supported so when you need values of bit-fields, you can do this: op = instruction[6:8] src = instruction[3:6] dest = instruction[0:3] The half-closed interval notation for slices is probably going to drive the programmer up the wall because all of the documentation that's being followed uses closed intervals. > It is a trade-off. And Python programmers are awfully spoiled. :) -- Grant Edwards grante Yow! I think my career at is ruined! visi.com -- http://mail.python.org/mailman/listinfo/python-list
