243 lines
9.3 KiB
Python
Executable File
243 lines
9.3 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import RPi.GPIO
|
|
import time
|
|
|
|
class channel:
|
|
def __init__(self):
|
|
if RPi.GPIO.getmode() != RPi.GPIO.BOARD:
|
|
RPi.GPIO.setmode(RPi.GPIO.BOARD)
|
|
self._PWMFreq = 48
|
|
self._PWMDutyCycle = 0
|
|
self._PWM = []
|
|
|
|
def channel_list(self,ChnlList):
|
|
Channels = []
|
|
if type(ChnlList) != list:
|
|
Channels.append(ChnlList)
|
|
else:
|
|
Channels = list(ChnlList)
|
|
return Channels
|
|
|
|
def chnl_in(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.setup(Chnl,RPi.GPIO.IN)
|
|
def chnl_in_pud_up(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.setup(Chnl,RPi.GPIO.IN, pull_up_down=RPi.GPIO.PUD_UP)
|
|
def chnl_in_pud_down(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.setup(Chnl,RPi.GPIO.IN, pull_up_down=RPi.GPIO.PUD_DOWN)
|
|
def chnl_out(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.setup(Chnl,RPi.GPIO.OUT)
|
|
def chnl_out_on(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.output(Chnl,RPi.GPIO.HIGH)
|
|
def chnl_out_off(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.output(Chnl,RPi.GPIO.LOW)
|
|
def chnl_state(self,ChnlList):
|
|
StateList = []
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
StateList.append(RPi.GPIO.input(Chnl))
|
|
return StateList
|
|
|
|
def wait_change_block(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.wait_for_edge(Chnl,RPi.GPIO.BOTH)
|
|
def wait_up_block(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.wait_for_edge(Chnl,RPi.GPIO.RISING)
|
|
def wait_down_block(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.wait_for_edge(Chnl,RPi.GPIO.FALLING)
|
|
def wait_change(self,ChnlList,callback=lambda *args: None):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.add_event_detect(Chnl,RPi.GPIO.BOTH,callback)
|
|
def wait_up(self,ChnlList,callback=lambda *args: None):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.add_event_detect(Chnl,RPi.GPIO.RISING,callback)
|
|
def wait_down(self,ChnlList,callback=lambda *args: None):
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
RPi.GPIO.add_event_detect(Chnl,RPi.GPIO.FALLING,callback)
|
|
def wait_check(self,ChnlList):
|
|
StateList = []
|
|
Chnls = self.channel_list(ChnlList)
|
|
for Chnl in Chnls:
|
|
StateList.append(RPi.GPIO.event_detected(Chnl))
|
|
return StateList
|
|
|
|
def chnl_pwm(self,ChnlList):
|
|
self.chnl_pwm_add(ChnlList)
|
|
def chnl_pwm_add(self,ChnlList):
|
|
Chnls = self.channel_list(ChnlList)
|
|
self.chnl_out(Chnls)
|
|
for Chnl in Chnls:
|
|
self._PWM.append(RPi.GPIO.PWM(Chnl,self._PWMFreq))
|
|
self._PWM[-1].start(self._PWMDutyCycle)
|
|
def chnl_def_freq(self,Freq):
|
|
self._PWMFreq = Freq
|
|
def chnl_def_dc(self,DutyCycle):
|
|
self._PWMDutyCycle = DutyCycle
|
|
def chnl_pwm_set_freq(self,Freq):
|
|
for Pwm in self._PWM:
|
|
pwm.ChangeFrequency(Freq)
|
|
def chnl_pwm_set_dc(self,DC):
|
|
for Pwm in self._PWM:
|
|
Pwm.ChangeDutyCycle(DC%100)
|
|
def chnl_pwm_stop(self):
|
|
for Pwm in self._PWM:
|
|
Pwm.stop()
|
|
def clean(self):
|
|
self.chnl_pwm_stop()
|
|
RPi.GPIO.cleanup()
|
|
self._PWM = []
|
|
|
|
class morse:
|
|
_Alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
|
|
'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
|
|
'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'ä', 'ö',
|
|
'ü', 'ß', '.', ',', ':', ';', '?', '-', '_', '(', ')', "'", '=',
|
|
'+', '/', '@']
|
|
_ToMorse = {'a':0b110,'b':0b10001,'c':0b10101,'d':0b1001,'e':0b10,
|
|
'f':0b10100,'g':0b1011,'h':0b10000,'i':0b100,'j':0b11110,
|
|
'k':0b1101,'l':0b10010,'m':0b111,'n':0b101,'o':0b1111,
|
|
'p':0b10110,'q':0b11011,'r':0b1010,'s':0b1000,'t':0b11,
|
|
'u':0b1100,'v':0b11000,'w':0b1110,'x':0b11001,'y':0b11101,
|
|
'z':0b10011,'0':0b111111,'1':0b101111,'2':0b100111,'3':0b100011,
|
|
'4':0b100001,'5':0b100000,'6':0b110000,'7':0b111000,
|
|
'8':0b111100,'9':0b111110,'ä':0b11010,'ö':0b10111,'ü':0b11100,
|
|
'ß':0b10011000,'.':0b1101010,',':0b1110011,':':0b1000111,
|
|
';':0b1010101,'?':0b1001100,'-':0b1100001,'_':0b1101100,
|
|
'(':0b101101,')':0b1101101,'\'':0b1011110,'=':0b110001,
|
|
'+':0b101010,'/':0b101001,'@':0b1010110}
|
|
_ToAlpha = {0b110:'a',0b10001:'b',0b10101:'c',0b1001:'d',0b10:'e',
|
|
0b10100:'f',0b1011:'g',0b10000:'h',0b100:'i',0b11110:'j',
|
|
0b1101:'k',0b10010:'l',0b111:'m',0b101:'n',0b1111:'o',
|
|
0b10110:'p',0b11011:'q',0b1010:'r',0b1000:'s',0b11:'t',
|
|
0b1100:'u',0b11000:'v',0b1110:'w',0b11001:'x',0b11101:'y',
|
|
0b10011:'z',0b111111:'0',0b101111:'1',0b100111:'2',0b100011:'3',
|
|
0b100001:'4',0b100000:'5',0b110000:'6',0b111000:'7',
|
|
0b111100:'8',0b111110:'9',0b11010:'ä',0b10111:'ö',0b11100:'ü',
|
|
0b10011000:'ß',0b1101010:'.',0b1110011:',',0b1000111:':',
|
|
0b1010101:';',0b1001100:'?',0b1100001:'-',0b1101100:'_',
|
|
0b101101:'(',0b1101101:')',0b1011110:'\'',0b110001:'=',
|
|
0b101010:'+',0b101001:'/',0b1010110:'@'}
|
|
|
|
def __init__(self,ChnlList,WrnChnlList=-1,ErrChnlList=-1):
|
|
self._Board = channel()
|
|
self.set_blink_factor(1)
|
|
self.set_short_time(1/30)
|
|
self.set_long_time(1/15)
|
|
self.set_chnls(ChnlList)
|
|
self.set_chnls_warning(WrnChnlList)
|
|
self.set_chnls_error(ErrChnlList)
|
|
|
|
def set_chnls(self,ChnlList):
|
|
if type(ChnlList) != list:
|
|
ChnlList = [ChnlList]
|
|
self._ChnlList = list(ChnlList)
|
|
self._Board.chnl_out(self._ChnlList)
|
|
def set_chnls_warning(self,WrnChnlList):
|
|
if WrnChnlList != -1:
|
|
if type(WrnChnlList) != list:
|
|
WrnChnlList = [WrnChnlList]
|
|
self._WarnChnlList = list(WrnChnlList)
|
|
self._Board.chnl_out(self._WarnChnlList)
|
|
else:
|
|
self._WarnChnlList = []
|
|
def set_chnls_error(self,ErrChnlList):
|
|
if ErrChnlList != -1:
|
|
if type(ErrChnlList) != list:
|
|
ErrorChnlList = [ErrChnlList]
|
|
self._ErrorChnlList = list(ErrorChnlList)
|
|
self._Board.chnl_out(self._ErrorChnlList)
|
|
else:
|
|
self._ErrorChnlList = []
|
|
def set_blink_factor(self,Factor):
|
|
self._Factor = Factor
|
|
def set_long_time(self, Long):
|
|
self._Long = Long
|
|
def set_short_time(self, Short):
|
|
self._Short = Short
|
|
|
|
def chnls(self):
|
|
return list(self._ChnlList)
|
|
def chnls_warning(self):
|
|
return list(self._WarnChnlList)
|
|
def chnls_error(self):
|
|
return list(self._ErrorChnlList)
|
|
def alphabet(self):
|
|
return list(self._Alphabet)
|
|
def symbol_to_morse(self):
|
|
return dict(self._ToMorse)
|
|
def morse_to_symbol(self):
|
|
return dict(self._ToAlpha)
|
|
def blink_factor(self):
|
|
return self._Factor
|
|
def long_time(self):
|
|
return self._Long
|
|
def short_time(self):
|
|
return self._Short
|
|
|
|
def clean(self):
|
|
self._Board.clean()
|
|
self._ChnlList = []
|
|
self._WarnChnlList = []
|
|
self._ErrorChnlList = []
|
|
self._Factor = 1
|
|
self._Short = 1/30
|
|
self._Long = 1/15
|
|
|
|
def _blink_short(self,ChnlList):
|
|
self._Board.chnl_out_on(ChnlList)
|
|
time.sleep(self._Short*self._Factor)
|
|
self._Board.chnl_out_off(ChnlList)
|
|
time.sleep(self._Short*self._Factor)
|
|
def _blink_long(self,ChnlList):
|
|
self._Board.chnl_out_on(ChnlList)
|
|
time.sleep(self._Long*self._Factor)
|
|
self._Board.chnl_out_off(ChnlList)
|
|
time.sleep(self._Long*self._Factor)
|
|
|
|
def transmit(self, Text):
|
|
MorseText = []
|
|
for Char in Text:
|
|
Char = Char.lower()
|
|
if Char in [' ','\t','\n']:
|
|
time.sleep(self._Long*2*self._Factor)
|
|
MorseText.append(Char)
|
|
elif Char not in self._Alphabet:
|
|
for ErrChnl in self._ErrorChnlList:
|
|
self._Board.chnl_out_on(ErrChnl)
|
|
time.sleep(self._Long*self._Factor)
|
|
for ErrChnl in self._ErrorChnlList:
|
|
self._Board.chnl_out_off(ErrChnl)
|
|
time.sleep(self._Long*self._Factor)
|
|
MorseText.append('?')
|
|
else:
|
|
Code = self._ToMorse[Char]
|
|
while Code > 1:
|
|
if Code % 2 == 0:
|
|
self._blink_short(self._ChnlList)
|
|
MorseText.append('.')
|
|
else:
|
|
self._blink_long(self._ChnlList)
|
|
MorseText.append('-')
|
|
Code //= 2
|
|
return ''.join(MorseText)
|
|
|