# main.py -- put your code here!

#Import relevant modules

import network

import pyb

import utime

import machine

import micropython

import usocket as socket

from machine import Pin

from pyb import ExtInt

from pyb import USB_VCP

from pyb import I2C

from pyb import ADC

from pyb import DAC

from pyb import LED

from array import array

micropython.alloc_emergency_exception_buf(100) # For interrupt debugging

#==================================================================================#

# SETUP

#==================================================================================#

# OBJECT DEFINITIONS

led = LED(1) # define diagnostic LED

#usb = USB_VCP() # init VCP object, NOT IN USE

i2c = I2C(1, I2C.MASTER,

baudrate=400000) # define I2C channel, master/slave protocol and baudrate needed

ti = pyb.Timer(2,freq=1000000) # init timer for interrupts

# PIN SETUP AND INITIAL POLARITY/INTERRUPT MODE

Pin('PULL_SCL', Pin.OUT, value=1) # enable 5.6kOhm X9/SCL pull-up

Pin('PULL_SDA', Pin.OUT, value=1) # enable 5.6kOhm X10/SDA pull-up

adcpin = Pin("X12")

adc = ADC(adcpin, "SingleDMA") # define ADC pin for pulse stretcher measurement

calibpin = Pin("X3") # ADC pin for calibration

calibadc = 0

pin_mode = Pin('X8', Pin.OUT) # define pulse clearing mode pin

pin_mode.value(1) # low -> automatic pulse clearing, high -> manual pulse clear

clearpin = Pin('X7',Pin.OUT) # choose pin used for manually clearing the pulse once ADC measurement is complete

polarpin = Pin('X6', Pin.OUT) # define pin that chooses polarity

testpulsepin = Pin('X4',Pin.OUT) # pin to enable internal test pulses on APIC

polarpin.value(0) # set to 1 for positive polarity

# DATA STORAGE AND COUNTERS

sendbuf = array('H',[720]) # 1440 byte buffer for calibration routine

data = array('H',[0]*4) # buffer for writing adc interrupt data from adc.read_timed() in calibration() and ADC_IT_poll()

calibdata = array('H',[0]*4) # buffer to store ADC data from calibadc

count=0 # counter for pulses read

peakcount = 0

ratecounter = 0 # counter for rate measurements

STATE = "STARTUP" # state variable for applying startup settings etc.

ADC_STATE = "SingleDMA" # monitor state of ADC configs

# SET UP WIRELESS ACCESS POINT

wl_ap = network.WLAN(1) # init wlan object

wl_ap.config(essid='PYBD') # set AP SSID

wl_ap.config(channel=1) # set AP channel

wl_ap.active(1) # enable the AP

# LOOP UNTIL A CONNECTION IS RECEIVED

while wl_ap.status('stations')==[]:

utime.sleep(1)

# SET UP THE NETWORK SOCKET FOR UDP

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

s.bind(('',8080)) # network listens on port 8080, any IP

destipv4 = ('192.168.4.16', 8080) # destination for sending data

print("SOCKET BOUND")

#==================================================================================#

# BOARD STATE CHECKING

#==================================================================================#

def checkstate():

a = STATE.encode('utf-8')

s.sendto(a, destipv4)

def adc_setstate(state):

print("ADC STATE UNCHANGED")

def setstate():

utime.sleep(0.1)

STATE = s.recv(32).decode('utf-8')

def drain_socket():

s.settimeout(None)

#==================================================================================#

# I2C CONTROL

# Ir, read both I2C chips and send via socket.

# Iw, write 8 bit val to an I2C pot.

# Is, scan for the I2C addresses on the pulse stretcher.

# If the I2C chips are not connected, an exception will be raised.

#==================================================================================#

def Ir():

return None

def Iw(address):

return None

def Is():

return None

#==================================================================================#

# CALIBRATION CURVE CODE FIXME: Find a way to measure this properly

#==================================================================================#

def calibrate():

calibint.disable()

def cbcal(line):

count = 0

#==================================================================================#

# RATE MEASUREMENT CODE

#==================================================================================#

def rateaq():

s.sendto(finalratebyte,destipv4)

def ratecount(line):

clearpin.value(0)

#==================================================================================#

# ADC INTERRUPT MEASUREMENT CODE:

# Python level legacy function, interrupt to take and send data

# samples mnum peaks, uses schedule to delay measurements for

# concurrent interrupts.

#==================================================================================#

"""

def ADC_IT_poll():

global extint

global count

count = 0

utime.sleep(0.5)

msg, addr = s.recvfrom(8)

mnum = int.from_bytes(msg,'little')

mnum=mnum*1.2

adc_setstate("Single")

utime.sleep(1)

extint.enable()

while count < mnum:

pass

extint.disable()

print("MEASUREMENT COMPLETE")

drain_socket()

# ISR CALLBACK FUNCTION

def callback(arg):

extint.disable()

global count # reference the global count counter

adc.read_timed(data,ti) # 4 microsecond measurement from ADC at X12,

pos = (4*count)%500

if pos == 124:

sendbuf[pos:pos+4] = data

try:

s.sendto(sendbuf, destipv4)

except:

print("SEND FAILED")

else:

sendbuf[pos:pos+4] = data

count+=1 # pulse counter

extint.enable() # re-enable interrupts

# TEMP FIX FOR ISR OVERFLOW

# Uses micropython.schedule to delay interrupts

# that occur during ISR callback - interrupting usocket transfer is v. bad.

def cb(line):

micropython.schedule(callback,'a')

"""

# ENABLE GPIO INTERRUPTs

irqstate=pyb.disable_irq() # disable all interrupts during initialisation

rateint = ExtInt('X1', ExtInt.IRQ_RISING,

pyb.Pin.PULL_NONE, rateaq) # rate measurement interrupts on pin X1

rateint.disable()

calibint = ExtInt('X2',ExtInt.IRQ_RISING,

pyb.Pin.PULL_NONE,cbcal) # interrupts for ADC pulse DAQ on pin X2

calibint.disable()

pyb.enable_irq(irqstate) # re-enable interrupts

#==================================================================================#

# C ADC data stream method

# Wait for this to complete before attempting any other actions.

# Uses a different ADC setup from python level ADC_IT_poll.

#==================================================================================#

def read_DMA():

adc.read_dma(mnum)

#==================================================================================#

# COMMAND CODES:

# Bytearrays used by main loop to execute functions

# expect a 2-byte command.

#==================================================================================#

commands = {

}

#==================================================================================#

# MAIN LOOP

#==================================================================================#

while True:

mode = s.recv(2) # wait until the board receives the 2 byte command code, no timeout

print("MODE RECEIVED")

commands[mode]() # reference commands dictionary and run the corresponding function