├── .gitignore
├── README.md
├── examples
├── analogRead.py
├── colorloop.py
├── digitalRead.py
├── digitalWrite.py
├── encoderMotorMove.py
├── encoderMotorMoveTo.py
├── encoderMotorReadPos.py
├── encoderMotorReadSpeed.py
├── encoderMotorRun.py
├── gyroRead.py
├── humitureSensorRead.py
├── joystickRead.py
├── ledMatrixMessage.py
├── lineFollowerRead.py
├── motorRun.py
├── motorRunForOrion.py
├── servoRun.py
├── sevenSegmentDisplay.py
├── stepperMotorMove.py
├── stepperMotorMoveTo.py
├── stepperMotorRun.py
└── ultrasonicSensorRead.py
├── images
├── baseboard-pi-shield.jpg
├── baseboard-usb-cable.jpg
├── configTxt.jpg
├── firmware.jpg
├── megapi.jpg
├── pi3-disable-bt.jpg
└── serial.jpg
└── src
├── MANIFEST
├── README.md
├── __init__.py
├── megapi.py
├── megapi_python2.py
├── megapi_python3.py
└── setup.py
/.gitignore:
--------------------------------------------------------------------------------
1 | # Byte-compiled / optimized / DLL files
2 | __pycache__/
3 | *.py[cod]
4 | *$py.class
5 |
6 | # C extensions
7 | *.so
8 |
9 | # Distribution / packaging
10 | .Python
11 | env/
12 | build/
13 | develop-eggs/
14 | dist/
15 | downloads/
16 | eggs/
17 | .eggs/
18 | lib64/
19 | parts/
20 | sdist/
21 | var/
22 | *.egg-info/
23 | .installed.cfg
24 | *.egg
25 |
26 | # PyInstaller
27 | # Usually these files are written by a python script from a template
28 | # before PyInstaller builds the exe, so as to inject date/other infos into it.
29 | *.manifest
30 | *.spec
31 |
32 | # Installer logs
33 | pip-log.txt
34 | pip-delete-this-directory.txt
35 |
36 | # Unit test / coverage reports
37 | htmlcov/
38 | .tox/
39 | .coverage
40 | .coverage.*
41 | .cache
42 | nosetests.xml
43 | coverage.xml
44 | *,cover
45 | .hypothesis/
46 |
47 | # Translations
48 | *.mo
49 | *.pot
50 |
51 | # Django stuff:
52 | *.log
53 |
54 | # Sphinx documentation
55 | docs/_build/
56 |
57 | # PyBuilder
58 | target/
59 |
60 | #Ipython Notebook
61 | .ipynb_checkpoints
62 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Python For MegaPi
2 | ## How To Use
3 | ### Prepare for Arduino
4 | * Download the Arduino library for Makeblock https://github.com/Makeblock-official/Makeblock-Libraries/archive/master.zip
5 | * Copy the makeblock folder to your arduino default library. Your Arduino library folder should now look like this
6 | * (on Windows): ```[x:\Users\XXX\Documents]\Arduino\libraries\makeblock\src```
7 | * (on Mac OSX): ```[\Users\XXX\Documents]\Arduino\libraries\makeblock\src```
8 | * Open Arduino IDE, choose the firmware from File>Examples.
9 | 
10 | * Compile and upload firmware according to your board type.
11 |
12 | ### Prepare for Raspberry Pi
13 | * On your Raspberry Pi, disable the login prompt from Desktop->Menu->Preferences->Raspberry Pi Configuration.
14 |
15 | 
16 |
17 | * If you are using raspberry 3 B+，since the Bluetooth function takes up the ttyAMA0 port, You have two ways to solve this problem.
18 |
19 |
20 | 1. Disable the pi3 bluetooth and restore UART0/ttyAMA0 over GPIOs 14&15
21 |
22 | 2. Switch pi3 blutooth function to use the mini-UART(ttyS0) and restore UART0/ttyAMA0 over GPIOs 14&15.
23 |
24 | * Here, I disable the pi3 bluetooth as an example
25 |
26 | 1. Search `pi3-disable-bt` in file `/boot/overlays/README`, it will show you, how to disable the bluetooth, if you want switch the bluetooth to mini-UART(ttyS0), you can search `pi3-miniuart-bt`
27 |
28 | 
29 |
30 | 2. Modify the file `/boot/config.txt`, At the end of the file, add the following content
31 | ```
32 | #Enable uart
33 | enable_uart=1
34 | dtoverlay=pi3-disable-bt
35 | ```
36 |
37 | 
38 |
39 | 3. reboot the raspberry pi
40 |
41 | 4. open the Terminal and input the command `sudo systemctl disable hciuart`
42 |
43 | 5. Now you can use ttyAMA0 as UART over GPIOs 14&15
44 |
45 |
46 | * install python library for Makeblock
47 | ```
48 | sudo pip install megapi
49 | ```
50 | * the initial code for python.
51 | ```
52 | from megapi import *
53 | bot = MegaPi()
54 | bot.start() #if using usb cable, need to call bot.start('/dev/ttyACM0')
55 | ```
56 | * python your code
57 |
58 | ### Wiring
59 | * Using MegaPi
60 | 
61 | * Using Me Shield for Raspberry Pi and RJ25 cable for Me Orion or Me Baseboard.
62 | 
63 | * Using USB Cable for Me Orion or Me Baseboard
64 | 
65 |
66 | ## Python API
67 | * Start
68 | * **MegaPi**()
69 | * **start**()
70 |
71 | * GPIO
72 | * **digitalWrite**( pin, level )
73 | * **pwmWrite**( pin, pwm )
74 | * **digitalRead**( pin, **def** onResult )
75 | * **analogRead**( pin, **def** onResult )
76 |
77 | * Motion
78 | * DC Motor
79 | * **motorRun**( port, speed )
80 | * **motorMove**( leftspeed, rightspeed )
81 | * Servo Motor
82 | * **servoRun**( port, slot, angle )
83 | * Encoder Motor
84 | * **encoderMotorRun**( port, speed )
85 | * **encoderMotorMove**( port, speed, distance, **def** onFinish )
86 | * **encoderMotorMoveTo**( port, speed, position, **def** onFinish )
87 | * **encoderMotorSetCurPosZero**( slot )
88 | * **encoderMotorPosition**( slot, **def** onResult)
89 | * **encoderMotorSpeed**( slot, **def** onResult)
90 | * Stepper Motor
91 | * **stepperMotorRun**( port, speed )
92 | * **stepperMotorMove**( port, speed, distance, **def** onFinish )
93 | * **stepperMotorMoveTo**( port, speed, position, **def** onFinish )
94 |
95 | * Sensors
96 | * Ultrasonic Sensor
97 | * **ultrasonicSensorRead** ( port, **def** onResult )
98 | * LineFollow Sensor
99 | * **lineFollowerRead** ( port, **def** onResult )
100 | * Light Sensor
101 | * **lightSensorRead** ( port, **def** onResult )
102 | * Sound Sensor
103 | * **soundSensorRead** ( port, **def** onResult )
104 | * Temperature Sensor
105 | * **temperatureRead** ( port, **def** onResult )
106 | * PIR Motion Sensor
107 | * **pirMotionSensorRead** ( port, **def** onResult )
108 | * Touch Sensor
109 | * **touchSensorRead** ( port, **def** onResult )
110 | * LimitSwitch
111 | * **limitSwitchRead** ( port, slot, **def** onResult )
112 | * Humiture Sensor
113 | * **humitureSensorRead** ( port, type, **def** onResult )
114 | * Gas Sensor
115 | * **gasSensorRead** ( port, **def** onResult )
116 | * Flame Sensor
117 | * **flameSensorRead** ( port, **def** onResult )
118 | * Button
119 | * **buttonRead** ( port, **def** onResult )
120 | * Potentiometer
121 | * **potentiometerRead** ( port, **def** onResult )
122 | * Joystick
123 | * **joystickRead** ( port, axis, **def** onResult )
124 | * 3-Axis Accelerometer and Gyro Sensor
125 | * **gyroRead** ( port，axis, **def** onResult )
126 | * Compass
127 | * **compassRead** ( **def** onResult )
128 | * Pressure Sensor for BMP085 and BMP180
129 | * **pressureSensorBegin** ( )
130 | * **pressureSensorRead** ( type, **def** onResult ) #1:Pressure #2:Temperature #3:Altitude #4:Real altitude #5:Sealevel Pressure
131 |
132 | * Display
133 | * RGB Led
134 | * **rgbLedSetColor** ( port, slot, index, r, g, b )
135 | * **rgbLedShow** ( port, slot )
136 | * **rgbLedDisplay** ( port, slot, index, r, g, b )
137 | * 7-segment Display
138 | * **sevenSegmentDisplay** ( port, value )
139 | * Led Matrix Display
140 | * **ledMatrixDisplayMessage** ( port, x, y, msg )
141 | * **ledMatrixDisplayRaw** ( port, buffer )
142 | * Serial LCD Display
143 | * **lcdDisplay** ( string )
144 |
145 | * Others
146 | * DSLR Shutter
147 | * **shutterOn** ( port )
148 | * **shutterOff** ( port )
149 | * **focusOn** ( port )
150 | * **focusOff** ( port )
151 |
152 | ###Learn more from Makeblock official website: www.makeblock.com
--------------------------------------------------------------------------------
/examples/analogRead.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onRead(level):
4 | print("level")
5 |
6 | if __name__ == '__main__':
7 | bot = MegaPi()
8 | bot.start()
9 | while 1:
10 | sleep(0.1);
11 | bot.analogRead(1,onRead);
--------------------------------------------------------------------------------
/examples/colorloop.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 | import random
3 | import math
4 |
5 | if __name__ == '__main__':
6 | bot = MegaPi()
7 | bot.start()
8 | j = 0.0;
9 | f = 0.0;
10 | k = 0.0;
11 | port = 8;
12 | slot = 2;
13 | while True:
14 | for i in range(5):
15 | j += random.random();
16 | f += random.random();
17 | k += random.random();
18 | red = 32*(1.0+math.sin(((i/2.0)+(j/4.0))));
19 | green = 32*(1.0+math.sin(((i/1.0)+(f/9.0)+2.1)));
20 | blue = 32*(1.0+math.sin(((i/3.0)+(k/14.0)+4.2)));
21 | bot.rgbledDisplay(port,slot,i,red,green,blue);
22 | sleep(1);
23 | pass
24 |
--------------------------------------------------------------------------------
/examples/digitalRead.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onRead(level):
4 | print("level")
5 |
6 | if __name__ == '__main__':
7 | bot = MegaPi()
8 | bot.start()
9 | while 1:
10 | sleep(0.1);
11 | bot.digitalRead(12,onRead);
--------------------------------------------------------------------------------
/examples/digitalWrite.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | while True:
7 | sleep(0.2);
8 | bot.digitalWrite(13,1);
9 | sleep(0.2);
10 | bot.digitalWrite(13,0);
--------------------------------------------------------------------------------
/examples/encoderMotorMove.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onForwardFinish(slot):
4 | sleep(0.4);
5 | bot.encoderMotorMove(slot,100,-1000,onBackwardFinish);
6 |
7 | def onBackwardFinish(slot):
8 | sleep(0.4);
9 | print("slot")
10 | bot.encoderMotorMove(slot,100,1000,onForwardFinish);
11 |
12 | if __name__ == '__main__':
13 | bot = MegaPi()
14 | bot.start()
15 | bot.encoderMotorRun(4,0);
16 | sleep(1);
17 | onForwardFinish(4);
18 | while 1:
19 | continue;
--------------------------------------------------------------------------------
/examples/encoderMotorMoveTo.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onForwardFinish(slot):
4 | sleep(0.4);
5 | bot.encoderMotorMoveTo(slot,100,-1000,onBackwardFinish);
6 |
7 | def onBackwardFinish(slot):
8 | sleep(0.4);
9 | bot.encoderMotorMoveTo(slot,100,1000,onForwardFinish);
10 |
11 | if __name__ == '__main__':
12 | bot = MegaPi()
13 | bot.start()
14 | bot.encoderMotorRun(4,0);
15 | bot.encoderMotorSetCurPosZero(4);
16 | sleep(1);
17 | onForwardFinish(4);
18 | while 1:
19 | continue;
--------------------------------------------------------------------------------
/examples/encoderMotorReadPos.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onRead(level):
4 | print("Encoder motor speed Value:%f" %level);
5 |
6 | if __name__ == '__main__':
7 | bot = MegaPi()
8 | bot.start()
9 | bot.encoderMotorRun(4,100);
10 | sleep(1);
11 | while 1:
12 | bot.encoderMotorPosition(4,onRead);
13 | sleep(0.2);
--------------------------------------------------------------------------------
/examples/encoderMotorReadSpeed.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onRead(level):
4 | print("Encoder motor speed Value:%f" %level);
5 |
6 | if __name__ == '__main__':
7 | bot = MegaPi()
8 | bot.start()
9 | bot.encoderMotorRun(4,100);
10 | sleep(1);
11 | while 1:
12 | bot.encoderMotorSpeed(4,onRead);
13 | sleep(0.2);
--------------------------------------------------------------------------------
/examples/encoderMotorRun.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | bot.encoderMotorRun(4,0);
7 | sleep(1);
8 | while 1:
9 | bot.encoderMotorRun(4,-200);
10 | sleep(5);
11 | bot.encoderMotorRun(4,0);
12 | sleep(5);
--------------------------------------------------------------------------------
/examples/gyroRead.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onRead(level):
4 | print("Gyro Value:%f" %level);
5 |
6 | if __name__ == '__main__':
7 | bot = MegaPi()
8 | bot.start()
9 | while 1:
10 | sleep(0.1);
11 | bot.gyroRead(0,1,onRead);
--------------------------------------------------------------------------------
/examples/humitureSensorRead.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onReadHumiture(hum):
4 | print("Humiture:"+str(hum)+"%");
5 | bot.humitureSensorRead(port,1,onReadTemperature);
6 |
7 | def onReadTemperature(temp):
8 | print("Temperature:"+str(temp)+" C");
9 |
10 | if __name__ == '__main__':
11 | bot = MegaPi()
12 | bot.start('/dev/ttyACM0') #Raspberry
13 | #bot.start('COM31') #windows
14 | port = 6;
15 | while 1:
16 | sleep(1);
17 | bot.humitureSensorRead(port,0,onReadHumiture);
18 |
--------------------------------------------------------------------------------
/examples/joystickRead.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | axisX = 0;
4 | axisY = 0;
5 |
6 | def onReadX(v):
7 | global axisX;
8 | axisX = v;
9 | bot.joystickRead(port,2,onReadY);
10 |
11 | def onReadY(v):
12 | global axisY;
13 | axisY = v;
14 | print(axisX,axisY);
15 |
16 | if __name__ == '__main__':
17 | bot = MegaPi()
18 | bot.start()
19 | port = 6;
20 | while True:
21 | bot.joystickRead(port,1,onReadX);
22 | sleep(0.1);
--------------------------------------------------------------------------------
/examples/ledMatrixMessage.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | t = 16;
7 | while True:
8 | sleep(0.06);
9 | bot.ledMatrixMessage(6,t,0,"Hello World");
10 | t-=1;
11 | if(t<-68):
12 | t = 16;
13 |
--------------------------------------------------------------------------------
/examples/lineFollowerRead.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onRead(v):
4 | print("line:"+str(v));
5 |
6 | if __name__ == '__main__':
7 | bot = MegaPi()
8 | bot.start()
9 | while 1:
10 | sleep(0.1);
11 | bot.lineFollowerRead(6,onRead);
--------------------------------------------------------------------------------
/examples/motorRun.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | bot.motorRun(1,0);
7 | sleep(1);
8 | while 1:
9 | sleep(1);
10 | bot.motorRun(1,50);
11 | sleep(1);
12 | bot.motorRun(1,0);
13 | sleep(1);
14 | bot.motorRun(1,-50);
15 | sleep(1);
16 | bot.motorRun(1,0);
--------------------------------------------------------------------------------
/examples/motorRunForOrion.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | bot.motorRun(M1,0);
7 | sleep(1);
8 | while 1:
9 | sleep(1);
10 | bot.motorRun(M1,50);
11 | sleep(1);
12 | bot.motorRun(M1,0);
13 | sleep(1);
14 | bot.motorRun(M1,-50);
15 | sleep(1);
16 | bot.motorRun(M1,0);
17 |
--------------------------------------------------------------------------------
/examples/servoRun.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | while True:
7 | sleep(1);
8 | bot.servoRun(7,1,20);
9 | bot.servoRun(7,2,20);
10 | bot.servoRun(8,1,20);
11 | bot.servoRun(8,2,20);
12 | sleep(1);
13 | bot.servoRun(7,1,160);
14 | bot.servoRun(7,2,160);
15 | bot.servoRun(8,1,160);
16 | bot.servoRun(8,2,160);
17 |
--------------------------------------------------------------------------------
/examples/sevenSegmentDisplay.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | t = 0.0;
7 | while True:
8 | bot.sevenSegmentDisplay(6,t);
9 | t+=0.13;
10 | if t>100:
11 | t = 0;
12 | sleep(0.1);
--------------------------------------------------------------------------------
/examples/stepperMotorMove.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onForwardFinish(slot):
4 | sleep(0.4);
5 | bot.stepperMotorMove(slot,3000,-3000,onBackwardFinish);
6 |
7 | def onBackwardFinish(slot):
8 | sleep(0.4);
9 | print(slot);
10 | bot.stepperMotorMove(slot,3000,3000,onForwardFinish);
11 |
12 | if __name__ == '__main__':
13 | bot = MegaPi()
14 | bot.start()
15 | sleep(1);
16 | onForwardFinish(1);
17 | while 1:
18 | continue;
--------------------------------------------------------------------------------
/examples/stepperMotorMoveTo.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onForwardFinish(slot):
4 | sleep(0.4);
5 | bot.stepperMotorMoveTo(slot,3000,-6000,onBackwardFinish);
6 |
7 | def onBackwardFinish(slot):
8 | sleep(0.4);
9 | bot.stepperMotorMoveTo(slot,3000,6000,onForwardFinish);
10 |
11 | if __name__ == '__main__':
12 | bot = MegaPi()
13 | bot.start()
14 | sleep(1);
15 | onForwardFinish(1);
16 | while 1:
17 | continue;
--------------------------------------------------------------------------------
/examples/stepperMotorRun.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | if __name__ == '__main__':
4 | bot = MegaPi()
5 | bot.start()
6 | bot.stepperMotorRun(1,0);
7 | sleep(1);
8 | while 1:
9 | bot.stepperMotorRun(1,-3000);
10 | sleep(10);
11 | bot.stepperMotorRun(1,0);
12 | sleep(4);
--------------------------------------------------------------------------------
/examples/ultrasonicSensorRead.py:
--------------------------------------------------------------------------------
1 | from megapi import *
2 |
3 | def onRead(v):
4 | print("distance:"+str(v)+" cm");
5 |
6 | if __name__ == '__main__':
7 | bot = MegaPi()
8 | bot.start()
9 | while 1:
10 | sleep(0.1);
11 | bot.ultrasonicSensorRead(6,onRead);
--------------------------------------------------------------------------------
/images/baseboard-pi-shield.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/images/baseboard-pi-shield.jpg
--------------------------------------------------------------------------------
/images/baseboard-usb-cable.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/images/baseboard-usb-cable.jpg
--------------------------------------------------------------------------------
/images/configTxt.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/images/configTxt.jpg
--------------------------------------------------------------------------------
/images/firmware.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/images/firmware.jpg
--------------------------------------------------------------------------------
/images/megapi.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/images/megapi.jpg
--------------------------------------------------------------------------------
/images/pi3-disable-bt.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/images/pi3-disable-bt.jpg
--------------------------------------------------------------------------------
/images/serial.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/images/serial.jpg
--------------------------------------------------------------------------------
/src/MANIFEST:
--------------------------------------------------------------------------------
1 | # file GENERATED by distutils, do NOT edit
2 | README
3 | __init__.py
4 | megapi.py
5 | setup.py
6 |
--------------------------------------------------------------------------------
/src/README.md:
--------------------------------------------------------------------------------
1 | # Python For MegaPi
2 | ## How To Use
3 | * Compile and upload the Firmware to MegaPi ( https://github.com/Makeblock-Official/FirmwareForMegaPi )
4 | * On your Raspberry Pi,
5 | ```
6 | sudo pip install megapi
7 | ```
8 | * Insert the initial code for starting MegaPi first.
9 | ```
10 | from megapi import *
11 | bot = MegaPi()
12 | bot.start()
13 | ```
14 | * python your code
15 |
16 | ## Python API
17 | * Start
18 | * **MegaPi**()
19 | * **start**()
20 |
21 | * GPIO
22 | * **digitalWrite**( pin, level )
23 | * **pwmWrite**( pin, pwm )
24 | * **digitalRead**( pin, **def** onResult )
25 | * **analogRead**( pin, **def** onResult )
26 |
27 | * Motion
28 | * DC Motor
29 | * **dcMotorRun**( port, speed )
30 | * Servo Motor
31 | * **servoRun**( port, angle )
32 | * Encoder Motor
33 | * **encoderMotorRun**( port, speed )
34 | * **encoderMotorMove**( port, speed, distance, **def** onFinish )
35 | * **encoderMotorMoveTo**( port, speed, position, **def** onFinish )
36 | * **encoderMotorSetCurPosZero( port )
37 | * **encoderMotorPosition( port, **def** onResult )
38 | * **encoderMotorSpeed( port, **def** onResult )
39 | * Stepper Motor
40 | * **stepperMotorRun**( port, speed )
41 | * **stepperMotorMove**( port, speed, distance, **def** onFinish )
42 | * **stepperMotorMoveTo**( port, speed, position, **def** onFinish )
43 | * **stepperMotorSetCurPosZero( port )
44 |
45 | * Sensors
46 | * Ultrasonic Sensor
47 | * **ultrasonicSensorRead** ( port, **def** onResult )
48 | * LineFollow Sensor
49 | * **lineFollowerRead** ( port, **def** onResult )
50 | * Light Sensor
51 | * **lightSensorRead** ( port, **def** onResult )
52 | * Sound Sensor
53 | * **soundSensorRead** ( port, **def** onResult )
54 | * Temperature Sensor
55 | * **temperatureRead** ( port, **def** onResult )
56 | * PIR Motion Sensor
57 | * **pirMotionSensorRead** ( port, **def** onResult )
58 | * Touch Sensor
59 | * **touchSensorRead** ( port, **def** onResult )
60 | * LimitSwitch
61 | * **limitSwitchRead** ( port, slot, **def** onResult )
62 | * Humiture Sensor
63 | * **humitureSensorRead** ( port, type, **def** onResult )
64 | * Gas Sensor
65 | * **gasSensorRead** ( port, **def** onResult )
66 | * Flame Sensor
67 | * **flameSensorRead** ( port, **def** onResult )
68 | * Button
69 | * **buttonRead** ( port, **def** onResult )
70 | * Potentiometer
71 | * **potentiometerRead** ( port, **def** onResult )
72 | * Joystick
73 | * **joystickRead** ( port, axis, **def** onResult )
74 | * 3-Axis Accelerometer and Gyro Sensor
75 | * **gyroRead** (port, axis, **def** onResult )
76 | * Compass
77 | * **compassRead** ( **def** onResult )
78 |
79 | * Display
80 | * RGB Led
81 | * **rgbLedSetColor** ( port, slot, index, r, g, b )
82 | * **rgbLedShow** ( port, slot )
83 | * **rgbLedDisplay** ( port, slot, index, r, g, b )
84 | * 7-segment Display
85 | * **sevenSegmentDisplay** ( port, value )
86 | * Led Matrix Display
87 | * **ledMatrixDisplayMessage** ( port, x, y, msg )
88 | * **ledMatrixDisplayRaw** ( port, buffer )
89 | * Serial LCD Display
90 | * **lcdDisplay** ( string )
91 |
92 | * Others
93 | * DSLR Shutter
94 | * **shutterOn** ( port )
95 | * **shutterOff** ( port )
96 | * **focusOn** ( port )
97 | * **focusOff** ( port )
98 |
--------------------------------------------------------------------------------
/src/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Makeblock-official/PythonForMegaPi/99671d724ae53f558d5828d2dd631c75632511be/src/__init__.py
--------------------------------------------------------------------------------
/src/megapi.py:
--------------------------------------------------------------------------------
1 | import serial
2 | import sys,time,math,random
3 | import signal
4 | from time import ctime,sleep
5 | import glob,struct
6 | from multiprocessing import Process,Manager,Array
7 | import threading
8 |
9 | class mSerial():
10 | ser = None
11 | def __init__(self):
12 | print self
13 |
14 | def start(self, port='/dev/ttyAMA0'):
15 | self.ser = serial.Serial(port,115200,timeout=10)
16 |
17 | def device(self):
18 | return self.ser
19 |
20 | def serialPorts(self):
21 | if sys.platform.startswith('win'):
22 | ports = ['COM%s' % (i + 1) for i in range(256)]
23 | elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
24 | ports = glob.glob('/dev/tty[A-Za-z]*')
25 | elif sys.platform.startswith('darwin'):
26 | ports = glob.glob('/dev/tty.*')
27 | else:
28 | raise EnvironmentError('Unsupported platform')
29 | result = []
30 | for port in ports:
31 | s = serial.Serial()
32 | s.port = port
33 | s.close()
34 | result.append(port)
35 | return result
36 |
37 | def writePackage(self,package):
38 | self.ser.write(package)
39 | sleep(0.01)
40 |
41 | def read(self):
42 | return self.ser.read()
43 |
44 | def isOpen(self):
45 | return self.ser.isOpen()
46 |
47 | def inWaiting(self):
48 | return self.ser.inWaiting()
49 |
50 | def close(self):
51 | self.ser.close()
52 | M1 = 9
53 | M2 = 10
54 | A0 = 14
55 | A1 = 15
56 | A2 = 16
57 | A3 = 17
58 | A4 = 18
59 | A6 = 19
60 | A7 = 20
61 | A8 = 21
62 | A9 = 22
63 | A10 = 23
64 | A11 = 24
65 |
66 | class MegaPi():
67 | def __init__(self):
68 | print "init MegaPi"
69 | signal.signal(signal.SIGINT, self.exit)
70 | self.manager = Manager()
71 | self.__selectors = self.manager.dict()
72 | self.buffer = []
73 | self.bufferIndex = 0
74 | self.isParseStart = False
75 | self.exiting = False
76 | self.isParseStartIndex = 0
77 |
78 | def __del__(self):
79 | self.exiting = True
80 |
81 | def start(self,port='/dev/ttyAMA0'):
82 | self.device = mSerial()
83 | self.device.start(port)
84 | sys.excepthook = self.excepthook
85 | th = threading.Thread(target=self.__onRead,args=(self.onParse,))
86 | th.start()
87 |
88 | def excepthook(self, exctype, value, traceback):
89 | self.close()
90 |
91 | def close(self):
92 | self.device.close()
93 |
94 | def exit(self, signal, frame):
95 | self.exiting = True
96 | sys.exit(0)
97 |
98 | def __onRead(self,callback):
99 | while True:
100 | if(self.exiting==True):
101 | break
102 | try:
103 | if self.device.isOpen()==True:
104 | n = self.device.inWaiting()
105 | for i in range(n):
106 | r = ord(self.device.read())
107 | callback(r)
108 | sleep(0.01)
109 | else:
110 | sleep(0.5)
111 | except Exception,ex:
112 | print str(ex)
113 | self.close()
114 | sleep(1)
115 | def __writePackage(self,pack):
116 | self.device.writePackage(pack)
117 |
118 | def __writeRequestPackage(self,deviceId,port,callback):
119 | extId = ((port<<4)+deviceId)&0xff
120 | self.__doCallback(extId,callback)
121 | self.__writePackage(bytearray([0xff,0x55,0x4,extId,0x1,deviceId,port]))
122 |
123 | def digitalRead(self,pin,callback):
124 | self.__writeRequestPackage(0x1e,pin,callback)
125 |
126 | def analogRead(self,pin,callback):
127 | self.__writeRequestPackage(0x1f,pin,callback)
128 |
129 | def lightSensorRead(self,port,callback):
130 | self.__writeRequestPackage(4,port,callback)
131 |
132 | def ultrasonicSensorRead(self,port,callback):
133 | self.__writeRequestPackage(1,port,callback)
134 |
135 | def lineFollowerRead(self,port,callback):
136 | self.__writeRequestPackage(17,port,callback)
137 |
138 | def soundSensorRead(self,port,callback):
139 | self.__writeRequestPackage(7,port,callback)
140 |
141 | def pirMotionSensorRead(self,port,callback):
142 | self.__writeRequestPackage(15,port,callback)
143 |
144 | def potentiometerRead(self,port,callback):
145 | self.__writeRequestPackage(4,port,callback)
146 |
147 | def limitSwitchRead(self,port,callback):
148 | self.__writeRequestPackage(21,port,callback)
149 |
150 | def temperatureRead(self,port,slot,callback):
151 | deviceId = 2
152 | extId = ((port<<4)+deviceId)&0xff
153 | self.__doCallback(extId,callback)
154 | self.__writePackage(bytearray([0xff,0x55,0x5,extId,0x1,deviceId,port,slot]))
155 |
156 | def touchSensorRead(self,port,callback):
157 | self.__writeRequestPackage(15,port,callback)
158 |
159 | def humitureSensorRead(self,port,type,callback):
160 | deviceId = 23;
161 | extId = ((port<<4)+deviceId)&0xff
162 | self.__doCallback(extId,callback)
163 | self.__writePackage(bytearray([0xff,0x55,0x5,extId,0x1,deviceId,port,type]))
164 |
165 | def joystickRead(self,port,axis,callback):
166 | deviceId = 5;
167 | extId = (((port+axis)<<4)+deviceId)&0xff
168 | self.__doCallback(extId,callback)
169 | self.__writePackage(bytearray([0xff,0x55,0x5,extId,0x1,deviceId,port,axis]))
170 |
171 | def gasSensorRead(self,port,callback):
172 | self.__writeRequestPackage(25,port,callback)
173 |
174 | def flameSensorRead(self,port,callback):
175 | self.__writeRequestPackage(24,port,callback)
176 |
177 | def compassRead(self,port,callback):
178 | self.__writeRequestPackage(26,port,callback)
179 |
180 | def angularSensorRead(self,port,slot,callback):
181 | self.__writeRequestPackage(28,port,callback)
182 |
183 | def buttonRead(self,port,callback):
184 | self.__writeRequestPackage(22,port,callback)
185 |
186 | def gyroRead(self,port,axis,callback):
187 | deviceId = 6;
188 | extId = (((port+axis)<<4)+deviceId)&0xff
189 | self.__doCallback(extId,callback)
190 | self.__writePackage(bytearray([0xff,0x55,0x5,extId,0x1,deviceId,port,axis]))
191 |
192 | def pressureSensorBegin(self):
193 | self.__writePackage(bytearray([0xff,0x55,0x3,0x0,0x2,29]))
194 |
195 | def pressureSensorRead(self,type,callback):
196 | self.__writeRequestPackage(29,type,callback)
197 |
198 | def digitalWrite(self,pin,level):
199 | self.__writePackage(bytearray([0xff,0x55,0x5,0x0,0x2,0x1e,pin,level]))
200 |
201 | def pwmWrite(self,pin,pwm):
202 | self.__writePackage(bytearray([0xff,0x55,0x5,0x0,0x2,0x20,pin,pwm]))
203 |
204 | def motorRun(self,port,speed):
205 | self.__writePackage(bytearray([0xff,0x55,0x6,0x0,0x2,0xa,port]+self.short2bytes(speed)))
206 |
207 | def motorMove(self,leftSpeed,rightSpeed):
208 | self.__writePackage(bytearray([0xff,0x55,0x7,0x0,0x2,0x5]+self.short2bytes(-leftSpeed)+self.short2bytes(rightSpeed)))
209 |
210 | def servoRun(self,port,slot,angle):
211 | self.__writePackage(bytearray([0xff,0x55,0x6,0x0,0x2,0xb,port,slot,angle]))
212 |
213 | def encoderMotorRun(self,slot,speed):
214 | deviceId = 62;
215 | self.__writePackage(bytearray([0xff,0x55,0x07,0x00,0x02,deviceId,0x02,slot]+self.short2bytes(speed)))
216 |
217 | def encoderMotorMove(self,slot,speed,distance,callback):
218 | deviceId = 62;
219 | extId = ((slot<<4)+deviceId)&0xff
220 | self.__doCallback(extId,callback)
221 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x01,slot]+self.long2bytes(distance)+self.short2bytes(speed)))
222 |
223 | def encoderMotorMoveTo(self,slot,speed,distance,callback):
224 | deviceId = 62;
225 | extId = ((slot<<4)+deviceId)&0xff
226 | self.__doCallback(extId,callback)
227 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x06,slot]+self.long2bytes(distance)+self.short2bytes(speed)))
228 |
229 | def encoderMotorSetCurPosZero(self,slot):
230 | deviceId = 62;
231 | self.__writePackage(bytearray([0xff,0x55,0x05,0x00,0x02,deviceId,0x04,slot]))
232 |
233 | def encoderMotorPosition(self,slot,callback):
234 | deviceId = 61;
235 | extId = ((slot<<4)+deviceId)&0xff
236 | self.__doCallback(extId,callback)
237 | self.__writePackage(bytearray([0xff,0x55,0x06,extId,0x01,deviceId,0x00,slot,0x01]))
238 |
239 | def encoderMotorSpeed(self,slot,callback):
240 | deviceId = 61;
241 | extId = ((slot<<4)+deviceId)&0xff
242 | self.__doCallback(extId,callback)
243 | self.__writePackage(bytearray([0xff,0x55,0x06,extId,0x01,deviceId,0x00,slot,0x02]))
244 |
245 | def stepperMotorRun(self,slot,speed):
246 | deviceId = 76;
247 | self.__writePackage(bytearray([0xff,0x55,0x07,0x00,0x02,deviceId,0x02,slot]+self.short2bytes(speed)))
248 |
249 | def stepperMotorMove(self,port,speed,distance,callback):
250 | deviceId = 76;
251 | extId = ((port<<4)+deviceId)&0xff
252 | self.__doCallback(extId,callback)
253 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x01,port]+self.long2bytes(distance)+self.short2bytes(speed)))
254 |
255 | def stepperMotorMoveTo(self,port,speed,distance,callback):
256 | deviceId = 76;
257 | extId = ((port<<4)+deviceId)&0xff
258 | self.__doCallback(extId,callback)
259 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x06,port]+self.long2bytes(distance)+self.short2bytes(speed)))
260 |
261 | def stepperMotorSetCurPosZero(self,port):
262 | deviceId = 76;
263 | self.__writePackage(bytearray([0xff,0x55,0x05,0x00,0x02,deviceId,0x04,port]))
264 |
265 | def rgbledDisplay(self,port,slot,index,red,green,blue):
266 | self.__writePackage(bytearray([0xff,0x55,0x9,0x0,0x2,0x8,port,slot,index,int(red),int(green),int(blue)]))
267 |
268 | def rgbledShow(self,port,slot):
269 | self.__writePackage(bytearray([0xff,0x55,0x5,0x0,0x2,19,port,slot]))
270 |
271 | def sevenSegmentDisplay(self,port,value):
272 | self.__writePackage(bytearray([0xff,0x55,0x8,0x0,0x2,9,port]+self.float2bytes(value)))
273 |
274 | def ledMatrixMessage(self,port,x,y,message):
275 | arr = list(message);
276 | for i in range(len(arr)):
277 | arr[i] = ord(arr[i]);
278 | self.__writePackage(bytearray([0xff,0x55,8+len(arr),0,0x2,41,port,1,self.char2byte(x),self.char2byte(7-y),len(arr)]+arr))
279 |
280 | def ledMatrixDisplay(self,port,x,y,buffer):
281 | self.__writePackage(bytearray([0xff,0x55,7+len(buffer),0,0x2,41,port,2,x,7-y]+buffer))
282 |
283 | def shutterOn(self,port):
284 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,1]))
285 |
286 | def shutterOff(self,port):
287 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,2]))
288 |
289 | def focusOn(self,port):
290 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,3]))
291 |
292 | def focusOff(self,port):
293 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,4]))
294 |
295 | def onParse(self, byte):
296 | position = 0
297 | value = 0
298 | self.buffer+=[byte]
299 | bufferLength = len(self.buffer)
300 | if bufferLength >= 2:
301 | if (self.buffer[bufferLength-1]==0x55 and self.buffer[bufferLength-2]==0xff):
302 | self.isParseStart = True
303 | self.isParseStartIndex = bufferLength-2
304 | if (self.buffer[bufferLength-1]==0xa and self.buffer[bufferLength-2]==0xd and self.isParseStart==True):
305 | self.isParseStart = False
306 | position = self.isParseStartIndex+2
307 | extID = self.buffer[position]
308 | position+=1
309 | type = self.buffer[position]
310 | position+=1
311 | # 1 byte 2 float 3 short 4 len+string 5 double
312 | if type == 1:
313 | value = self.buffer[position]
314 | if type == 2:
315 | value = self.readFloat(position)
316 | if(value<-512 or value>1023):
317 | value = 0
318 | if type == 3:
319 | value = self.readShort(position)
320 | if type == 4:
321 | value = self.readString(position)
322 | if type == 5:
323 | value = self.readDouble(position)
324 | if type == 6:
325 | value = self.readLong(position)
326 | if(type<=6):
327 | self.responseValue(extID,value)
328 | self.buffer = []
329 |
330 | def readFloat(self, position):
331 | v = [self.buffer[position], self.buffer[position+1],self.buffer[position+2],self.buffer[position+3]]
332 | return struct.unpack(' '3':
379 | PY3 = True
380 | print("\r\nVersion:" + sys.version)
381 | from megapi_python3 import *
382 | else:
383 | PY3 = False
384 | print("\r\nVersion:" + sys.version)
385 | from megapi_python2 import *
386 |
--------------------------------------------------------------------------------
/src/megapi_python2.py:
--------------------------------------------------------------------------------
1 | import serial
2 | import sys,time,math,random
3 | import signal
4 | from time import ctime,sleep
5 | import glob,struct
6 | from multiprocessing import Process,Manager,Array
7 | import threading
8 |
9 | class mSerial():
10 | ser = None
11 | def __init__(self):
12 | print self
13 |
14 | def start(self, port='/dev/ttyAMA0'):
15 | self.ser = serial.Serial(port,115200,timeout=10)
16 |
17 | def device(self):
18 | return self.ser
19 |
20 | def serialPorts(self):
21 | if sys.platform.startswith('win'):
22 | ports = ['COM%s' % (i + 1) for i in range(256)]
23 | elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
24 | ports = glob.glob('/dev/tty[A-Za-z]*')
25 | elif sys.platform.startswith('darwin'):
26 | ports = glob.glob('/dev/tty.*')
27 | else:
28 | raise EnvironmentError('Unsupported platform')
29 | result = []
30 | for port in ports:
31 | s = serial.Serial()
32 | s.port = port
33 | s.close()
34 | result.append(port)
35 | return result
36 |
37 | def writePackage(self,package):
38 | self.ser.write(package)
39 | sleep(0.01)
40 |
41 | def read(self):
42 | return self.ser.read()
43 |
44 | def isOpen(self):
45 | return self.ser.isOpen()
46 |
47 | def inWaiting(self):
48 | return self.ser.inWaiting()
49 |
50 | def close(self):
51 | self.ser.close()
52 | M1 = 9
53 | M2 = 10
54 | A0 = 14
55 | A1 = 15
56 | A2 = 16
57 | A3 = 17
58 | A4 = 18
59 | A6 = 19
60 | A7 = 20
61 | A8 = 21
62 | A9 = 22
63 | A10 = 23
64 | A11 = 24
65 |
66 | class MegaPi():
67 | def __init__(self):
68 | print "init MegaPi"
69 | signal.signal(signal.SIGINT, self.exit)
70 | self.manager = Manager()
71 | self.__selectors = self.manager.dict()
72 | self.buffer = []
73 | self.bufferIndex = 0
74 | self.isParseStart = False
75 | self.exiting = False
76 | self.isParseStartIndex = 0
77 |
78 | def __del__(self):
79 | self.exiting = True
80 |
81 | def start(self,port='/dev/ttyAMA0'):
82 | self.device = mSerial()
83 | self.device.start(port)
84 | sys.excepthook = self.excepthook
85 | th = threading.Thread(target=self.__onRead,args=(self.onParse,))
86 | th.start()
87 |
88 | def excepthook(self, exctype, value, traceback):
89 | self.close()
90 |
91 | def close(self):
92 | self.device.close()
93 |
94 | def exit(self, signal, frame):
95 | self.exiting = True
96 | sys.exit(0)
97 |
98 | def __onRead(self,callback):
99 | while True:
100 | if(self.exiting==True):
101 | break
102 | try:
103 | if self.device.isOpen()==True:
104 | n = self.device.inWaiting()
105 | for i in range(n):
106 | r = ord(self.device.read())
107 | callback(r)
108 | sleep(0.01)
109 | else:
110 | sleep(0.5)
111 | except Exception,ex:
112 | print str(ex)
113 | self.close()
114 | sleep(1)
115 | def __writePackage(self,pack):
116 | self.device.writePackage(pack)
117 |
118 | def __writeRequestPackage(self,deviceId,port,callback):
119 | extId = ((port<<4)+deviceId)&0xff
120 | self.__doCallback(extId,callback)
121 | self.__writePackage(bytearray([0xff,0x55,0x4,extId,0x1,deviceId,port]))
122 |
123 | def digitalRead(self,pin,callback):
124 | self.__writeRequestPackage(0x1e,pin,callback)
125 |
126 | def analogRead(self,pin,callback):
127 | self.__writeRequestPackage(0x1f,pin,callback)
128 |
129 | def lightSensorRead(self,port,callback):
130 | self.__writeRequestPackage(4,port,callback)
131 |
132 | def ultrasonicSensorRead(self,port,callback):
133 | self.__writeRequestPackage(1,port,callback)
134 |
135 | def lineFollowerRead(self,port,callback):
136 | self.__writeRequestPackage(17,port,callback)
137 |
138 | def soundSensorRead(self,port,callback):
139 | self.__writeRequestPackage(7,port,callback)
140 |
141 | def pirMotionSensorRead(self,port,callback):
142 | self.__writeRequestPackage(15,port,callback)
143 |
144 | def potentiometerRead(self,port,callback):
145 | self.__writeRequestPackage(4,port,callback)
146 |
147 | def limitSwitchRead(self,port,callback):
148 | self.__writeRequestPackage(21,port,callback)
149 |
150 | def temperatureRead(self,port,callback):
151 | self.__writeRequestPackage(2,port,callback)
152 |
153 | def touchSensorRead(self,port,callback):
154 | self.__writeRequestPackage(15,port,callback)
155 |
156 | def humitureSensorRead(self,port,type,callback):
157 | deviceId = 23;
158 | extId = ((port<<4)+deviceId)&0xff
159 | self.__doCallback(extId,callback)
160 | self.__writePackage(bytearray([0xff,0x55,0x5,extId,0x1,deviceId,port,type]))
161 |
162 | def joystickRead(self,port,axis,callback):
163 | deviceId = 5;
164 | extId = (((port+axis)<<4)+deviceId)&0xff
165 | self.__doCallback(extId,callback)
166 | self.__writePackage(bytearray([0xff,0x55,0x5,extId,0x1,deviceId,port,axis]))
167 |
168 | def gasSensorRead(self,port,callback):
169 | self.__writeRequestPackage(25,port,callback)
170 |
171 | def flameSensorRead(self,port,callback):
172 | self.__writeRequestPackage(24,port,callback)
173 |
174 | def compassRead(self,port,callback):
175 | self.__writeRequestPackage(26,port,callback)
176 |
177 | def angularSensorRead(self,port,slot,callback):
178 | self.__writeRequestPackage(28,port,callback)
179 |
180 | def buttonRead(self,port,callback):
181 | self.__writeRequestPackage(22,port,callback)
182 |
183 | def gyroRead(self,port,axis,callback):
184 | deviceId = 6;
185 | extId = (((port+axis)<<4)+deviceId)&0xff
186 | self.__doCallback(extId,callback)
187 | self.__writePackage(bytearray([0xff,0x55,0x5,extId,0x1,deviceId,port,axis]))
188 |
189 | def pressureSensorBegin(self):
190 | self.__writePackage(bytearray([0xff,0x55,0x3,0x0,0x2,29]))
191 |
192 | def pressureSensorRead(self,type,callback):
193 | self.__writeRequestPackage(29,type,callback)
194 |
195 | def digitalWrite(self,pin,level):
196 | self.__writePackage(bytearray([0xff,0x55,0x5,0x0,0x2,0x1e,pin,level]))
197 |
198 | def pwmWrite(self,pin,pwm):
199 | self.__writePackage(bytearray([0xff,0x55,0x5,0x0,0x2,0x20,pin,pwm]))
200 |
201 | def motorRun(self,port,speed):
202 | self.__writePackage(bytearray([0xff,0x55,0x6,0x0,0x2,0xa,port]+self.short2bytes(speed)))
203 |
204 | def motorMove(self,leftSpeed,rightSpeed):
205 | self.__writePackage(bytearray([0xff,0x55,0x7,0x0,0x2,0x5]+self.short2bytes(-leftSpeed)+self.short2bytes(rightSpeed)))
206 |
207 | def servoRun(self,port,slot,angle):
208 | self.__writePackage(bytearray([0xff,0x55,0x6,0x0,0x2,0xb,port,slot,angle]))
209 |
210 | def encoderMotorRun(self,slot,speed):
211 | deviceId = 62;
212 | self.__writePackage(bytearray([0xff,0x55,0x07,0x00,0x02,deviceId,0x02,slot]+self.short2bytes(speed)))
213 |
214 | def encoderMotorMove(self,slot,speed,distance,callback):
215 | deviceId = 62;
216 | extId = ((slot<<4)+deviceId)&0xff
217 | self.__doCallback(extId,callback)
218 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x01,slot]+self.long2bytes(distance)+self.short2bytes(speed)))
219 |
220 | def encoderMotorMoveTo(self,slot,speed,distance,callback):
221 | deviceId = 62;
222 | extId = ((slot<<4)+deviceId)&0xff
223 | self.__doCallback(extId,callback)
224 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x06,slot]+self.long2bytes(distance)+self.short2bytes(speed)))
225 |
226 | def encoderMotorSetCurPosZero(self,slot):
227 | deviceId = 62;
228 | self.__writePackage(bytearray([0xff,0x55,0x05,0x00,0x02,deviceId,0x04,slot]))
229 |
230 | def encoderMotorPosition(self,slot,callback):
231 | deviceId = 61;
232 | extId = ((slot<<4)+deviceId)&0xff
233 | self.__doCallback(extId,callback)
234 | self.__writePackage(bytearray([0xff,0x55,0x06,extId,0x01,deviceId,0x00,slot,0x01]))
235 |
236 | def encoderMotorSpeed(self,slot,callback):
237 | deviceId = 61;
238 | extId = ((slot<<4)+deviceId)&0xff
239 | self.__doCallback(extId,callback)
240 | self.__writePackage(bytearray([0xff,0x55,0x06,extId,0x01,deviceId,0x00,slot,0x02]))
241 |
242 | def stepperMotorRun(self,slot,speed):
243 | deviceId = 76;
244 | self.__writePackage(bytearray([0xff,0x55,0x07,0x00,0x02,deviceId,0x02,slot]+self.short2bytes(speed)))
245 |
246 | def stepperMotorMove(self,port,speed,distance,callback):
247 | deviceId = 76;
248 | extId = ((port<<4)+deviceId)&0xff
249 | self.__doCallback(extId,callback)
250 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x01,port]+self.long2bytes(distance)+self.short2bytes(speed)))
251 |
252 | def stepperMotorMoveTo(self,port,speed,distance,callback):
253 | deviceId = 76;
254 | extId = ((port<<4)+deviceId)&0xff
255 | self.__doCallback(extId,callback)
256 | self.__writePackage(bytearray([0xff,0x55,0x0b,extId,0x02,deviceId,0x06,port]+self.long2bytes(distance)+self.short2bytes(speed)))
257 |
258 | def stepperMotorSetCurPosZero(self,port):
259 | deviceId = 76;
260 | self.__writePackage(bytearray([0xff,0x55,0x05,0x00,0x02,deviceId,0x04,port]))
261 |
262 | def rgbledDisplay(self,port,slot,index,red,green,blue):
263 | self.__writePackage(bytearray([0xff,0x55,0x9,0x0,0x2,0x8,port,slot,index,int(red),int(green),int(blue)]))
264 |
265 | def rgbledShow(self,port,slot):
266 | self.__writePackage(bytearray([0xff,0x55,0x5,0x0,0x2,19,port,slot]))
267 |
268 | def sevenSegmentDisplay(self,port,value):
269 | self.__writePackage(bytearray([0xff,0x55,0x8,0x0,0x2,9,port]+self.float2bytes(value)))
270 |
271 | def ledMatrixMessage(self,port,x,y,message):
272 | arr = list(message);
273 | for i in range(len(arr)):
274 | arr[i] = ord(arr[i]);
275 | self.__writePackage(bytearray([0xff,0x55,8+len(arr),0,0x2,41,port,1,self.char2byte(x),self.char2byte(7-y),len(arr)]+arr))
276 |
277 | def ledMatrixDisplay(self,port,x,y,buffer):
278 | self.__writePackage(bytearray([0xff,0x55,7+len(buffer),0,0x2,41,port,2,x,7-y]+buffer))
279 |
280 | def shutterOn(self,port):
281 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,1]))
282 |
283 | def shutterOff(self,port):
284 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,2]))
285 |
286 | def focusOn(self,port):
287 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,3]))
288 |
289 | def focusOff(self,port):
290 | self.__writePackage(bytearray([0xff,0x55,0x5,0,0x3,20,port,4]))
291 |
292 | def onParse(self, byte):
293 | position = 0
294 | value = 0
295 | self.buffer+=[byte]
296 | bufferLength = len(self.buffer)
297 | if bufferLength >= 2:
298 | if (self.buffer[bufferLength-1]==0x55 and self.buffer[bufferLength-2]==0xff):
299 | self.isParseStart = True
300 | self.isParseStartIndex = bufferLength-2
301 | if (self.buffer[bufferLength-1]==0xa and self.buffer[bufferLength-2]==0xd and self.isParseStart==True):
302 | self.isParseStart = False
303 | position = self.isParseStartIndex+2
304 | extID = self.buffer[position]
305 | position+=1
306 | type = self.buffer[position]
307 | position+=1
308 | # 1 byte 2 float 3 short 4 len+string 5 double
309 | if type == 1:
310 | value = self.buffer[position]
311 | if type == 2:
312 | value = self.readFloat(position)
313 | if(value<-512 or value>1023):
314 | value = 0
315 | if type == 3:
316 | value = self.readShort(position)
317 | if type == 4:
318 | value = self.readString(position)
319 | if type == 5:
320 | value = self.readDouble(position)
321 | if type == 6:
322 | value = self.readLong(position)
323 | if(type<=6):
324 | self.responseValue(extID,value)
325 | self.buffer = []
326 |
327 | def readFloat(self, position):
328 | v = [self.buffer[position], self.buffer[position+1],self.buffer[position+2],self.buffer[position+3]]
329 | return struct.unpack('= 2:
298 | if (self.buffer[bufferLength-1]==0x55 and self.buffer[bufferLength-2]==0xff):
299 | self.isParseStart = True
300 | self.isParseStartIndex = bufferLength-2
301 | if (self.buffer[bufferLength-1]==0xa and self.buffer[bufferLength-2]==0xd and self.isParseStart==True):
302 | self.isParseStart = False
303 | position = self.isParseStartIndex+2
304 | extID = self.buffer[position]
305 | position+=1
306 | type = self.buffer[position]
307 | position+=1
308 | # 1 byte 2 float 3 short 4 len+string 5 double
309 | if type == 1:
310 | value = self.buffer[position]
311 | if type == 2:
312 | value = self.readFloat(position)
313 | if(value<-512 or value>1023):
314 | value = 0
315 | if type == 3:
316 | value = self.readShort(position)
317 | if type == 4:
318 | value = self.readString(position)
319 | if type == 5:
320 | value = self.readDouble(position)
321 | if type == 6:
322 | value = self.readLong(position)
323 | if(type<=6):
324 | self.responseValue(extID,value)
325 | self.buffer = []
326 |
327 | def readFloat(self, position):
328 | v = [self.buffer[position], self.buffer[position+1],self.buffer[position+2],self.buffer[position+3]]
329 | return struct.unpack('