Mercurial Repositories > eric / file comparison

comparison: src/eric7/MicroPython/Devices/DeviceBase.py

src/eric7/MicroPython/Devices/DeviceBase.py

branch
eric7
changeset 9844
2f3d623f7617
parent 9829
cafb132fe3bb
child 9847
d8c7ded575cb
equal deleted inserted replaced
9843:72e8270a5940 9844:2f3d623f7617
662 print(remove_file('{0}', {1}, {2})) 662 print(remove_file('{0}', {1}, {2}))
663 del __os_, remove_file 663 del __os_, remove_file
664 """.format( 664 """.format(
665 name, recursive, force 665 name, recursive, force
666 ) 666 )
667 out, err = self._interface.execute(command, mode=self._submitMode) 667 out, err = self._interface.execute(
668 command, mode=self._submitMode, timeout=20000
669 )
668 if err: 670 if err:
669 raise OSError(self._shortError(err)) 671 raise OSError(self._shortError(err))
670 return ast.literal_eval(out.decode("utf-8")) 672 return ast.literal_eval(out.decode("utf-8"))
671 673
672 return False 674 return False
911 @return dictionary containing the determined data 913 @return dictionary containing the determined data
912 @rtype dict 914 @rtype dict
913 @exception OSError raised to indicate an issue with the device 915 @exception OSError raised to indicate an issue with the device
914 """ 916 """
915 command = """ 917 command = """
916 res = {} 918 def get_device_data():
917 919 res = {}
918 import os as __os_ 920
919 uname = __os_.uname() 921 import os
920 res['sysname'] = uname.sysname 922 uname = os.uname()
921 res['nodename'] = uname.nodename 923 res['sysname'] = uname.sysname
922 res['release'] = uname.release 924 res['nodename'] = uname.nodename
923 res['version'] = uname.version 925 res['release'] = uname.release
924 res['machine'] = uname.machine 926 res['version'] = uname.version
925 927 res['machine'] = uname.machine
926 import sys as __sys_ 928
927 res['py_platform'] = __sys_.platform 929 import sys
928 res['py_version'] = __sys_.version 930 res['py_platform'] = sys.platform
929 931 res['py_version'] = sys.version
930 try: 932
931 res['mpy_name'] = __sys_.implementation.name
932 except AttributeError:
933 res['mpy_name'] = 'unknown'
934
935 try:
936 res['mpy_version'] = '.'.join((str(i) for i in __sys_.implementation.version))
937 except AttributeError:
938 res['mpy_version'] = 'unknown'
939
940 try:
941 import pimoroni as __pimoroni_
942 res['mpy_variant'] = 'Pimoroni Pico'
943 try: 933 try:
944 import version as __version_ 934 res['mpy_name'] = sys.implementation.name
945 res['mpy_variant_info'] = __version_.BUILD 935 except AttributeError:
946 res['mpy_variant_version'] = __version_.BUILD.split('-')[2][1:] 936 res['mpy_name'] = 'unknown'
947 del __version_ 937
938 try:
939 res['mpy_version'] = '.'.join((str(i) for i in sys.implementation.version))
940 except AttributeError:
941 res['mpy_version'] = 'unknown'
942
943 try:
944 import pimoroni
945 res['mpy_variant'] = 'Pimoroni Pico'
946 try:
947 import version
948 res['mpy_variant_info'] = version.BUILD
949 res['mpy_variant_version'] = version.BUILD.split('-')[2][1:]
950 except ImportError:
951 res['mpy_variant_info'] = ''
952 res['mpy_variant_version'] = ''
948 except ImportError: 953 except ImportError:
954 res['mpy_variant'] = ''
949 res['mpy_variant_info'] = '' 955 res['mpy_variant_info'] = ''
950 res['mpy_variant_version'] = '' 956 res['mpy_variant_version'] = ''
951 del __pimoroni_ 957
952 except ImportError: 958 res['mip'] = False
953 res['mpy_variant'] = '' 959 res['upip'] = False
954 res['mpy_variant_info'] = '' 960 try:
955 res['mpy_variant_version'] = '' 961 import mip
956 962 res['mip'] = True
957 print(res) 963 except ImportError:
958 del res, uname, __os_, __sys_ 964 try:
965 import upip
966 res['upip'] = True
967 except ImportError:
968 pass
969
970 return res
971
972 print(get_device_data())
973 del get_device_data
959 """ 974 """
960 out, err = self._interface.execute(command, mode=self._submitMode) 975 out, err = self._interface.execute(command, mode=self._submitMode)
961 if err: 976 if err:
962 raise OSError(self._shortError(err)) 977 raise OSError(self._shortError(err))
963 return ast.literal_eval(out.decode("utf-8")) 978 return ast.literal_eval(out.decode("utf-8"))
969 @return dictionary containing the determined data 984 @return dictionary containing the determined data
970 @rtype dict 985 @rtype dict
971 @exception OSError raised to indicate an issue with the device 986 @exception OSError raised to indicate an issue with the device
972 """ 987 """
973 command = """ 988 command = """
974 res = {} 989 def get_board_info():
975 990 res = {}
976 import gc as __gc_ 991
977 __gc_.enable() 992 import gc
978 __gc_.collect() 993 gc.enable()
979 mem_alloc = __gc_.mem_alloc() 994 gc.collect()
980 mem_free = __gc_.mem_free() 995 mem_alloc = gc.mem_alloc()
981 mem_total = mem_alloc + mem_free 996 mem_free = gc.mem_free()
982 res['mem_total_kb'] = mem_total / 1024.0 997 mem_total = mem_alloc + mem_free
983 res['mem_used_kb'] = mem_alloc / 1024.0 998 res['mem_total_kb'] = mem_total / 1024.0
984 res['mem_used_pc'] = mem_alloc / mem_total * 100.0 999 res['mem_used_kb'] = mem_alloc / 1024.0
985 res['mem_free_kb'] = mem_free / 1024.0 1000 res['mem_used_pc'] = mem_alloc / mem_total * 100.0
986 res['mem_free_pc'] = mem_free / mem_total * 100.0 1001 res['mem_free_kb'] = mem_free / 1024.0
987 del __gc_, mem_alloc, mem_free, mem_total 1002 res['mem_free_pc'] = mem_free / mem_total * 100.0
988 1003 del gc, mem_alloc, mem_free, mem_total
989 import os as __os_ 1004
990 uname = __os_.uname() 1005 import os
991 res['sysname'] = uname.sysname 1006 uname = os.uname()
992 res['nodename'] = uname.nodename 1007 res['sysname'] = uname.sysname
993 res['release'] = uname.release 1008 res['nodename'] = uname.nodename
994 res['version'] = uname.version 1009 res['release'] = uname.release
995 res['machine'] = uname.machine 1010 res['version'] = uname.version
996 1011 res['machine'] = uname.machine
997 import sys as __sys_ 1012
998 res['py_platform'] = __sys_.platform 1013 import sys
999 res['py_version'] = __sys_.version 1014 res['py_platform'] = sys.platform
1000 1015 res['py_version'] = sys.version
1001 try: 1016
1002 res['mpy_name'] = __sys_.implementation.name
1003 except AttributeError:
1004 res['mpy_name'] = 'unknown'
1005 try:
1006 res['mpy_version'] = '.'.join((str(i) for i in __sys_.implementation.version))
1007 except AttributeError:
1008 res['mpy_version'] = 'unknown'
1009 try:
1010 import pimoroni as __pimoroni_
1011 res['mpy_variant'] = 'Pimoroni Pico'
1012 try: 1017 try:
1013 import version as __version_ 1018 res['mpy_name'] = sys.implementation.name
1014 res['mpy_variant_info'] = __version_.BUILD 1019 except AttributeError:
1015 res['mpy_variant_version'] = __version_.BUILD.split('-')[2][1:] 1020 res['mpy_name'] = 'unknown'
1016 del __version_ 1021 try:
1022 res['mpy_version'] = '.'.join((str(i) for i in sys.implementation.version))
1023 except AttributeError:
1024 res['mpy_version'] = 'unknown'
1025 try:
1026 import pimoroni
1027 res['mpy_variant'] = 'Pimoroni Pico'
1028 try:
1029 import version
1030 res['mpy_variant_info'] = version.BUILD
1031 res['mpy_variant_version'] = version.BUILD.split('-')[2][1:]
1032 except ImportError:
1033 res['mpy_variant_info'] = ''
1034 res['mpy_variant_version'] = ''
1017 except ImportError: 1035 except ImportError:
1036 res['mpy_variant'] = ''
1018 res['mpy_variant_info'] = '' 1037 res['mpy_variant_info'] = ''
1019 res['mpy_variant_version'] = '' 1038 res['mpy_variant_version'] = ''
1020 del __pimoroni_ 1039
1021 except ImportError:
1022 res['mpy_variant'] = ''
1023 res['mpy_variant_info'] = ''
1024 res['mpy_variant_version'] = ''
1025
1026 try:
1027 stat_ = __os_.statvfs('/flash')
1028 res['flash_info_available'] = True
1029 res['flash_total_kb'] = stat_[2] * stat_[0] / 1024.0
1030 res['flash_free_kb'] = stat_[3] * stat_[0] / 1024.0
1031 res['flash_used_kb'] = res['flash_total_kb'] - res['flash_free_kb']
1032 res['flash_free_pc'] = res['flash_free_kb'] / res['flash_total_kb'] * 100.0
1033 res['flash_used_pc'] = res['flash_used_kb'] / res['flash_total_kb'] * 100.0
1034 del stat_
1035 except AttributeError:
1036 res['flash_info_available'] = False
1037
1038 try:
1039 import machine as __mc_
1040 if isinstance(__mc_.freq(), tuple):
1041 res['mc_frequency_mhz'] = __mc_.freq()[0] / 1000000.0
1042 else:
1043 res['mc_frequency_mhz'] = __mc_.freq() / 1000000.0
1044 res['mc_id'] = __mc_.unique_id()
1045 del __mc_
1046 except ImportError:
1047 try: 1040 try:
1048 import microcontroller as __mc_ 1041 stat_ = os.statvfs('/flash')
1049 res['mc_frequency_mhz'] = __mc_.cpu.frequency / 1000000.0 1042 res['flash_info_available'] = True
1050 res['mc_temp_c'] = __mc_.cpu.temperature 1043 res['flash_total_kb'] = stat_[2] * stat_[0] / 1024.0
1051 res['mc_id'] = __mc_.cpu.uid 1044 res['flash_free_kb'] = stat_[3] * stat_[0] / 1024.0
1052 del __mc_ 1045 res['flash_used_kb'] = res['flash_total_kb'] - res['flash_free_kb']
1046 res['flash_free_pc'] = res['flash_free_kb'] / res['flash_total_kb'] * 100.0
1047 res['flash_used_pc'] = res['flash_used_kb'] / res['flash_total_kb'] * 100.0
1048 except AttributeError:
1049 res['flash_info_available'] = False
1050
1051 try:
1052 import machine as mc
1053 if isinstance(mc.freq(), tuple):
1054 res['mc_frequency_mhz'] = mc.freq()[0] / 1000000.0
1055 else:
1056 res['mc_frequency_mhz'] = mc.freq() / 1000000.0
1057 res['mc_id'] = mc.unique_id()
1053 except ImportError: 1058 except ImportError:
1054 res['mc_frequency'] = None 1059 try:
1055 res['mc_temp'] = None 1060 import microcontroller as mc
1056 if 'mc_id' in res: 1061 res['mc_frequency_mhz'] = mc.cpu.frequency / 1000000.0
1057 res['mc_id'] = ':'.join('{0:02X}'.format(x) for x in res['mc_id']) 1062 res['mc_temp_c'] = mc.cpu.temperature
1058 1063 res['mc_id'] = mc.cpu.uid
1059 try: 1064 except ImportError:
1060 import ulab as __ulab_ 1065 res['mc_frequency'] = None
1061 res['ulab'] = __ulab_.__version__ 1066 res['mc_temp'] = None
1062 del __ulab_ 1067 if 'mc_id' in res:
1063 except ImportError: 1068 res['mc_id'] = ':'.join('{0:02X}'.format(x) for x in res['mc_id'])
1064 res['ulab'] = None 1069
1065 1070 try:
1066 print(res) 1071 import ulab
1067 del res, __os_, __sys_, uname 1072 res['ulab'] = ulab.__version__
1073 except ImportError:
1074 res['ulab'] = None
1075
1076 return res
1077
1078 print(get_board_info())
1079 del get_board_info
1068 """ 1080 """
1069 out, err = self._interface.execute(command, mode=self._submitMode) 1081 out, err = self._interface.execute(command, mode=self._submitMode)
1070 if err: 1082 if err:
1071 raise OSError(self._shortError(err)) 1083 raise OSError(self._shortError(err))
1072 return ast.literal_eval(out.decode("utf-8")) 1084 return ast.literal_eval(out.decode("utf-8"))
1100 @return time of the device 1112 @return time of the device
1101 @rtype str 1113 @rtype str
1102 @exception OSError raised to indicate an issue with the device 1114 @exception OSError raised to indicate an issue with the device
1103 """ 1115 """
1104 command = """ 1116 command = """
1105 try: 1117 def get_time():
1106 import rtc as __rtc_
1107 print(
1108 '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'
1109 .format(*__rtc_.RTC().datetime[:6])
1110 )
1111 del __rtc_
1112 except:
1113 import time as __time_
1114 try: 1118 try:
1115 print(__time_.strftime('%Y-%m-%d %H:%M:%S', __time_.localtime())) 1119 import rtc
1116 except AttributeError:
1117 tm = __time_.localtime()
1118 print( 1120 print(
1119 '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}' 1121 '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'
1120 .format(tm[0], tm[1], tm[2], tm[3], tm[4], tm[5]) 1122 .format(*rtc.RTC().datetime[:6])
1121 ) 1123 )
1122 del tm 1124 except:
1123 del __time_ 1125 import time
1126 try:
1127 print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
1128 except AttributeError:
1129 tm = time.localtime()
1130 print(
1131 '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'
1132 .format(tm[0], tm[1], tm[2], tm[3], tm[4], tm[5])
1133 )
1134
1135 get_time()
1136 del get_time
1124 """ 1137 """
1125 out, err = self._interface.execute(command, mode=self._submitMode) 1138 out, err = self._interface.execute(command, mode=self._submitMode)
1126 if err: 1139 if err:
1127 if b"NotImplementedError" in err: 1140 if b"NotImplementedError" in err:
1128 return "<unsupported> <unsupported>" 1141 return "<unsupported> <unsupported>"
1197 out, err = self._interface.execute(command, mode=self._submitMode) 1210 out, err = self._interface.execute(command, mode=self._submitMode)
1198 if err: 1211 if err:
1199 raise OSError(self._shortError(err)) 1212 raise OSError(self._shortError(err))
1200 1213
1201 ################################################################## 1214 ##################################################################
1215 ## Methods below implement package management related methods
1216 ##################################################################
1217
1218 def upipInstall(self, packages):
1219 """
1220 Public method to install packages using 'upip'.
1221
1222 @return tuple containing the command output and errors
1223 @return tuple of (str, str)
1224 """
1225 command = """
1226 def upip_install():
1227 import upip
1228 upip.install({0})
1229
1230 upip_install()
1231 del upip_install
1232 """.format(repr(packages))
1233 return self._interface.execute(command, mode=self._submitMode, timeout=60000)
1234
1235 def mipInstall(self, package, version, mpy):
1236 """
1237 Public method
1238
1239 @param package package name
1240 @type str
1241 @param version package version
1242 @type str
1243 @param mpy flag indicating to install as '.mpy' file
1244 @type bool
1245 @return tuple containing the command output and errors
1246 @return tuple of (str, str)
1247 """
1248 parameterStr = repr(package)
1249 if version:
1250 parameterStr += ", version={0}".format(repr(version))
1251 if not mpy:
1252 parameterStr += ", mpy=False"
1253
1254 command = """
1255 def mip_install():
1256 import mip
1257 mip.install({0})
1258
1259 mip_install()
1260 del mip_install
1261 """.format(parameterStr)
1262 return self._interface.execute(command, mode=self._submitMode, timeout=60000)
1263
1264 ##################################################################
1202 ## Methods below implement WiFi related methods 1265 ## Methods below implement WiFi related methods
1203 ################################################################## 1266 ##################################################################
1204 1267
1205 def hasWifi(self): 1268 def hasWifi(self):
1206 """ 1269 """

Mercurial Repository: eric

eric ide

mercurial