Bitwise operations and masks: basics, help?

[mister_e]

Yes i see some different ways, just paste your pattern here and where to send them, i'll give you something to think about.

[xnihilo]

Example:

The bits I need to set to display the "0" digit on the 7 segments display are:

on porta: %***01* , all other bits are left untouched
on portc: %*11111 , bit 5 is left untouched.

I have two arrays of bytes:
cval VAR BYTE[10] and aval VAR BYTE[10], each index represents a duet of bytes containing the bits configuration to display a digit.
arrays index 0 for digit "0",... up to digit "9" in index 9.

I only need to 'insert' chunks of bits in porta and portc registers.


For a given array index (representing the 7 bits to make a digit):
For porta I will need to replace bits 1 and 2 from porta by bits 1 and 2 from aval variable.
For portc I will need to replace bits 4 to 0 from portc by bits 4 to 0 from cval variable

is this clear ???

[mister_e]

Why not a WORD array instead? Anyways, yes it's clear enough. I'll do something a little bit later.

[xnihilo]

Why not a WORD array instead? Anyways, yes it's clear enough. I'll do something a little bit later.

Yes, I may use a WORD array instead... Anyway, it wont be much different I guess. The principle of bit manipulations will remain the same I beleive...

Anyway, thank you very much for your help.

[mister_e]

        '
        '   Tested on 16F877
        '   ----------------
@       __CONFIG _XT_OSC & _LVP_OFF & _WDT_OFF

        TRISA=0
        TRISB=0
        TRISC=0
        TRISD=0
        
        
        Aval VAR byte [10]
        Cval VAR BYTE [10]
        CounterA VAR BYTE
        CounterB VAR BYTE
        
        PORTA=0
        PORTB=0
        PORTC=0
        PORTD=0
        ADCON1=7
        
        AVAL[0]=%00000000
        AVAL[1]=%00000010
        AVAL[2]=%00000100
        AVAL[3]=%00001010
        AVAL[4]=%00010000
        AVAL[5]=%00100010
        AVAL[6]=%01000100
        AVAL[7]=%10000010
        AVAL[8]=%10101001
        AVAL[9]=%11111111

        CVAL[0]=%00000000
        Cval[1]=%00000001
        CVAL[2]=%00000010
        CVAL[3]=%00000100
        CVAL[4]=%00001000
        CVAL[5]=%00010000
        CVAL[6]=%00101000
        CVAL[7]=%01000100
        CVAL[8]=%10000010
        CVAL[9]=%11100001

Start:
        for CounterB = 0 to 255
            PORTA=CounterB
            PORTB=COUNTERB
            PORTC=CounterB
            PORTD=COUNTERB
            fOR CounterA = 0 TO 9
                '
                '   this should be the section you need
                PORTA = (PORTA & %11111001) | (AVAL[COUNTERA] & %00000110)
                PORTC = (PORTC & %11100000) | (CvAL[CounterA] & %00011111)
                '
                '
                PAUSE 250
                NEXT        
            NEXT
        STOP

PS: As you only use 7 bit... you could also us ONLY 1 byte array instead of 2.

[falingtrea]

What I would do is:

PORTC = PORTC & %11100000   / Clear all the bits in PORTC that are segments
PORTC = AVAL[x] | PORTC        / sets the bits in PORTC that are '1' in AVAL[x]

PORTA = PORTA & %11111001  /  Clear all the bits in PORTA that are segments
PORTA = CVAL[x] | PORTA       / sets the bits in PORTA that are '1' in CVAL[x]

if you just want to use one matrix for segment data you can do this:

ORMASK = SEGVAL[x] & %00011111 / makes sure only 5 lsb of SEGVAL[x] '1' bits get set below
PORTC = PORTC & %11100000    / Clear all the bits in PORTC that are segments 
PORTC = ORMASK | PORTC         / sets the bits in PORTC that are '1' in AVAL[x]

ORMASK = SEGVAL[x] >> 4         / shift data 4 to right to position correct SEGVAL[x] bits for PORTA
ORMASK = ORMASK & %0000110 / makes sure only 2 bits of SEGVAL[x] '1' bits get set below
PORTA = PORTA | %11111001    / Clear all the bits in PORTA that are segments
PORTA = ORMASK | PORTA        / sets the bits in PORTC that are '1' in AVAL[x]

[mister_e]

Yup, mine is just in case something is badly define in the array, unless

PORTA = (PORTA & %11111001) | AVAL[COUNTERA]
PORTC = (PORTC & %11100000) | CvAL[CounterA]

Would work anyways.