def summary():
	trace("SUMMARY:",log_trace)
	trace("Errors  : " + str(s_error),log_trace)

	if s_error==0:
		trace("Result  : No errors occurred.",log_trace)
	else:
		trace("Self Test FAILED",log_trace)


	if online==1:
		print "Saving results on remote server"
		url = 'http://plm.fabtotum.com/reports/add_report.php'
		files = {'file': open(log_trace, 'rb')}
		info={'ID':controller_serial_id, 'result':s_error}
		try:
			r = requests.post(url,info, files=files)
			trace("Self Test results saved online",log_trace)
		except:
			#print "Response: " + r.text
			trace("Could not contact remote support server, is Internet connectivity available?",log_trace)
	if s_error>0:
		#clean the buffer and leave
		#shutdown temps
		
		serial.write("M104 S0\r\n") #shutdown extruder (fast)
		serial.write("M140 S0\r\n") #shudown bed (fast)
		serial.flush()
		serial.close()
		write_json('1', status_json)
		call (['sudo php /var/www/fabui/script/finalize.php '+str(task_id)+" self_test"], shell=True)

		sys.exit()

def write_packet(i, val):
    i = int(i)
    val = int(val)

    msb = (int(val) & 0xFF00) >> 8
    lsb = int(val) & 0xFF

    p = bytearray([i, msb, lsb])
    serial.write(p)
    serial.flush()

def write_packet(i, val):
    i = int(i)
    val = int(val)
    print ("SENDING {} {}".format(i, val))

    msb = (int(val) & 0xFF00) >> 8
    lsb = int(val) & 0xFF

    p = bytearray([i, msb, lsb])
    serial.write(p)
    serial.flush()

def initSerial(port, baudrate):
    serial.port = port
    serial.baudrate = baudrate
    serial.timeout = 1
    serial.writeTimeout = 1
    serial.open()
    serial.flush()
 
    logd( 'Opening port %s - %s' %(port, baudrate) )
    if serial.isOpen(): 
        logd('Success')
    else:
        logd('Failed')
        exit(2)

    def put(self, address, type, value):

        with self.__lock:

            result = None
            while result is None:
                serial = self.serial()

                try:
                    serial.write([address, 0, type, int(value)])
                    serial.flush()

                    result = True

                except Exception as e:
                    print e
                    self.__clean()

    def get(self, address, type):
        with self.__lock:

            result = None
            while result is None:
                serial = self.serial()

                try:
                    print type
                    serial.write([address, 1, type])
                    serial.flush()

                    result = struct.unpack('B', serial.read(1))[0]
                except Exception as e:
                    print e
                    self.__clean()

        return result

def tagRead():
    import serial
    try:
        serial= serial.Serial("/dev/ttyACM0", baudrate=9600)
        n=0
        serial.flushInput()
        serial.flushOutput()
        while True:
        	data=serial.readline()
                n=n+1
                if data[0:3]=="ISO" and n>3:
                    myString1=data.find('[')+1
                    myString2=data.find(',')
                    serial.flush()
                    serial.close()
                    return data[myString1:myString2]
    except Exception as e:
        return 0

def getDistanceArray():

    # flush the buffer
    serial.flush()

    # This constant will request the values for all of the sensors
    sensorValsArray = []

    # Write that value to the Arduinos serial monitor
    amountOfSensors = 5

    # set inital value of i to the first sensor
    i = 1

    # set inital value of sensor val to 1 so the while loop is entered
    sensorVal = 1

    # while loop that asks for sensor values sequentially, converts them to an integer and adds them to an array
    while(sensorVal > -1):

        # ask for the sensor value from the arduino
        serial.write(str.encode(str(i)))

        # read the sensor value, conert it to an integer and store it in the temp variable
        sensorVal = int(serial.readline())

        # if the sensor was actually there store the value in the array
        if(sensorVal > -1):
            sensorValsArray.append(sensorVal)

        # delay
        time.sleep(0.01)

        # increment i to check for next sensor
        i += 1



    return sensorValsArray

def writeToTape(serial, array, maxvalue):
    print("Writing")
    print(array)
    data = ""
    if array[0] > 1e1:
        for x in array:
            towrite = [0, 0, 0]               #rgb
            towrite[0] = x
            towrite[1] = 60
            towrite[2] = 254 - x
                
            for x in towrite:
                capped = int(min(254,max(0,x)))
                data += chr(capped)
    else:
#        cleartape(serial)
        return

    # write control
    serial.write(data)
    serial.write(CONTROL)
    serial.flushInput()
    serial.flush()

udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_socket.bind(udp_server_address)
if BROADCAST_MODE:
        udp_socket.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST,1)

slip_processor=slip.slip()

while True:
        (rlist, wlist, xlist) = select.select([udp_socket,serial], [], [])
        if serial in rlist:
                serial_data = serial.read(1)
                slip_processor.append(serial_data)
                slip_packets=slip_processor.decode()
                for packet in slip_packets:
                        if BROADCAST_MODE:
                                udp_socket.sendto(packet,udp_broadcast)
                        else:
                                udp_socket.sendto(packet,udp_client_address)

        if udp_socket in rlist:
                udp_data,udp_client = udp_socket.recvfrom(MAX_UDP_PACKET)
                slip_data=slip_processor.encode(udp_data)
                serial.write(slip_data)
                serial.flush()
                udp_client_address=(udp_client[0],UDP_PORT_OUT)
                time.sleep(0.001) #avoid flooding the microcontroller (to be controlled)

def snd_bytearray_uart(msg):
    global serial
    byte = serial.write(msg)
    serial.flush()
    return byte