with parallel send and receive

Makefile

+server:
+	python wifi_server_withpicar.py
+
+
+zip:
+	zip -r server.zip ./server ./server/lib
\ No newline at end of file

README.md

+## CS-437-IOT LAB-2
+
+
+## Build
+
+````
+make zip
+````
+## Copy to Raspberry pi
+
+````
+scp ./server.zip pi@192.168.86.206:
+````
+## Unzip
+
+````
+unzip server.zip -d server
+````
\ No newline at end of file

index.html

@@ -23,7 +23,7 @@
         <source src="samplevid.mp4" type="video/mp4">
           Your browser does not support the video tag.
       </video> -->
-      <img src="./media/default_background.png" id='pics'>
+      <img src="./media/default_background.jpg" width="1000" height="600" id='pics'>
     </div> 
   
   </div>
@@ -59,8 +59,7 @@
         </div>
 
         <div class="jumbotron text-left col-md-6">
-        <input id="message" type="text" placeholder="message to Pi"/>
-        <button class="btn btn-success" onclick="update_data()">Submit</button>
+        <button class="btn btn-success" onclick="register()">Connect</button>
           <p>
             <span id="direction_dot" style="color:Green">&bull;</span> Car Direction: <span id="direction"> </span>
            <br>

index.js

 document.onkeydown = updateKey;
 document.onkeyup = resetKey;
-
+const net = require('net');
 var server_port = 65432;
-var server_addr = "192.168.1.36";   // the IP address of your Raspberry PI
+var server_addr = "192.168.86.206";   // the IP address of your Raspberry PI
+const piClient = net.createConnection({ port: server_port, host: server_addr })
 
+function register(){
+    console.log("to register ", piClient)
+    piClient.on('connect', () => {
+        console.log('connected to pi server!');
+    });
+    // get the data from the server
+    piClient.on('data', (data) => {
+        //document.getElementById("bluetooth").innerHTML = data;
+        document.getElementById("bluetooth").innerHTML = data;
+        
+        console.log(data.toString());
+    
+        // client.end();
+        // client.destroy();
+    });
+
+    piClient.on('end', () => {
+        console.log('disconnected from pi server');
+    });
+}
 function client(value){
     
-    const net = require('net');
+
     var input = document.getElementById("message").value;
 
     const client = net.createConnection({ port: server_port, host: server_addr }, () => {
@@ -24,8 +45,8 @@ function client(value){
         
         console.log(data.toString());
  
-        client.end();
-        client.destroy();
+        // client.end();
+        // client.destroy();
     });
 
     client.on('end', () => {
@@ -78,6 +99,7 @@ function resetKey(e) {
 function update_data(value){
  //   setInterval(function(){
         // get image from python server
-        client(value);
+        //client(value);
+        piClient.write(value);
    // }, 50);
 }

main.js

@@ -18,7 +18,7 @@ function createWindow () {
   mainWindow.loadFile('index.html')
 
   // Open the DevTools.
-  // mainWindow.webContents.openDevTools()
+  mainWindow.webContents.openDevTools()
 }
 
 // This method will be called when Electron has finished

server/lib/i2c.py

+from smbus import SMBus
+import time
+
+class I2C(object):
+    MASTER = 0
+    SLAVE  = 1
+    RETRY = 5
+
+    def __init__(self, *args, **kargs):    
+        self._bus = 1
+        self._smbus = SMBus(self._bus)
+
+    def auto_reset(func):
+        def wrapper(*args, **kw):
+            try:
+                return func(*args, **kw)
+            except OSError:
+                soft_reset()
+                time.sleep(1)
+                return func(*args, **kw)
+        return wrapper
+
+    @auto_reset
+    def _i2c_write_byte(self, addr, data):   
+        # self._debug("_i2c_write_byte: [0x{:02X}] [0x{:02X}]".format(addr, data))
+        return self._smbus.write_byte(addr, data)
+    
+    @auto_reset
+    def _i2c_write_byte_data(self, addr, reg, data):
+        # self._debug("_i2c_write_byte_data: [0x{:02X}] [0x{:02X}] [0x{:02X}]".format(addr, reg, data))
+        return self._smbus.write_byte_data(addr, reg, data)
+    
+    @auto_reset
+    def _i2c_write_word_data(self, addr, reg, data):
+        # self._debug("_i2c_write_word_data: [0x{:02X}] [0x{:02X}] [0x{:04X}]".format(addr, reg, data))
+        return self._smbus.write_word_data(addr, reg, data)
+    
+    @auto_reset
+    def _i2c_write_i2c_block_data(self, addr, reg, data):
+        # self._debug("_i2c_write_i2c_block_data: [0x{:02X}] [0x{:02X}] {}".format(addr, reg, data))
+        return self._smbus.write_i2c_block_data(addr, reg, data)
+    
+    @auto_reset
+    def _i2c_read_byte(self, addr):  
+        # self._debug("_i2c_read_byte: [0x{:02X}]".format(addr))
+        return self._smbus.read_byte(addr)
+
+    @auto_reset
+    def _i2c_read_i2c_block_data(self, addr, reg, num):
+        # self._debug("_i2c_read_i2c_block_data: [0x{:02X}] [0x{:02X}] [{}]".format(addr, reg, num))
+        return self._smbus.read_i2c_block_data(addr, reg, num)
+
+    def is_ready(self, addr):
+        addresses = self.scan()
+        if addr in addresses:
+            return True
+        else:
+            return False
+
+    def scan(self):                            
+        cmd = "i2cdetect -y %s" % self._bus
+        _, output = self.run_command(cmd)          
+        outputs = output.split('\n')[1:]       
+       # self._debug("outputs")
+        addresses = []
+        for tmp_addresses in outputs:
+            tmp_addresses = tmp_addresses.split(':')[1]
+            tmp_addresses = tmp_addresses.strip().split(' ')    
+            for address in tmp_addresses:
+                if address != '--':
+                    addresses.append(address)
+     #   self._debug("Conneceted i2c device: %s"%addresses)                   
+        return addresses
+
+    def send(self, send, addr, timeout=0):                     
+        if isinstance(send, bytearray):
+            data_all = list(send)
+        elif isinstance(send, int):
+            data_all = []
+            d = "{:X}".format(send)
+            d = "{}{}".format("0" if len(d)%2 == 1 else "", d)  
+            # print(d)
+            for i in range(len(d)-2, -1, -2):      
+                tmp = int(d[i:i+2], 16)             
+                # print(tmp)
+                data_all.append(tmp)                
+            data_all.reverse()
+        elif isinstance(send, list):
+            data_all = send
+        else:
+            raise ValueError("send data must be int, list, or bytearray, not {}".format(type(send)))
+
+        if len(data_all) == 1:                      
+            data = data_all[0]
+            self._i2c_write_byte(addr, data)
+        elif len(data_all) == 2:                    
+            reg = data_all[0]
+            data = data_all[1]
+            self._i2c_write_byte_data(addr, reg, data)
+        elif len(data_all) == 3:                    
+            reg = data_all[0]
+            data = (data_all[2] << 8) + data_all[1]
+            self._i2c_write_word_data(addr, reg, data)
+        else:
+            reg = data_all[0]
+            data = list(data_all[1:])
+            self._i2c_write_i2c_block_data(addr, reg, data)
+
+    def recv(self, recv, addr=0x00, timeout=0):     
+        if isinstance(recv, int):                   
+            result = bytearray(recv)
+        elif isinstance(recv, bytearray):
+            result = recv
+        else:
+            return False
+        for i in range(len(result)):
+            result[i] = self._i2c_read_byte(addr)
+        return result
+
+    def mem_write(self, data, addr, memaddr, timeout=5000, addr_size=8): #memaddr match to chn
+        if isinstance(data, bytearray):
+            data_all = list(data)
+        elif isinstance(data, int):
+            data_all = []
+            for i in range(0, 100):
+                d = data >> (8*i) & 0xFF
+                if d == 0:
+                    break
+                else:
+                    data_all.append(d)
+            data_all.reverse()
+        self._i2c_write_i2c_block_data(addr, memaddr, data_all)
+    
+    def mem_read(self, data, addr, memaddr, timeout=5000, addr_size=8):     
+        if isinstance(data, int):
+            num = data
+        elif isinstance(data, bytearray):
+            num = len(data)
+        else:
+            return False
+        result = bytearray(num)
+        result = self._i2c_read_i2c_block_data(addr, memaddr, num)
+        return result
+
+    def test():
+        a_list = [0x2d,0x64,0x0]
+        b = I2C()
+        b.send(a_list,0x14)
+
+def soft_reset():
+    from lib.pin import Pin
+    soft_reset_pin = Pin("D16")
+    # print('soft_reset')
+    soft_reset_pin.low()
+    time.sleep(0.001)
+    soft_reset_pin.high()
+    time.sleep(0.001)

server/lib/motor.py

+import threading
+
+class Motor():
+    STEP = 10
+    DELAY = 0.1
+    def __init__(self, pwm_pin, dir_pin, is_reversed=False):
+        self.pwm_pin = pwm_pin
+        self.dir_pin = dir_pin
+        self._is_reversed = is_reversed
+        self._power = 0
+        self._except_power = 0
+    
+    # def start_timer(self):
+    #     self.t = threading.Timer(self.DELAY, self.adder_thread)
+    #     self.t.start()
+
+    def set_power(self, power):
+        if power >= 0:
+            direction = 0
+        elif power < 0:
+            direction = 1
+        power = abs(power)
+        if power != 0:
+            power = int(power /2 ) + 50
+        power = power
+
+        direction = direction if not self._is_reversed else not direction  
+        self.dir_pin.value(direction)
+            
+        self.pwm_pin.pulse_width_percent(power)
+
+#     def adder_thread(self):
+#         if self._except_power > self._power:
+#             step = self.STEP
+#         else:
+#             step = -self.STEP
+#         if abs(self._except_power - self._power) < self.STEP:
+#             self._power = self._except_power
+#         else:
+#             self._power += step
+#         self._set_power(self._power)
+#         if self._power != self._except_power:
+#             self.start_timer()
+
+#     def set_power(self, power):
+#         # print("Power: {}".format(power))
+#         self._except_power = power
+#         if self._power != self._except_power:
+#             self.start_timer()
+
+# if __name__ == "__main__":
+#     import picar-4wd as fc
+#     import time
+#     fc.forward(100)
+#     time.sleep(1)

server/lib/pin.py

+import RPi.GPIO as GPIO
+
+class Pin(object):
+    OUT = GPIO.OUT                  
+    IN = GPIO.IN                   
+    IRQ_FALLING = GPIO.FALLING      
+    IRQ_RISING = GPIO.RISING        
+    IRQ_RISING_FALLING = GPIO.BOTH  
+    PULL_UP = GPIO.PUD_UP           
+    PULL_DOWN = GPIO.PUD_DOWN       
+    PULL_NONE = None                
+    _dict = {                       
+        "D0":  17,
+        "D1":  18,
+        "D2":  27,
+        "D3":  22,
+        "D4":  23,
+        "D5":  24,
+        "D6":  25,
+        "D7":  4,
+        "D8":  5,
+        "D9":  6,
+        "D10": 12,
+        "D11": 13,
+        "D12": 19,
+        "D13": 16,
+        "D14": 26,
+        "D15": 20,
+        "D16": 21,
+        "SW":  19,
+        "LED": 26,
+    }
+
+    def __init__(self, *value):
+        super().__init__()          
+        GPIO.setmode(GPIO.BCM)      
+        GPIO.setwarnings(False)     
+        if len(value) > 0:          
+            pin = value[0]
+        if len(value) > 1:          
+            mode = value[1]
+        else:
+            mode = None
+        if len(value) > 2:          
+            setup = value[2]
+        else:
+            setup = None
+        if isinstance(pin, str):    
+            try:
+                self._bname = pin
+                self._pin = self.dict()[pin]
+            except Exception as e:
+                print(e)
+                self._error('Pin should be in %s, not %s' % (self._dict, pin))
+        elif isinstance(pin, int):  
+            self._pin = pin
+        else:
+            self._error('Pin should be in %s, not %s' % (self._dict, pin))
+        self._value = 0
+        self.init(mode, pull=setup)
+    #    self._info("Pin init finished.")
+        
+    def init(self, mode, pull=PULL_NONE):   
+        self._pull = pull
+        self._mode = mode
+        if mode != None:
+            if pull != None:
+                GPIO.setup(self._pin, mode, pull_up_down=pull)
+            else:
+                GPIO.setup(self._pin, mode)
+
+    def dict(self, *_dict):                 
+        if len(_dict) == 0:                 
+            return self._dict
+        else:
+            if isinstance(_dict, dict):
+                self._dict = _dict
+            else:
+                self._error(
+                    'argument should be a pin dictionary like {"my pin": ezblock.Pin.cpu.GPIO17}, not %s' % _dict)
+
+    def __call__(self, value):
+        return self.value(value)
+
+    def value(self, *value):                 
+        if len(value) == 0:
+            self.mode(self.IN)
+            result = GPIO.input(self._pin)
+        #    self._debug("read pin %s: %s" % (self._pin, result))
+            return result
+        else:                               
+            value = value[0]
+            self.mode(self.OUT)
+            GPIO.output(self._pin, value)
+            return value
+
+    def on(self):                           
+        return self.value(1)
+
+    def off(self):                          
+        return self.value(0)
+
+    def high(self):                        
+        return self.on()
+
+    def low(self):                          
+        return self.off()
+
+    def mode(self, *value):                 
+        if len(value) == 0:
+            return self._mode
+        else:
+            mode = value[0]
+            self._mode = mode
+            GPIO.setup(self._pin, mode)
+
+    def pull(self, *value):     
+        return self._pull
+
+    def irq(self, handler=None, trigger=None):      
+        self.mode(self.IN)
+        GPIO.add_event_detect(self._pin, trigger, callback=handler)
+
+    def name(self):                                 
+        return "GPIO%s"%self._pin
+
+    def names(self):
+        return [self.name, self._bname]
+
+    class cpu(object):
+        GPIO17 = 17
+        GPIO18 = 18
+        GPIO27 = 27
+        GPIO22 = 22
+        GPIO23 = 23
+        GPIO24 = 24
+        GPIO25 = 25
+        GPIO26 = 26
+        GPIO4  = 4
+        GPIO5  = 5
+        GPIO6  = 6
+        GPIO12 = 12
+        GPIO13 = 13
+        GPIO19 = 19
+        GPIO16 = 16
+        GPIO26 = 26
+        GPIO20 = 20
+        GPIO21 = 21
+
+        def __init__(self):
+            pass

server/lib/pwm.py

+import smbus, math
+from lib.pin import Pin
+from lib.i2c import I2C
+import time
+
+class PWM(I2C):
+    REG_CHN = 0x20
+    REG_FRE = 0x30
+    REG_PSC = 0x40
+    REG_ARR = 0x44
+    ADDR = 0x14
+    CLOCK = 72000000
+
+    def __init__(self, channel):
+        super().__init__()
+        if isinstance(channel, str):
+            if channel.startswith("P"):
+                channel = int(channel[1:])
+            else:
+                raise ValueError("PWM channel should be between [P1, P14], not {0}".format(channel))
+        try:
+            self.send(0x2C, self.ADDR)
+            self.send(0, self.ADDR)
+            self.send(0, self.ADDR)
+        except IOError:
+            self.ADDR = 0x15
+
+      #  self.debug = debug
+      #  self._debug("PWM address: {:02X}".format(self.ADDR))
+        self.channel = channel
+        self.timer = int(channel/4)
+        self.bus = smbus.SMBus(1)
+        self._pulse_width = 0
+        self._freq = 50
+        self.freq(50)
+
+    def i2c_write(self, reg, value):
+        value_h = value >> 8
+        value_l = value & 0xff
+    #   self._debug("i2c write: [0x%02X, 0x%02X, 0x%02X, 0x%02X]"%(self.ADDR, reg, value_h, value_l))
+        self.send([reg, value_h, value_l], self.ADDR)
+
+    def freq(self, *freq):
+        if len(freq) == 0:
+            return self._freq
+        else:
+            self._freq = int(freq[0])
+            # [prescaler,arr] list
+            result_ap = []
+            # accuracy list
+            result_acy = []
+            # middle value for equal arr prescaler
+            st = int(math.sqrt(self.CLOCK/self._freq))
+            # get -5 value as start
+            st -= 5
+            # prevent negetive value
+            if st <= 0:
+                st = 1
+            for psc in range(st,st+10):
+                arr = int(self.CLOCK/self._freq/psc)
+                result_ap.append([psc, arr])
+                result_acy.append(abs(self._freq-self.CLOCK/psc/arr))
+            i = result_acy.index(min(result_acy))
+            psc = result_ap[i][0]
+            arr = result_ap[i][1]
+        #   self._debug("prescaler: %s, period: %s"%(psc, arr))
+            self.prescaler(psc)
+            self.period(arr)
+
+    def prescaler(self, *prescaler):
+        if len(prescaler) == 0:
+            return self._prescaler
+        else:
+            self._prescaler = int(prescaler[0]) - 1
+            reg = self.REG_PSC + self.timer
+        #    self._debug("Set prescaler to: %s"%self._prescaler)
+            self.i2c_write(reg, self._prescaler)
+
+    def period(self, *arr):
+        if len(arr) == 0:
+            return self._arr
+        else:
+            self._arr = int(arr[0]) - 1
+            reg = self.REG_ARR + self.timer
+        #    self._debug("Set arr to: %s"%self._arr)
+            self.i2c_write(reg, self._arr)
+
+    def pulse_width(self, *pulse_width):
+        if len(pulse_width) == 0:
+            return self._pulse_width
+        else:
+            self._pulse_width = int(pulse_width[0])
+            reg = self.REG_CHN + self.channel
+            # CCR = int(self._pulse_width/self.PRECISION * self._arr)
+            # print("CCR: %s"%CCR)
+            self.i2c_write(reg, self._pulse_width)
+
+    def pulse_width_percent(self, *pulse_width_percent):
+        if len(pulse_width_percent) == 0:
+            return self._pulse_width_percent
+        else:
+            self._pulse_width_percent = pulse_width_percent[0] / 100.0
+            pulse_width = self._pulse_width_percent * self._arr
+            self.pulse_width(pulse_width)
+
+        
+def test():
+    import time
+    p = PWM('P12')
+    # p.debug = 'debug'
+    p.period(1000)
+    p.prescaler(10)
+    # p.pulse_width(2048)
+    while True:
+        for i in range(0, 4095, 10):
+            p.pulse_width(i)
+            print(i)
+            time.sleep(1/4095)
+        time.sleep(1)
+        for i in range(4095, 0, -10):
+            p.pulse_width(i)
+            print(i)
+            time.sleep(1/4095)
+        time.sleep(1)
+
+if __name__ == '__main__':
+    test()
\ No newline at end of file

server/temp_monitor.py

+import os
+import time
+
+def measure_temp():
+        temp = os.popen("vcgencmd measure_temp").readline()
+        print(temp)
+        return (temp.replace("temp=",""))
\ No newline at end of file

wifi_server_withpicar.py → server/wifi_server_withpicar.py

 
+from time import sleep
 import socket
 
-HOST = "192.168.1.36" # IP address of your Raspberry PI
+from temp_monitor import measure_temp
+
+
+
+HOST = "192.168.86.206" # IP address of your Raspberry PI
 PORT = 65432  
-from pickle import FALSE
-from random import randrange
-import time
+
+from concurrent.futures import thread
+import threading
 from lib.motor import Motor
-from lib.servo import Servo
-from lib.ultrasonic import Ultrasonic 
 from lib.pwm import PWM
 from lib.pin import Pin
-#import picar
-speed = 0
-direction = ""
+import json
+import traceback
+import time
+
 fwd_speed = 30
 bwd_speed = 15
 turn_speed = 10
-ultrasonic_servo_offset = 0 
-
-ANGLE_RANGE = 180
-STEP = 18
-us_step = STEP
-angle_distance = [0,0]
-current_angle = 0
-max_angle = ANGLE_RANGE/2
-min_angle = -ANGLE_RANGE/2
-scan_list = []
-
-# Init Ultrasonic
-us = Ultrasonic(Pin('D8'), Pin('D9'))
-
-# Init Servo
-servo = Servo(PWM("P0"), offset=ultrasonic_servo_offset)
 
 # Init motors
 left_front = Motor(PWM("P13"), Pin("D4"), is_reversed=False) # motor 1
@@ -87,36 +75,71 @@ def drive(data):
         if data == b"F":
             print("forward")
             forward(fwd_speed)
+            time.sleep(0.1)
+            stop()
         elif data == b"D":
             print("backward")
             backward(bwd_speed)
+            time.sleep(0.1)
+            stop()
         elif data == b"L":
             print("left")
             turn_left(turn_speed)
+            time.sleep(0.1)
+            stop()
         elif data == b"R":
             print("right")
             turn_right(turn_speed)
+            time.sleep(0.1)
+            stop()
         elif data == b"S":
             print("stop")
-            forward(0)
+            stop()
+            time.sleep(0.1)
+def destroy():
+    print("Interrupted")
 
         # Port to listen on (non-privileged ports are > 1023)
-
-with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-    s.bind((HOST, PORT))
-    s.listen()
-
+def main():
+    global squareGrid
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind((HOST, PORT))
+        s.listen()
+        client, clientInfo = s.accept()
+        print("server recv from: ", clientInfo)
+
+        background_thread = threading.Thread(target=receive_and_print, args=(client, ))
+        background_thread.daemon = True
+        background_thread.start()
+
+        try:
+            while 1: 
+                time.sleep(2)
+                data = {}
+                data['temp'] = measure_temp() 
+                jsonString  = json.dumps(data)
+                client.sendall(jsonString.encode('utf-8')) # Echo back to client
+                
+        except Exception as e:
+            print(e)
+            print(traceback.format_exc())
+            print("Closing socket")
+            client.close()
+            s.close()    
+
+def receive_and_print(client):
+    while 1:
+        print("in loop")
+        data = client.recv(1024)      # receive 1024 Bytes of message in binary format
+        print(data)
+        if data != b"":
+            drive(data) 
+
+if __name__ == '__main__':
     try:
-        while 1:
-            client, clientInfo = s.accept()
-            print("server recv from: ", clientInfo)
-            data = client.recv(1024)      # receive 1024 Bytes of message in binary format
-            print(data)
-            if data != b"":
-                drive(data)                
-                client.sendall(data) # Echo back to client
-    except: 
-        print("Closing socket")
-        client.close()
-        s.close()    
+        main()
+    except KeyboardInterrupt:
+        destroy()
+