Sample GPIO codes highlighting RPi.GPIO-PineA64 and the PI bus

Code:

display8bit.py





 

## display8bit.py

#

#   Mark H. Harris

#   v.01i

#   07-15-2016

#   Rochester, MN

#

#

## IMPORTS

from time import sleep

from sys import argv

import RPi.GPIO as GPIO



## ALL GPIO use Broadcom Numbering

GPIO.setmode(GPIO.BCM)



## PUSH BUTTON SWITCH DEFINED HERE, BUT NOT ALWAYS USED

p_switch = 19

GPIO.setup(p_switch, GPIO.IN, pull_up_down=GPIO.PUD_UP)



## BINARY ROMS 

high_pins=[23, 22, 21, 20]

for pin in high_pins:

    GPIO.setup(pin, GPIO.OUT)



low_pins=[27, 26, 25, 24]

for pin in low_pins:

    GPIO.setup(pin, GPIO.OUT)



## FUNCTION DEFINITIONS

def push_button():

    if GPIO.input(p_switch):

        return False

    else:

        return True



def led_on(pin):

    GPIO.output(pin, True)



def led_off(pin):

    GPIO.output(pin, False)



def bin_display(val, led_rom, nibble, std_inv):

    bin_digit = nibble

    if (std_inv=="STD"):

        start=0; finish=4; incrmt=1

    else:

        start=3; finish=-1; incrmt=-1

    for n in range(start, finish, incrmt):

        if (val & bin_digit):

            led_on(led_rom[n])

        else:

            led_off(led_rom[n])

        bin_digit = bin_digit<<(1)



def dsp8_STD(val):

    bin_display(val, high_pins, 0x10, "STD")

    bin_display(val, low_pins, 0x1, "STD")



def dsp8_INV(val):

    bin_display(val, low_pins, 0x10, "INV")

    bin_display(val, high_pins, 0x1, "INV")



def counter_8bit(max, t_delay, std_inv):

    for n in range(max):

        if (std_inv=="STD"):

            dsp8_STD(n)

        else:

            dsp8_INV(n)

        sleep(t_delay)



def counter_4bit(max, led_rom, t_delay, std_inv):

    for n in range(max):

        bin_display(n, led_rom, 0x1, std_inv)

        sleep(t_delay)



def walking(cycles, t_delay, std_inv):

    for m in range(cycles):

        digit=0x1

        for n in range(9):

            if (std_inv=="STD"):

                dsp8_STD(digit) 

            else:

                dsp8_INV(digit) 

            sleep(t_delay)

            digit = digit << (1)



def all_off():

    dsp8_INV(0x0)



def all_on():

    dsp8_INV(0xff)



def end():

    GPIO.cleanup()

    quit()

Code:

dsp_patterns3.sh





 

#!/usr/bin/python3

# dsp_patterns3.sh

#

#   Mark H. Harris

#   v.01i

#   07-15-2016

#   Rochester, MN

#

## REQUIRES v.10h display8bit.py

import display8bit as DSP

import signal as SIG



## RUN CYCLE COUNTER DISPLAYED WITH HUP SIGNAL

cycle = 0



## EXIT FLAG FROM SIGINT INTERRUPT HANDLER

interrupt_flag = False



## DISPLAY ORDER OF PATTERNS USED BY SIGUSR1 AND SIGUSR2

led_pattern_index=[2, 12, 3, 1, 4, 9, 11, 5, 7, 6, 8, 0, 10]



## BEGINNING DISPLAY PATTERN (IN THIS EXAMPLE 1)

#     led_pattern_index numbered from 0

#         pattern_index = 2

#         led_pattern_index[2] = 1  (see index above)

pattern_index=2

pattern_num = led_pattern_index[pattern_index]



## FREQUENCY SETTINGS (DELAYS) SET BY HUP

tt_delay_val=[0.023, 0.077, 0.140, 0.258, 0.70]

tt_delay_index=2

tt_delay=tt_delay_val[tt_delay_index]



## DISPLAY LED PATTERN ROMS

circular2R = [0x88, 0xc0, 0x60, 0x30, 0x11, 0x03, 0x06, 0x0c]

dual_walker= [0x81, 0x42, 0x24, 0x18, 0x24, 0x42]

side_side_steps = [0x08, 0x40, 0x02, 0x10, 0x01, 0x20, 0x04, 0x80]

two_led_wave = [0x88, 0x44, 0x22, 0x11, 0x22, 0x44]

all_leds_on_flasher = [0xff, 0x00]

high_low_bars_flasher = [0xf0, 0x0f]

alternating_flasher = [0x69, 0x96]

curtain_scanner = [0x1f, 0x8f, 0xc7, 0xe3, 0xf1, 0xf8, 0xf1, 0xe3, 0xc7, 0x8f]



## SIGUSR2 HANDLER FOR SELECTING PREVIOUS DISPLAY INDEX

def ssigusr2(signum, frame):

    global pattern_num

    global pattern_index

    if (pattern_index>0):

        pattern_index-=1

    else:

        pattern_index=len(led_pattern_index)-1

    pattern_num=led_pattern_index[pattern_index]

    print("\n USR1: swapping backward to previous pattern: "+str(pattern_num)+"\n")



## SIGUSR1 HANDLER FOR SELECTING NEXT DISPLAY INDEX

def ssigusr1(signum, frame):

    global pattern_num

    global pattern_index

    if (pattern_index<len(led_pattern_index)-1):

        pattern_index+=1

    else:

        pattern_index=0

    pattern_num=led_pattern_index[pattern_index]

    print("\n USR1: swapping forward to next pattern: "+str(pattern_num)+"\n")



## SIGHUP HANDLER FOR DISPLAYING INFORMATION AND ROTATING DELAY INDEX

def ssighup(signum, frame):

    global tt_delay

    global tt_delay_index

    tt_delay_top = len(tt_delay_val)-1

    if (tt_delay_index<tt_delay_top):

        tt_delay_index+=1

    else:

        tt_delay_index=0

    tt_delay=tt_delay_val[tt_delay_index]

    print("\n cycle: "+str(cycle))

    print("\n delay: "+str(tt_delay))

    print("\n HUP: presently displaying pattern: "+str(pattern_num)+"\n")



## SIGINT HANDLER FOR EXITING THE DISPLAY PROCESS

def ssigint(signum, frame):

    global interrupt_flag

    print("\n keyboard interrupt"+"\n")

    interrupt_flag = True



## SIGNAL TRAPS

SIG.signal(SIG.SIGINT, ssigint)

SIG.signal(SIG.SIGHUP, ssighup)

SIG.signal(SIG.SIGUSR1, ssigusr1)

SIG.signal(SIG.SIGUSR2, ssigusr2)



## DISPLAY FUNCTION FOR READING AND RESOLVING DISPLAY ROMS INFORMATION

def displayf(pattern, fwd_rvs):

    p_pattern=[]

    if (fwd_rvs=="RVS"):

        for n in range(len(pattern)-1, -1, -1):

            p_pattern.append(pattern[n])

    else:

        p_pattern=pattern

    for p_code in p_pattern:

        DSP.dsp8_STD(p_code)

        DSP.sleep(tt_delay)



## MAIN TRY BLOCK FOR THE DISPLAY PROCESS

while (not interrupt_flag):

    try:

        if (pattern_num==0):

            ## 0 FLASHING BARS OF GREEN AND RED

            displayf(high_low_bars_flasher, "FWD")

        if (pattern_num==1):

            ## 1 DUAL WALKING PATTERN SIMPLE

            displayf(dual_walker, "FWD")

        if (pattern_num==2):

            ## 2x2 ALTERNATE FLASHING PATTERN SIMPLE

            DSP.dsp8_STD(0xcc)

            DSP.sleep(tt_delay)

            DSP.dsp8_STD(0x33)

            DSP.sleep(tt_delay)

        if (pattern_num==3):

            ## 3 SINGLE RAPID WALKER FROM DSP

            DSP.walking(1, tt_delay, "STD")

            DSP.sleep(tt_delay)

            DSP.walking(1, tt_delay, "INV")

            DSP.sleep(tt_delay)

        if (pattern_num==4):

            ## 4 STEPS BACK-AND-FORTH LEFT-AND-RIGHT

            displayf(side_side_steps, "FWD")

            DSP.dsp8_STD(0x0)

            DSP.sleep(tt_delay)

            displayf(side_side_steps, "RVS")

            DSP.dsp8_STD(0x0)

            DSP.sleep(tt_delay)

        if (pattern_num==5):

            ## 5 CLOCK-WISE 2-LED CIRCULAR WALKING D-RIGHT

            displayf(circular2R, "FWD")

        if (pattern_num==6):

            ## 6 COUNTER CLOCK-WISE 2-LED CIRCULAR WALKING D-LEFT

            displayf(circular2R, "RVS")

        if (pattern_num==7):

            ## 7 STROBE RIGHT

            DSP.walking(1, tt_delay, "INV")

            DSP.sleep(tt_delay)

        if (pattern_num==8):

            ## 8 STROBE LEFT

            DSP.walking(1, tt_delay, "STD")

            DSP.sleep(tt_delay)

        if (pattern_num==9):

            ## 9 TWO LED WAVE DISPLAY   

            displayf(two_led_wave, "FWD")

        if (pattern_num==10):

            ## 10 ALL LEDS ON FLASHER !  

            displayf(all_leds_on_flasher, "FWD")

        if (pattern_num==11):

            ## 11 ALTERNATING PATTERN INTERESTING  

            displayf(alternating_flasher, "FWD")

        if (pattern_num==12):

            ## 12 ALTERNATING PATTERN INTERESTING  

            displayf(curtain_scanner, "FWD")

    finally:

        if interrupt_flag:

            break

        cycle+=1

        # print("cycle: "+str(cycle)+"\n") DSP.all_off()



DSP.GPIO.cleanup()