def __init__(self, tunData, radios):
# init tun
self.ip = tunData[0]
self.mask = tunData[1]
self.tun = TunTap(nic_type="Tun", nic_name="longge")
self.tun.config(ip=self.ip, mask=self.mask)
# init nrf24
self.radios = radios
self.address = [b'1Node', b'2Node']
self.radioNumber = 0 if self.tun.ip == "192.168.2.1" else 1
for r in self.radios:
if not r.begin():
raise RuntimeError("Hardware Error")
r.setPALevel(RF24_PA_LOW)
r.openWritingPipe(self.address[self.radioNumber])
r.openReadingPipe(1, self.address[not self.radioNumber])
r.payloadSize = 32
r.setAutoAck(False) # config chip --------------
r.disableCRC()
r.setDataRate(RF24_2MBPS)
# misc
self.fr = FrameReader()
self.routingtable = []
self.payloads = {}
def __init__(self, serial, rxq, txq, stop, is_master):
Thread.__init__(self)
self.txq = txq
self.rxq = rxq
self.stop = stop
self.master = is_master
self.serial = serial
self.rx_task = Serial485Rx(self.serial, self.rxq, self.stop, self.master, self)
if ENABLE_WIRESHARK and self.master:
from tuntap import TunTap
self.tun = TunTap()
self.tun.open()
self.rx_task.start()
def main():
parser = optparse.OptionParser()
parser.add_option('--nic_type', default='Tun',dest='nic_type',
help='set type Tun or Tap')
parser.add_option('--nic_name', default='',dest='nic_name',
help='set device name')
parser.add_option('--tap-addr', default='192.168.33.10',dest='taddr',
help='set tunnel local address')
parser.add_option('--tap-netmask', default='255.255.255.0',dest='tmask',
help='set tunnel netmask')
parser.add_option('--tap-mtu', type='int', default=1500,dest='tmtu',
help='set tunnel MTU')
parser.add_option('--local-addr', default='0.0.0.0', dest='laddr',
help='set local address [%default]')
parser.add_option('--local-port', type='int', default=12000, dest='lport',
help='set local port [%default]')
# parser.add_option('--remote-addr', dest='raddr',
# help='set remote address')
# parser.add_option('--remote-port', type='int', dest='rport',
# help='set remote port')
opt, args = parser.parse_args()
# if not (opt.taddr and opt.raddr and opt.rport):
# parser.print_help()
# return 1
try:
tuntap = TunTap(opt.nic_type)
tuntap.create()
tuntap.config(opt.taddr, opt.tmask)
#, opt.tmtu, opt.laddr,opt.lport, opt.raddr, opt.rport)
except Exception as e:
print(str(e),traceback.format_exc())
traceback.print_stack(limit=10)
return 1
start_new_thread(readtest,(tuntap,))
input("press return key to quit!")
tuntap.close()
return 0
def prepareenv(self):
# create devname
if "a." == self._devname[0:2]:
self.shell(["ip", "tuntap", "add", "mode", "tap", self._devname])
self.assignmac(self._devname)
dev = TunTap(nic_type="Tap", nic_name=self._devname)
else:
self.shell(["ip", "tuntap", "add", "mode", "tun", self._devname])
dev = TunTap(nic_type="Tun", nic_name=self._devname)
if not self._ip is None:
dev.config(self._ip, "255.255.255.0")
self._dev = dev
self.shell(["ip", "link", "set", self._devname, "up"])
if not self._bridge is None:
ret = self.shell(
["/sbin/brctl", "addif", self._bridge, self._devname])
if ret != 0:
raise Exception("Can not add tap dev to bridge")
self._mgrdict["pid"] = self.pid
pass
class TunDevice:
def __init__(self, tunData, radios):
# init tun
self.ip = tunData[0]
self.mask = tunData[1]
self.tun = TunTap(nic_type="Tun", nic_name="longge")
self.tun.config(ip=self.ip, mask=self.mask)
# init nrf24
self.radios = radios
self.address = [b'1Node', b'2Node']
self.radioNumber = 0 if self.tun.ip == "192.168.2.1" else 1
for r in self.radios:
if not r.begin():
raise RuntimeError("Hardware Error")
r.setPALevel(RF24_PA_LOW)
r.openWritingPipe(self.address[self.radioNumber])
r.openReadingPipe(1, self.address[not self.radioNumber])
r.payloadSize = 32
r.setAutoAck(False) # config chip --------------
r.disableCRC()
r.setDataRate(RF24_2MBPS)
# misc
self.fr = FrameReader()
self.routingtable = []
self.payloads = {}
# self.sendQ = queue.Queue()
# self.receiveQ = queue.Queue()
# Handshake helper function
def assignIP(self, ip):
newIp = ip
if ip in self.routingtable:
parts = ip.split('.')
for i in range(2, 255): # 1 is base, 255 is broadcast (?)
newIp = str(parts[0] + "." + parts[1] + "." + parts[2] + "." +
str(i))
if newIp not in self.routingtable:
break
return newIp
def packetType(self, rcvd):
return rcvd.hex()[:2]
def handshake(self, fragment, data):
if fragment == 0:
request = str(ipaddress.IPv4Address(data))
response = self.assignIP(request)
if response not in self.routingtable:
self.routingtable.append(
response) # this should be done after an ACK
frame = Frame(1, 1, fragment + 1, 0, 0,
format(int(ipaddress.IPv4Address(response)), "032b"))
buf = self.fr.bits2bytes(frame.compile())
self.radios[0].write(buf)
elif fragment == 1:
if data is not None: print(data)
self.tun.config(ip=str(ipaddress.IPv4Address(data)),
mask=self.tun.mask)
print("ip updated:", self.tun.ip)
# Room to add an ack part as well
def dividePayload(self, bits):
return [
bits[i:i + Frame.DATA_LENGTH]
for i in range(0, len(bits), Frame.DATA_LENGTH)
]
def sendBits(self, bits):
tx = self.radios[0]
payloads = self.dividePayload(bits)
fragments = ""
for i, b in enumerate(payloads):
final = 1 if i == len(payloads) - 1 else 0
frame = Frame(
0,
final, # final fragment flag
i, # fragment number
int(ipaddress.IPv4Address(self.ip)),
0, # don't know which device I'm on
b)
val = frame.compile()
d = self.fr.data(val)
fragments += d
res = tx.write(self.fr.bits2bytes(frame.compile()))
if not res:
print("Transmission failed")
# print("All fragments:", self.fr.bits2bytes(fragments).hex())
def transmit(self):
print("Transmitting!")
tx = self.radios[0]
tx.stopListening()
while True:
buf = self.tun.read()
if buf.hex()[:2] != "60": # "60" is some kind of OS dump
bits = self.fr.bytes2bits(buf)
self.sendBits(bits)
def handlePayloads(self):
bits = ""
for k in self.payloads.keys():
bits += self.payloads[k]
# print("Accumulated data:", self.fr.bits2bytes(bits).hex())
self.tun.write(self.fr.bits2bytes(bits))
# print("Tun got:", self.fr.bits2bytes(bits).hex())
def receive(self):
print("Receiving!")
rx = self.radios[1]
rx.startListening()
while True:
hasPayload, pipeNo = rx.available_pipe()
if hasPayload:
rcvd = rx.read(rx.payloadSize)
bits = self.fr.bytes2bits(rcvd)
if self.fr.plane(bits) == 0:
f = self.fr.fragment(bits)
self.payloads[f] = self.fr.data(bits)
if self.fr.final(bits):
self.handlePayloads()
elif self.fr.plane(bits) == 1:
self.handshake(self.fr.fragment(bits),
int(self.fr.data(bits), 2))
# Radio 1: Transmitter
# enable CRC checking
rfm9xT.enable_crc = True
rfm9xT.destination = 3 # SAME FOR ALL MOBILE UNITS
rfm9xT.tx_power = 5
rfm9xT.spreading_factor = 10
#rfm9xT.ack_retries = 1
# Radio 2: Receiver NOT WOKRING
# enable CRC checking
rfm9xR.enable_crc = True
rfm9xR.node = 2 # Needs to be changed for all other mobile units
rfm9xR.spreading_factor = 10
iface = 'longGe'
tun = TunTap(nic_type="Tun", nic_name="longGe")
#tun.config(ip="192.168.2.100", mask="255.255.255.0", gateway="192.168.0.1")
tun_ip = ""
ip_set = False
receive_time = 0
sent_time = 0
lock = threading.Lock()
def exit_handler():
tun.close()
def transmit_message(message):
rfm9xT.spreading_factor = 10
rfm9xT.ack_retries = 1
#rfm9xT.signal_bandwidth = 125000
counterT = 0
# Radio 2: Receiver NOT WOKRING
# enable CRC checking
#rfm9xR.enable_crc = True
rfm9xR.node = 2
rfm9xR.destination = 1
rfm9xR.spreading_factor = 10
#rfm9xT.signal_bandwidth = 125000
counterR = 0
iface = 'tun2'
tun = TunTap(nic_type="Tun", nic_name="tun2")
#tun.config(ip="192.168.2.100", mask="255.255.255.0", gateway="192.168.0.1")
tun_ip = ""
ip_set = False
lock = threading.Lock()
def exit_handler():
tun.close()
def transmit_message(message):
print("SENDING: ", message.hex())
rfm9xT.send(message)
rfm9xT.ack_retries = 1
#rfm9xT.signal_bandwidth = 125000
counterT = 0
# Radio 2: Receiver NOT WOKRING
# enable CRC checking
#rfm9xR.enable_crc = True
rfm9xR.node = 2
rfm9xR.destination = 1
rfm9xR.spreading_factor = 10
#rfm9xR.signal_bandwidth = 125000
counterR = 0
iface = 'tun0'
# Createand configurea TUN interface
tun = TunTap(nic_type="Tun", nic_name="tun0")
tun.config(ip="192.168.2.16", mask="255.255.255.0", gateway="192.168.2.15")
# Set up UDP tunnel
RECEIVER_IP = "192.168.0.193" # Should be receiver's IP on the local network
MY_IP = "192.168.0.170" # Should be this node's IP on the local network
UDP_PORT = 4001
tx_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
rx_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
rx_sock.bind((MY_IP, UDP_PORT))
def exit_handler():
tun.close()
class Serial485(Thread):
def __init__(self, serial, rxq, txq, stop, is_master):
Thread.__init__(self)
self.txq = txq
self.rxq = rxq
self.stop = stop
self.master = is_master
self.serial = serial
self.rx_task = Serial485Rx(self.serial, self.rxq, self.stop, self.master, self)
if ENABLE_WIRESHARK and self.master:
from tuntap import TunTap
self.tun = TunTap()
self.tun.open()
self.rx_task.start()
def write_wireshark(self,buffer,to_device=False):
#print buffer
# flags (2) and proto (2)
hdr_tun = [0,0,0,0]
hdr_ip_udp = [
###### IP ######
0x45, # version and header len
0x00, # service type
0x00, 0x00, # total len
0x00, 0x00, # ID
0x40, 0x00, # flags, fragment offset
0x40, # TTL
0x11, # protocol (UDP)
0x00, 0x00, # checksum
0x00, 0x00, 0x00, 0x00, # Source IP
0x00, 0x00, 0x00, 0x00, # Dest IP
###### UDP ######
0x00, 0x00, # Source port
0x00, 0x00, # Dest port
0x00, 0x00, # len (header + data)
0x00, 0x00 # checksum
]
# set total len
hdr_ip_udp[2] = (len(hdr_ip_udp) + len(buffer)) >> 8
hdr_ip_udp[3] = (len(hdr_ip_udp) + len(buffer)) & 0x00ff
# fake IPs (use device node address)
dst = ord(buffer[0])
src = ord(buffer[1])
#print dst,src
hdr_ip_udp[12:16] = [src]*4
hdr_ip_udp[16:20] = [dst]*4
# custom ports
if to_device:
hdr_ip_udp[20] = 0xde
hdr_ip_udp[21] = 0xad
hdr_ip_udp[22] = 0xbe
hdr_ip_udp[23] = 0xef
else:
hdr_ip_udp[20] = 0xbe
hdr_ip_udp[21] = 0xef
hdr_ip_udp[22] = 0xde
hdr_ip_udp[23] = 0xad
# UDP len (udp header + packet len)
hdr_ip_udp[24] = (8 + len(buffer)) >> 8
hdr_ip_udp[25] = (8 + len(buffer)) & 0x00ff
pad = ''
#lb = len(hdr_tun) + len(hdr_ip_udp) + len(buffer)
#if lb % 4 != 0:
# pad = ''*(4 - lb)
msg = ''.join([ chr(x) for x in hdr_tun + hdr_ip_udp ]) + buffer + pad
print(len(msg))
self.tun.write(msg)
def tx(self, buf):
if ENABLE_WIRESHARK and self.master:
self.write_wireshark(buf,True)
n = 0
buf = buf.replace(chr(FRAME_ESC), chr(FRAME_ESC)+chr(FRAME_ESC))
buf = buf.replace(chr(FRAME_FLAG), chr(FRAME_ESC)+chr(FRAME_FLAG))
buf = chr(FRAME_FLAG) + buf + chr(FRAME_FLAG)
while True:
try:
n += self.serial.write(buf[n:])
except Exception, e:
logging.debug('[%s] %s' % (get_func_name(),repr(e)))
raise Exception('serial TX error')
if n >= len(buf):
break
#logging.debug('[%s] sent %d bytes TX (master=%s)' % (get_func_name(),n,self.master))
return n