diff --git a/README.md b/README.md
index 2a5905946ab6d2bb5a960a46ef8be8d5524bd791..e426f2b13673f4fbf1d904a29b06717d96b6dd0d 100644
--- a/README.md
+++ b/README.md
@@ -1,92 +1,125 @@
# Digital Design - Calculator
+
+**Module Name:** Digital Design - Calculator
+**Module Code:** UFCFCS‑30‑2
-## Getting started
+**Module Leader Name:** Benedict R. Gaster
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://gitlab.uwe.ac.uk/jo2-holdsworth/digital-design-calculator.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://gitlab.uwe.ac.uk/jo2-holdsworth/digital-design-calculator/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
+- [Digital Design - Calculator](#digital-design---calculator)
+ - [Description](#description)
+ - [Task 1: a RPN calculator in Python.](#task-1--a-rpn-calculator-in-python)
+ - [Task 2: Hardware interface.](#task-2-hardware-interface)
+ - [Task 3: Server UDP time.](#task-3-server-udp-time)
+ - [Demos](#demos)
+ - [Getting Started](#getting-started)
+ - [Dependencies](#dependencies)
+ - [Installing](#installing)
+ - [Authors](#authors)
+ - [Version History](#version-history)
+ - [License](#license)
## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
+Worksheet 3:
+-This worksheet explored the UDP protocol. We will be decoding, encoding and comunicating with it in this rep
+FEATURES OF CALCULATOR
+**-This is a rep for only worksheet 3.**
+* [IOT - Worksheet 2 part 1 ](https://gitlab.uwe.ac.uk/jo2-holdsworth/iot-worksheet-2-part-1) can be found here
+* [IOT - Worksheet 2 part 2 ](https://gitlab.uwe.ac.uk/jo2-holdsworth/iot-worksheet-2-part-2) can be found here
+* [IOT - Worksheet 3](https://gitlab.uwe.ac.uk/jo2-holdsworth/iot-worksheet-3) **you are here**
+
+### Task 1: a RPN calculator in Python.
+* *RPN stands for reverse Polish Notation. RPN is postfix notation meaning the operators succeeds the operands.
+* ***stackClass.py*** A simple class to create a stack datatype within python. Contains a few error checking validation build into functions to help with the flow of the calculator program. The validation is used to prevent the user from performing actions or calculations that are not valid. The validation simply tells returns the current state of the stack. For example if the stack is empty and a `pop()` is called it will return **False**
+* ***sy.py*** A provided shunting yard algorithm. Takes input string and returns postfix.
+* ***rpn.py*** contains rpn_eval a Reverse Polish Notation Evaluator
+ * **def rpn_eval(tokens,stack)** Takes a string of expressions **+,-,*,/** `pop()`'s left and right value from the stack and applies the first expression and then `push(value)`'s the value back onto the stack thus making calculations._
+### Task 2: Hardware interface.
+* The calculator hardware is made up of three sub components. We have the *raspberry pi zero w* it self, this connects the components together and makes the calulations. The keypad makes up the second component and the OLED screen makes up the third component. There are some additional features I have added but these will be discussed later on. This section is only relevant to the required components.
+* ***The raspberry pi zero w*** This device is responsible for communicating to the other components. It also is responsible for the processing of *Task 1:*
+ * **calculator.py** This is the runner file. Responsible for connecting the hardware and making calculations. Displays welcome messages and puts `runCalculator()` into a loop
+ * **def runCalculator(lastPressed=[])** This function Runs the calculator. Writes buttons icons to the screen. Takes a pre input of the last pressed, this prevents the wake button press from inputting a input into the stack. A full cycle of the **lastPressed** button not being pressed is required to be able to operate the button. Retrieves the inputs from `keyboardclass.ispressed()`, if buttons pressed is an operation for example ***'='*** is will then compute the sum entered. Other wise it will add the input to the stack and display the stack string on the screen.
+* ***The Keyboard*** The keyboard is a 8 button switch matrix. Its wired to the raspberry pi via GPIO pins *(Please see wiring diagram for further details)*. A switch matrix works by ending power to one column at a time and then detecting if a row is active. Each column and row is cycled through multiple times per second. The main benefit for a switch matrix board is the reduced number of GPIO pins required.
+ * **keyboardClass.py** A class containing a few methods to the operation of the keyboard. Includes setup and outputs.
+ * **__init__()** Setup between the keyboard and the raspberry pi. Enables the connected GPIO pins *(Please see wiring diagram for further details)*
+ * **def isPressed(row, col)** Takes a row and column and returns if that button is pressed. Used mainly for debugging features and additional functionality.
+ * **pressed()** Takes no arguments. Returns an array of string of all buttons currently pressed. Detects what rows and columns are being pressed and calls `keyConverter()` to covert row and column into a string of button. I chose this unique way of processing button presses so that multiple button presses can be detected for additional features.
+ * **keyConverter(row,col)** Coverts the given row and column into a string of the corresponding button button.
+* ***The OLED screen*** The OLED screen is a small 129 by 64 screen. It will be used to display information to the user. Including the inputs and menu.
+ * **dd_oled.c** An API to communicate to the screen. The OLED screen communicated over I2C and is connected the the `sda,scl` pins on the raspberry pi *(Please see wiring diagram for further details)*
+ * **int oledSetPixel(int x, int y, unsigned char ucColor)** Sets the defined pixel to the given colour. This function forms the base for other functions.
+ * **int oledFill(unsigned char ucData)** Sets the screen to a given color. Also useful to reset the screen after input alteration.
+ * **int oledWriteString(int x, int y, char \*szMsg, int iSize)** This function displays a string of a given size in a location that is defined. Used for displaying the menu and inputs from the user.
+ * **int oledDrawLine(int x0, int y0, int x1, int y1, unsigned char ucPixel)** Draws a line across the screen at a given location and colour. Uses a naive line algorithm. Should be replaced in the future with a non naive line algorithm.
+ * **python API** pyOjbects are located at the bottom of the file. These object are used to connect the C file to the python extension.
+ * **setup.py** setup.py is a file used in the processes of building the c to python extension for the olid API.
+* ***Additional features*** This sections discusses some of the additional features I have added to the calculator.
+ * **Buttons** Multiple buttons make up extra functions of the calculator.
+ * **Brackets** There are two buttons near the screen. These buttons are soldered onto a perf board along with the led. These buttons are designed to be used along with a icon on the screen to signify the function of the buttons. Currently the buttons are used to input brackets into the calculator.
+ * **On-Off** Located on the side of the calculator lies a push button with a On-Off icon. Pressing this button toggles a toggle switch connected between the negative leg of the batery and the raspberry pi.
+ * **LED** As the rapsberry pi is located within the case, I have added a LED status light that indicates that the device is powered and working.
+ * **Battery** The battery is a small LIPO Cell connected to the usb-c charging port. It charges relatively slow but due to the low power consumption of the raspberry pi this is not an issue.
+ * **USB-C**
+ * **Case**
+___
+### Task 3: Server UDP time.
+* This takes builds upon **task 1** and **task 2** we need to send and receive packets from the sever with the correct checksum. This means encoding and decoding UDP.
+* ***mainSendandReceive()*** This function is a controller for smaller functions. It simply connects to server and tells the program to send and get packets from the server.
+* ***recv_and_decode_packet(websocket)*** We are taking a websocket connecting to it and printing the packet all it one. This take doesnt require us todo much else with the packet so it can just be called in a function. 
+* ***send_packet(websocket, sourcePort, deskPort, payLoad)*** To send packets to the server they need to be in UDP format in base64. This function will create a header for the payload including the correct checksum so the server can confirm the packet has arrived valid. 
+* ***unittest.py*** unittest is an inbuilt Python library. Its a test runner and is specially design for running tests and debugging. This one contains a few useful tools that we are going to use. It works similarly to the assert function. Task 3 doesn't have any output other than to the terminal. I could alter the output but this is out of my scope for the project. Here I am just checking if the program runs correctly. All the tests were successful.
+___
+## Demos
+* ***Task 1:***
+ **https://www.youtube.com/embed/_whlYriiWjs**
+ 
+* ***Task 2:***
+ **https://www.youtube.com/embed/1Am2Eauk4dY**
+ 
+* ***Task 3:***
+ **https://www.youtube.com/embed/wndZ8pPSINo**
+ 
+
+___
+## Getting Started
+
+* Running the task files
+ * Task 1: `python3 udpdecoder.py`
+ * Task 2: `python3 checksum.py`
+ * Task 3: `python3 serverudptime.py`
+
+### Dependencies
+
+* unittest
+* asyncio
+* websockets
+* json
+* time
+* base64
+
+### Installing
+
+* Nothing to install
+
+## Authors
+
+Contributors names and contact info
+
+ex. Jack Holdsworth @ [my website](https://holdsworth.dev)
+
+## Version History
+* 0.4
+ * README
+ * Unittesting
+* 0.3
+ * task 2 done
+ * started task 3
+* 0.2
+ * most of task 2 done
+ * README made
+* 0.1
+ * init.
## License
-For open source projects, say how it is licensed.
-
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+This project is licensed under the GPL License - see the LICENSE.md file for details
\ No newline at end of file
diff --git a/Schematic.fzz b/Schematic.fzz
new file mode 100644
index 0000000000000000000000000000000000000000..f071885235d4236545a50d9a3cc7f07ef54b1e2d
Binary files /dev/null and b/Schematic.fzz differ
diff --git a/calculator.py b/calculator.py
index 014031f8cd3391e8774f8a89aa85b43670364756..0bd7d3b72e3ca5991a0aa56043cfa3da7198c946 100644
--- a/calculator.py
+++ b/calculator.py
@@ -6,38 +6,61 @@ import rpn
import dd_oled
import RPi.GPIO as GPIO
-def runCalculator(lastPressed=[]):
- x = 0
- calculate = 0
- stack = stackClass.stack()
- rpnStack = stackClass.stack()
- while x < 200 and calculate == 0: #tempory return to while 1:
- pressed = keypad.pressed()
+def runCalculator(lastPressed=[]): # the calculator function. Takes parameters for key ignore.
+ x = 0 # counter
+ calculate = 0 # activate variable.
+ stack = stackClass.stack() # init the stack
+ rpnStack = stackClass.stack() # another stack for rpn
+ dd_oled.write_string(20, 0, '(', 2) # display buttons
+ dd_oled.write_string(20, 2, ')', 2)
+ while x < 800 and calculate == 0: #tempory return to while 1:
+
+ pressed = keypad.pressed() # get pressed keys
- for key in pressed:
- if len(lastPressed) == 0:
- if key != "=":
- stack.push(key)
+ for key in pressed: # for pressed key
+ if len(lastPressed) == 0: # checks for previous key presses
+ if key != "=" and key != "#": # if not a command key
+ stack.push(key) # push new key
+ dd_oled.oled_fill(0) # refresh screen
+ dd_oled.write_string(0, 0, ''.join(stack.stack[:15]), 0) # print two lines
+ dd_oled.write_string(0, 1, ''.join(stack.stack[15:]), 0)
+ dd_oled.write_string(20, 0, '(', 2) # reprint buttons
+ dd_oled.write_string(20, 2, ')', 2)
+ elif key == "#": # back space button
+ stack.pop()
dd_oled.oled_fill(0)
- dd_oled.write_string(0, 0, ''.join(stack.stack), 0)
+ dd_oled.write_string(0, 0, ''.join(stack.stack[:15]), 0)
+ dd_oled.write_string(0, 1, ''.join(stack.stack[15:]), 0)
+ dd_oled.write_string(20, 0, '(', 2)
+ dd_oled.write_string(20, 2, ')', 2)
else:
- calculate = 1
+ calculate = 1 # end loop start calculation.
else:
for lastKey in lastPressed:
if lastKey != key:
- if key != "=":
+ if key != "=" and key != "#":
stack.push(key)
dd_oled.oled_fill(0)
- dd_oled.write_string(0, 0, ''.join(stack.stack), 0)
+ dd_oled.write_string(0, 0, ''.join(stack.stack[:15]), 0)
+ dd_oled.write_string(0, 1, ''.join(stack.stack[15:]), 0)
+ dd_oled.write_string(20, 0, '(', 2)
+ dd_oled.write_string(20, 2, ')', 2)
+ elif key == "#":
+ stack.pop()
+ dd_oled.oled_fill(0)
+ dd_oled.write_string(0, 0, ''.join(stack.stack[:15]), 0)
+ dd_oled.write_string(0, 1, ''.join(stack.stack[15:]), 0)
+ dd_oled.write_string(20, 0, '(', 2)
+ dd_oled.write_string(20, 2, ')', 2)
else:
calculate = 1
- lastPressed = pressed
+ lastPressed = pressed # to allow for only 1 character per press
- print(stack.stack)
- time.sleep(.1)
- x += 1
- test = sy.shunt(sy.tokenize(''.join(stack.stack)))
+ print(stack.stack) # debug
+ time.sleep(.1) # time delay
+ x += 1 # counter
+ test = sy.shunt(sy.tokenize(''.join(stack.stack))) # token out
print(type(test))
@@ -47,18 +70,19 @@ def runCalculator(lastPressed=[]):
# print("hi")
ans = rpn.rpn_eval(test,rpnStack)
print(ans)
- dd_oled.oled_fill(0)
- dd_oled.write_string(0, 0, ''.join(ans), 0)
+ dd_oled.oled_fill(0) # print answer
+ dd_oled.write_string(0, 0, ''.join(ans)[:15], 0)
+ dd_oled.write_string(0, 1, ''.join(ans)[15:], 0)
# print(f"1 : {sy.shunt(stack.stack)}")
-keypad = keyboardClass.Keypad()
-dd_oled.oled_init(1, 0x3C, 1, 0, 0)
-dd_oled.oled_fill(0)
-dd_oled.write_string(1, 0, 'Welcome', 1)
+keypad = keyboardClass.Keypad() # init keyboard
+dd_oled.oled_init(1, 0x3C, 1, 0, 0) # init screen
+dd_oled.oled_fill(0) # clear
+dd_oled.write_string(1, 0, 'Welcome', 1) #welcome message
dd_oled.write_string(5, 3, 'Press any key', 2)
-lastPressed = []
-while True:
+lastPressed = [] # key press tracker
+while True: # forever loop
pressed = keypad.pressed()
if pressed != lastPressed:
lastPressed = pressed
@@ -69,20 +93,21 @@ while True:
runCalculator(lastPressed)
lastPressed = []
dd_oled.write_string(5, 2, 'Press any key.', 2)
- dd_oled.write_string(5, 3, 'or \'#\' to exit', 2)
+ # dd_oled.write_string(5, 3, 'or \'#\' to exit', 2)
while True:
time.sleep(1)
pressed = keypad.pressed()
if pressed != lastPressed:
print(f"pressed:{pressed}")
- if '#' in pressed:
- GPIO.cleanup()
- exit()
+ # if '#' in pressed:
+ # GPIO.cleanup()
+ # exit()
- else:
- lastPressed = pressed
- break
+ # else:
+ lastPressed = pressed
+ dd_oled.oled_fill(0)
+ break
lastPressed = pressed
# ADD mine sweeper
diff --git a/features.py b/features.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a9e55f95f14683893df45f79d23d42ec1707e9f
--- /dev/null
+++ b/features.py
@@ -0,0 +1,15 @@
+import RPi.GPIO as GPIO
+import time
+GPIO.setmode(GPIO.BCM)
+GPIO.setup(18, GPIO.OUT)
+GPIO.setup(15,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
+GPIO.setup(14,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
+while True: # Run forever
+ button0_state = GPIO.input(15)
+ button1_state = GPIO.input(14)
+ print(button0_state)
+ print(button1_state)
+ GPIO.output(18,GPIO.HIGH)
+ time.sleep(1)
+ GPIO.output(18,GPIO.LOW)
+ time.sleep(1)
\ No newline at end of file
diff --git a/keyboard.py b/keyboard.py
deleted file mode 100644
index 3f70d5c9f71453bd5e2e75ccc7c144a41aaff666..0000000000000000000000000000000000000000
--- a/keyboard.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import RPi.GPIO as GPIO
-import time
-
-COL1 = 6
-COL2 = 13
-COL3 = 19
-COL4 = 26
-ROW1 = 16
-ROW2 = 20
-ROW3 = 21
-ROW4 = 5
-
-GPIO.setmode(GPIO.BCM)
-#setup rows
-# set row1 as input and pullup (i.e. set HIGH)
-GPIO.setup(ROW1, GPIO.IN, pull_up_down=GPIO.PUD_UP)
-# other columnds go here
-# setup columns
-GPIO.setup(COL1, GPIO.OUT)
-# other rows go here
-# loop forever
-while True:
- # output LOW to col1
- GPIO.output(COL1, GPIO.LOW)
- # read the state of row1
- # if [ROW1, COL1] (which is key 1) pressed
- # then it will be 0 otherwise 1
- row1_state = GPIO.input(ROW1)
- print(row1_state)
- print('#######')
- time.sleep(1)
-# reset GPIOs before exiting
-GPIO.cleanup()
diff --git a/keyboardClass.py b/keyboardClass.py
index e11a4d2f3b1c71e9db77bd9051c32560efcdaf23..db2630eb9af5aad4185a5f046411555f8a690189 100644
--- a/keyboardClass.py
+++ b/keyboardClass.py
@@ -20,6 +20,8 @@ class Keypad:
for col in self.cols:
GPIO.setup(col, GPIO.OUT)
GPIO.output(col, GPIO.HIGH)
+ GPIO.setup(15,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
+ GPIO.setup(14,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
def isPressed(self, row, col):
GPIO.output(col, GPIO.LOW)
@@ -40,6 +42,10 @@ class Keypad:
pressed.append(self.keyConverter(row,col))
# print("pressed detected ########################")
# print("appended"+ str(self.keyConverter(row,col)))
+ if GPIO.input(15) == 1:
+ pressed.append('(')
+ if GPIO.input(14) == 1:
+ pressed.append(')')
return pressed
def keyConverter(self,row,col):
diff --git a/rpn.py b/rpn.py
index 10cc4d0bffdea1e0ac42d2d29959b6106e48b267..071ec412e2127b33dc7e862d1d427ac427be0e6d 100644
--- a/rpn.py
+++ b/rpn.py
@@ -1,5 +1,4 @@
def rpn_eval(tokens,stack):
- print("here0")
print(tokens)
for item in tokens:
print(item)
diff --git a/stackClass.py b/stackClass.py
index ef1f94e455edc42d6ec194ecd090588e01ec7fd3..4adeff075d29236abd0c0e16a569fa112037c787 100644
--- a/stackClass.py
+++ b/stackClass.py
@@ -1,31 +1,31 @@
class stack:
- def __init__ (self,size = 32):
+ def __init__ (self,size = 30): # max size of stack is 32 by default
self.stack = []
self.maxSize = size
- def push(self,plate):
+ def push(self,plate): # push method with error checking and return
if self.isFull() == False:
self.stack.append(plate)
return True
else:
return False
- def pop(self):
+ def pop(self): # pop method with error checking and return
if self.isEmpty() == False:
return self.stack.pop()
else:
return False
- def size(self):
+ def size(self): # size method to return current size of stack
return len(self.stack)
- def isEmpty(self):
+ def isEmpty(self): # isEmpty method to check if the stack is empty
if len(self.stack) == 0:
return True
else:
return False
- def isFull(self):
+ def isFull(self): # isFull method to check if the stack is full
if len(self.stack) >= self.maxSize:
return True
else:
diff --git a/test.py b/test.py
deleted file mode 100644
index ec633df118f256d1de6259399722205dba63c019..0000000000000000000000000000000000000000
--- a/test.py
+++ /dev/null
@@ -1,5 +0,0 @@
-import hello
-
-hello.oled_init(1, 0x3C, 1, 1, 1)
-hello.oled_fill(0)
-hello.write_string(0, 0, "1+1=2", 0)
\ No newline at end of file