cc3200: New irq API, affects all classes that provide the irq method.

8 files changed, 445 insertions, 3 deletions

diff --git a/tests/wipy/pin_irq.py b/tests/wipy/pin_irq.py
new file mode 100644
index 0000000000..75a7f090d8
--- /dev/null
+++ b/tests/wipy/pin_irq.py
@@ -0,0 +1,116 @@
+'''
+Pin IRQ test for the CC3200 based boards.
+'''
+
+from pyb import Pin
+from pyb import Sleep
+import os
+import time
+
+machine = os.uname().machine
+if 'LaunchPad' in machine:
+    pins = ['GP16', 'GP13']
+elif 'WiPy' in machine:
+    pins = ['GP16', 'GP13']
+else:
+    raise Exception('Board not supported!')
+
+pin0 = Pin(pins[0], mode=Pin.OUT, value=1)
+pin1 = Pin(pins[1], mode=Pin.IN, pull=Pin.PULL_UP)
+
+def pin_handler (pin_o):
+    global pin_irq_count_trigger
+    global pin_irq_count_total
+    global _trigger
+    if _trigger & pin1_irq.flags():
+        pin_irq_count_trigger += 1
+    pin_irq_count_total += 1
+
+pin_irq_count_trigger = 0
+pin_irq_count_total = 0
+_trigger = Pin.IRQ_FALLING
+pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
+for i in range (0, 10):
+    pin0.toggle()
+    time.sleep_ms(5)
+print(pin_irq_count_trigger == 5)
+print(pin_irq_count_total == 5)
+
+pin_irq_count_trigger = 0
+pin_irq_count_total = 0
+_trigger = Pin.IRQ_RISING
+pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
+for i in range (0, 200):
+    pin0.toggle()
+    time.sleep_ms(5)
+print(pin_irq_count_trigger == 100)
+print(pin_irq_count_total == 100)
+
+pin1_irq.disable()
+pin0(1)
+pin_irq_count_trigger = 0
+pin_irq_count_total = 0
+_trigger = Pin.IRQ_FALLING
+pin1_irq.init(trigger=_trigger, handler=pin_handler)
+pin0(0)
+time.sleep_us(50)
+print(pin_irq_count_trigger == 1)
+print(pin_irq_count_total == 1)
+pin0(1)
+time.sleep_us(50)
+print(pin_irq_count_trigger == 1)
+print(pin_irq_count_total == 1)
+
+# check the call method
+pin1_irq()
+print(pin_irq_count_trigger == 1)  # no flags since the irq was manually triggered
+print(pin_irq_count_total == 2)
+
+pin1_irq.disable()
+pin_irq_count_trigger = 0
+pin_irq_count_total = 0
+for i in range (0, 10):
+    pin0.toggle()
+    time.sleep_ms(5)
+print(pin_irq_count_trigger == 0)
+print(pin_irq_count_total == 0)
+
+# test waking up from suspended mode on low level
+pin0(0)
+t0 = time.ticks_ms()
+pin1_irq.init(trigger=Pin.IRQ_LOW_LEVEL, wake=Sleep.SUSPENDED)
+Sleep.suspend()
+print(time.ticks_ms() - t0 < 10)
+print('Awake')
+
+# test waking up from suspended mode on high level
+pin0(1)
+t0 = time.ticks_ms()
+pin1_irq.init(trigger=Pin.IRQ_HIGH_LEVEL, wake=Sleep.SUSPENDED)
+Sleep.suspend()
+print(time.ticks_ms() - t0 < 10)
+print('Awake')
+
+# check for memory leaks
+for i in range(0, 1000):
+    pin0_irq = pin0.irq(trigger=_trigger, handler=pin_handler)
+    pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
+
+# next ones must raise
+try:
+    pin1_irq.init(trigger=123456, handler=pin_handler)
+except:
+    print('Exception')
+
+try:
+    pin1_irq.init(trigger=Pin.IRQ_LOW_LEVEL, wake=1789456)
+except:
+    print('Exception')
+
+try:
+    pin0_irq = pin0.irq(trigger=Pin.IRQ_RISING, wake=Sleep.SUSPENDED)  # GP16 can't wake up from DEEPSLEEP
+except:
+    print('Exception')
+
+pin0_irq.disable()
+pin1_irq.disable()
diff --git a/tests/wipy/pin_irq.py.exp b/tests/wipy/pin_irq.py.exp
new file mode 100644
index 0000000000..458bd95668
--- /dev/null
+++ b/tests/wipy/pin_irq.py.exp
@@ -0,0 +1,19 @@
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+Awake
+True
+Awake
+Exception
+Exception
+Exception
diff --git a/tests/wipy/rtc.py b/tests/wipy/rtc.py
index 4114796db1..9f4a0f673e 100644
--- a/tests/wipy/rtc.py
+++ b/tests/wipy/rtc.py
@@ -66,17 +66,22 @@ rtc.alarm(0, 5000)
 rtc.alarm(time=2000)
 time.sleep_ms(1000)
 left = rtc.alarm_left()
-print(abs(left-1000) < 20)
+print(abs(left-1000) <= 10)
 time.sleep_ms(1000)
 print(rtc.alarm_left() == 0)
 time.sleep_ms(100)
-print(rtc.alarm_left() == 0)
+print(rtc.alarm_left(0) == 0)
+
+rtc.alarm(time=1000, repeat=True)
+time.sleep_ms(1500)
+left = rtc.alarm_left()
+print(abs(left-500) <= 15)
 
 rtc.init((2015, 8, 29, 9, 0, 0, 0, None))
 rtc.alarm(time=(2015, 8, 29, 9, 0, 45))
 time.sleep_ms(1000)
 left = rtc.alarm_left()
-print(abs(left-44000) < 100)
+print(abs(left-44000) <= 90)
 
 # next ones must raise
 try:
@@ -85,6 +90,16 @@ except:
     print('Exception')
 
 try:
+    rtc.alarm_left(1)
+except:
+    print('Exception')
+
+try:
+    rtc.alarm_cancel(1)
+except:
+    print('Exception')
+
+try:
     rtc.alarm(5000)
 except:
     print('Exception')
diff --git a/tests/wipy/rtc.py.exp b/tests/wipy/rtc.py.exp
index 8225f4602f..44f8f8b81c 100644
--- a/tests/wipy/rtc.py.exp
+++ b/tests/wipy/rtc.py.exp
@@ -28,6 +28,9 @@ True
 True
 True
 True
+True
+Exception
+Exception
 Exception
 Exception
 Exception
diff --git a/tests/wipy/rtc_irq.py b/tests/wipy/rtc_irq.py
new file mode 100644
index 0000000000..1c9ea93f1d
--- /dev/null
+++ b/tests/wipy/rtc_irq.py
@@ -0,0 +1,89 @@
+'''
+RTC IRQ test for the CC3200 based boards.
+'''
+
+from pyb import RTC
+from pyb import Sleep
+import os
+import time
+
+machine = os.uname().machine
+if not 'LaunchPad' in machine and not 'WiPy' in machine:
+    raise Exception('Board not supported!')
+
+def rtc_ticks_ms(rtc):
+    timedate = rtc.now()
+    return (timedate[5] * 1000) + (timedate[6] // 1000)
+
+rtc_irq_count = 0
+
+def alarm_handler (rtc_o):
+    global rtc_irq
+    global rtc_irq_count
+    if rtc_irq.flags() & RTC.ALARM0:
+        rtc_irq_count += 1
+
+rtc = RTC()
+rtc.alarm(time=500, repeat=True)
+rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler)
+
+# active mode
+time.sleep_ms(1000)
+rtc.alarm_cancel()
+print(rtc_irq_count == 2)
+rtc_irq_count = 0
+rtc.alarm(time=200, repeat=True)
+time.sleep_ms(1000)
+rtc.alarm_cancel()
+print(rtc_irq_count == 5)
+
+rtc_irq_count = 0
+rtc.alarm(time=100, repeat=True)
+time.sleep_ms(1000)
+rtc.alarm_cancel()
+print(rtc_irq_count == 10)
+
+# deep sleep mode
+rtc.alarm_cancel()
+rtc_irq_count = 0
+rtc.alarm(time=50, repeat=True)
+rtc_irq.init(trigger=RTC.ALARM0, handler=alarm_handler, wake=Sleep.SUSPENDED | Sleep.ACTIVE)
+while rtc_irq_count < 3:
+    Sleep.suspend()
+print(rtc_irq_count == 3)
+
+# no repetition
+rtc.alarm_cancel()
+rtc_irq_count = 0
+rtc.alarm(time=100, repeat=False)
+time.sleep_ms(250)
+print(rtc_irq_count == 1)
+
+rtc.alarm_cancel()
+t0 = rtc_ticks_ms(rtc)
+rtc.alarm(time=500, repeat=False)
+Sleep.suspend()
+t1 = rtc_ticks_ms(rtc)
+print(abs(t1 - t0 - 500) < 20)
+
+# deep sleep repeated mode
+rtc.alarm_cancel()
+rtc_irq_count = 0
+rtc.alarm(time=250, repeat=True)
+t0 = rtc_ticks_ms(rtc)
+rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler, wake=Sleep.SUSPENDED)
+while rtc_irq_count < 10:
+    Sleep.suspend()
+    t1 = rtc_ticks_ms(rtc)
+    print(abs(t1 - t0 - (250 * rtc_irq_count)) < 25) 
+
+# next ones must raise
+try:
+    rtc_irq = rtc.irq(trigger=10, handler=alarm_handler)
+except:
+    print('Exception')
+
+try:
+    rtc_irq = rtc.irq(trigger=RTC.ALARM0, wake=1789456)
+except:
+    print('Exception')
diff --git a/tests/wipy/rtc_irq.py.exp b/tests/wipy/rtc_irq.py.exp
new file mode 100644
index 0000000000..a9ef48c7a7
--- /dev/null
+++ b/tests/wipy/rtc_irq.py.exp
@@ -0,0 +1,18 @@
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+Exception
+Exception
diff --git a/tests/wipy/uart_irq.py b/tests/wipy/uart_irq.py
new file mode 100644
index 0000000000..3f1084cce3
--- /dev/null
+++ b/tests/wipy/uart_irq.py
@@ -0,0 +1,149 @@
+'''
+UART IRQ test for the CC3200 based boards.
+'''
+
+from pyb import UART
+import os
+import pyb
+import time
+
+machine = os.uname().machine
+if 'LaunchPad' in machine:
+    uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
+elif 'WiPy' in machine:
+    uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
+else:
+    raise Exception('Board not supported!')
+
+# just in case we have stdio duplicated on any of the uarts
+pyb.repl_uart(None)
+
+uart0 = UART(0, 1000000, pins=uart_pins[0][0])
+uart1 = UART(1, 1000000, pins=uart_pins[1][0])
+
+uart0_int_count = 0
+uart1_int_count = 0
+
+def uart0_handler (uart_o):
+    global uart0_irq
+    global uart0_int_count
+    if (uart0_irq.flags() & UART.RX_ANY):
+        uart0_int_count += 1
+
+def uart1_handler (uart_o):
+    global uart1_irq
+    global uart1_int_count
+    if (uart1_irq.flags() & UART.RX_ANY):
+        uart1_int_count += 1
+
+uart0_irq = uart0.irq(trigger=UART.RX_ANY, handler=uart0_handler)
+uart1_irq = uart1.irq(trigger=UART.RX_ANY, handler=uart1_handler)
+
+uart0.write(b'123')
+# wait for the characters to be received
+while not uart1.any():
+    pass
+
+time.sleep_us(100)
+print(uart1.any() == 3)
+print(uart1_int_count > 0)
+print(uart1_irq.flags() == 0)
+print(uart0_irq.flags() == 0)
+print(uart1.read() == b'123')
+
+uart1.write(b'12345')
+# wait for the characters to be received
+while not uart0.any():
+    pass
+
+time.sleep_us(100)
+print(uart0.any() == 5)
+print(uart0_int_count > 0)
+print(uart0_irq.flags() == 0)
+print(uart1_irq.flags() == 0)
+print(uart0.read() == b'12345')
+
+# do it again
+uart1_int_count = 0
+uart0.write(b'123')
+# wait for the characters to be received
+while not uart1.any():
+    pass
+
+time.sleep_us(100)
+print(uart1.any() == 3)
+print(uart1_int_count > 0)
+print(uart1_irq.flags() == 0)
+print(uart0_irq.flags() == 0)
+print(uart1.read() == b'123')
+
+# disable the interrupt
+uart1_irq.disable()
+# do it again
+uart1_int_count = 0
+uart0.write(b'123')
+# wait for the characters to be received
+while not uart1.any():
+    pass
+
+time.sleep_us(100)
+print(uart1.any() == 3)
+print(uart1_int_count == 0) # no interrupt triggered this time
+print(uart1_irq.flags() == 0)
+print(uart0_irq.flags() == 0)
+print(uart1.read() == b'123')
+
+# enable the interrupt
+uart1_irq.enable()
+# do it again
+uart1_int_count = 0
+uart0.write(b'123')
+# wait for the characters to be received
+while not uart1.any():
+    pass
+
+time.sleep_us(100)
+print(uart1.any() == 3)
+print(uart1_int_count > 0)
+print(uart1_irq.flags() == 0)
+print(uart0_irq.flags() == 0)
+print(uart1.read() == b'123')
+
+uart1_irq.init(trigger=UART.RX_ANY, handler=None) # No handler
+# do it again
+uart1_int_count = 0
+uart0.write(b'123')
+# wait for the characters to be received
+while not uart1.any():
+    pass
+
+time.sleep_us(100)
+print(uart1.any() == 3)
+print(uart1_int_count == 0) # no interrupt handler called
+print(uart1_irq.flags() == 0)
+print(uart0_irq.flags() == 0)
+print(uart1.read() == b'123')
+
+# check for memory leaks
+for i in range(0, 1000):
+    uart0_irq = uart0.irq(trigger=UART.RX_ANY, handler=uart0_handler)
+    uart1_irq = uart1.irq(trigger=UART.RX_ANY, handler=uart1_handler)
+
+# next ones must raise
+try:
+    uart0_irq = uart0.irq(trigger=100, handler=uart0_handler)
+except:
+    print('Exception')
+
+try:
+    uart0_irq = uart0.irq(trigger=0)
+except:
+    print('Exception')
+
+try:
+    uart0_irq = uart0.irq(trigger=UART.RX_ANY, wake=Sleep.SUSPENDED)
+except:
+    print('Exception')
+
+uart0_irq.disable()
+uart1_irq.disable()
diff --git a/tests/wipy/uart_irq.py.exp b/tests/wipy/uart_irq.py.exp
new file mode 100644
index 0000000000..b165e824a0
--- /dev/null
+++ b/tests/wipy/uart_irq.py.exp
@@ -0,0 +1,33 @@
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+Exception
+Exception
+Exception