#endif
/**
- * ºô½ÐÁ÷³Ì: ¼ÙÉè `É豸A' ºô½Ð `É豸B'
+ * 呼叫流程: 假设 `设备A' 呼叫 `设备B'
*
- * Æô¶¯Á¬½ÓÁ÷³Ì
- * - A ÐèÒª "ijÖÖÍÆËÍ»úÖÆ" (³¤Á¬½Ó,ÍÆËÍ·½Ê½) ֪ͨµ½B,
- * - A ´ò¿ªÍ¨ÐÅ(jrtc_open), ³õʼ״̬Ϊ JRTC_OPENED
- * - B ÊÕµ½ "¸ÃÖÖÍÆËÍ֪ͨ" ºóÒ²´ò¿ªÍ¨ÐÅ(jrtc_open), ³õʼ״̬Ϊ JRTC_OPENED
- * - A Ö÷¶¯¼¤»îýÌåÉ豸,ÒÔ±ã×Ô¶¯½ÓÌý
+ * 启动连接流程
+ * - A 需要 "某种推送机制" (长连接,推送方式) 通知到B,
+ * - A 打开通信(jrtc_open), 初始状态为 JRTC_OPENED
+ * - B 收到 "该种推送通知" 后也打开通信(jrtc_open), 初始状态为 JRTC_OPENED
+ * - A 主动激活媒体设备,以便自动接听
* jrtc_activate(jc, JRTC_AUDIO|JRTC_CAMERA)
*
- * ³É¹¦½¨Á¢ÍøÂçͨµÀ
- * - A ºÍ B ÔÚ·þÎñÆ÷É϶ԺôºóÁ¬Í¨, ͨ»°×´Ì¬¶¼±äΪ JRTC_JOINED
- * - A ¿ÉÒÔ¿ªÊ¼äÖȾ¾µÍ·Ô¤ÀÀ(äÖȾÁ÷³Ì)
+ * 成功建立网络通道
+ * - A 和 B 在服务器上对呼后连通, 通话状态都变为 JRTC_JOINED
+ * - A 可以开始渲染镜头预览(渲染流程)
*
- * ±»½ÐÁ÷³Ì
- * - B ÊÕµ½AµÄÒôÊÓƵÊý¾Ý, ͨ»°×´Ì¬±äΪ JRTC_TALKING
- * - B ¿ÉÒÔ¿ªÊ¼äÖȾ¶Ô¶ËÊÓƵ(äÖȾÁ÷³Ì)
- * - B µ¯³ö½ÓÌýÌáʾ, ÈôÓû§Ñ¡Ôñ"¾Ü½Ó"Ôò½øÈë¹Ò¶ÏÁ÷³Ì
- * - B ÔÚ½çÃæÑ¡Ôñ½ÓÌýºó, Ò²¼¤»îýÌåÉ豸
+ * 被叫流程
+ * - B 收到A的音视频数据, 通话状态变为 JRTC_TALKING
+ * - B 可以开始渲染对端视频(渲染流程)
+ * - B 弹出接听提示, 若用户选择"拒接"则进入挂断流程
+ * - B 在界面选择接听后, 也激活媒体设备
* jrtc_activate(jc,JRTC_AUDIO|JRTC_CAMERA)
*
- * Ö÷½ÐÁ÷³Ì
- * - A ÔÚÊÕµ½ÒôÊÓƵÊý¾Ýºó, ״̬±äΪJRTC_TALKING
- * - A Ò²¿ªÊ¼äÖȾ¶Ô¶ËÊÓƵ(äÖȾÁ÷³Ì)
+ * 主叫流程
+ * - A 在收到音视频数据后, 状态变为JRTC_TALKING
+ * - A 也开始渲染对端视频(渲染流程)
*
- * ¹Ò¶ÏÁ÷³Ì
- * - A µ÷Óà jrtc_close Ö÷¶¯¹Ò¶Ï
- * - B ͨ»°×´Ì¬½«±äΪ JRTC_LEAVING »ò JRTC_CLOSED
- * - ͨ¹ý jrtc_error() ¿ÉÒÔ»ñÈ¡¹Ò¶ÏµÄÔÒò(³ö´íÖµ)
- * - B µ÷Óà jrtc_close ½áÊøͨ»°
+ * 挂断流程
+ * - A 调用 jrtc_close 主动挂断
+ * - B 通话状态将变为 JRTC_LEAVING 或 JRTC_CLOSED
+ * - 通过 jrtc_error() 可以获取挂断的原因(出错值)
+ * - B 调用 jrtc_close 结束通话
*
- * ×î¼òº¯ÊýÁ÷³Ì
- * - jrtc_config(...); // ÅäÖû·¾³,Ö»Ðèµ÷ÓÃÒ»´Î
- * - jc = jrtc_open(...);// ´ò¿ªÍ¨»°,·µ»Ø¶ÔÏó
- * - jrtc_activate(jc,JRTC_AUDIO|JRTC_CAMERA);//¼¤»îÉ豸
- * - ÔÚ UI Ïß³Ì,¸üÐÂÊÓƵ»òÔ¤ÀÀ,²Î¿¼ÏÂÃæµÄ`äÖȾÁ÷³Ì'
- * - jrtc_close(jc, JRTC_EBYE); //Ö÷¶¯¹Ò¶Ï, ²¢ÇҵȴýÍøÂçÏ߳̽áÊø
+ * 最简函数流程
+ * - jrtc_config(...); // 配置环境,只需调用一次
+ * - jc = jrtc_open(...);// 打开通话,返回对象
+ * - jrtc_activate(jc,JRTC_AUDIO|JRTC_CAMERA);//激活设备
+ * - 在 UI 线程,更新视频或预览,参考下面的`渲染流程'
+ * - jrtc_close(jc, JRTC_EBYE); //主动挂断, 并且等待网络线程结束
*
- * ÊÕµ½À´µçÖжϵĴ¦Àí
- * - jrtc_close(jc, JRTC_EAUDIOCALL);//½áÊøͨ»°,µÈ´ýÍøÂçÏ߳̽áÊø
+ * 收到来电中断的处理
+ * - jrtc_close(jc, JRTC_EAUDIOCALL);//结束通话,等待网络线程结束
*/
-/** ͨ»°×´Ì¬ */
+/** 通话状态 */
enum jrtc_state
{
- JRTC_CLOSED=0,/*< ³õʼ״̬ */
- JRTC_LEAVING, /*< jrtc_leave »òÄÚ²¿³ö´íºóµÄ״̬ */
- JRTC_OPENED, /*< µ÷ÓÃjrtc_open ºóµÄ״̬ */
- JRTC_JOINING, /*< ¼ÓÈëÖеÄ״̬ */
- JRTC_JOINED, /*< ³É¹¦¼ÓÈë»á»° */
- JRTC_TALKING, /*< ÊÕµ½Ã½ÌåºóµÄ״̬ */
+ JRTC_CLOSED=0,/*< 初始状态 */
+ JRTC_LEAVING, /*< jrtc_leave 或内部出错后的状态 */
+ JRTC_OPENED, /*< 调用jrtc_open 后的状态 */
+ JRTC_JOINING, /*< 加入中的状态 */
+ JRTC_JOINED, /*< 成功加入会话 */
+ JRTC_TALKING, /*< 收到媒体后的状态 */
};
-/** ͨ»°´íÎóÖµ */
+/** 通话错误值 */
enum jrtc_error
{
JRTC_ENIL = 0, /* unknown error */
JRTC_EBYE = 255, /* Success, Closed by peer leave */
};
-/** ͨ»°ÖеÄýÌåÉ豸 */
+/** 通话中的媒体设备 */
enum jrtc_device
{
JRTC_SPEAKER = 1,
JRTC_REMOTE_POOR = 2,
};
-/** Êý¾ÝÀàÐÍ
+/** 数据类型
* @note
- * | Èí¼þϵͳ | ƽ̨ | ²É¼¯¸ñʽ | ±àÂëºó¸ñʽ | ½âÂëºó¸ñʽ |
+ * | 软件系统 | 平台 | 采集格式 | 编码后格式 | 解码后格式 |
* | ------------ | -------- | ---------- | ---------- | ------------ |
* | Unisoc Mocor | UMS9117 | JRTC_NV16 | JRTC_JPEG | JRTC_RGB565,JRTC_JPEG [^1] |
*/
enum jrtc_dtype
{
- JRTC_I420 = 0, /*< ͼÏñ×Ö½ÚÊý=W*H*3/2 */
- JRTC_NV12 = 1, /*< ͼÏñ×Ö½ÚÊý=W*H*3/2 */
- JRTC_UYVY = 2, /*< ͼÏñ×Ö½ÚÊý=W*H*2 */
- JRTC_JPEG = 3, /*< ±£³Ö¼æÈÝÐÔ */
- JRTC_NV16 = 4, /*< ͼÏñ×Ö½ÚÊý=W*H*2 */
+ JRTC_I420 = 0, /*< 图像字节数=W*H*3/2 */
+ JRTC_NV12 = 1, /*< 图像字节数=W*H*3/2 */
+ JRTC_UYVY = 2, /*< 图像字节数=W*H*2 */
+ JRTC_JPEG = 3, /*< 保持兼容性 */
+ JRTC_NV16 = 4, /*< 图像字节数=W*H*2 */
JRTC_RGB565 = 64,
JRTC_H263 = 97,
};
-/** äÖȾÁ÷³Ì:
- * jrtc_image_t* img ´ú±í jrtc_open Öд«Èë video »ò camera
- * - ¼ì²âµ±Ç°ÎªÍ¨»°×´Ì¬, ·ñÔòÎÞÐëäÖȾ
+/** 渲染流程:
+ * jrtc_image_t* img 代表 jrtc_open 中传入 video 或 camera
+ * - 检测当前为通话状态, 否则无须渲染
* if (jrtc_state(jc) < JRTC_JOINED) break;
*
- * - ÄÚ²¿×Ô¶¯¸üÐÂͼÏñ:
+ * - 内部自动更新图像:
* if (img->get == img->put) {
- * '¸üÐÂͼÏñÄÚÈÝ: ¼´¶ÔimgÖеÄdata, width, height, format ¸³Öµ'
- * img->put++;//Ôö¼Óд¼ÆÊý
+ * '更新图像内容: 即对img中的data, width, height, format 赋值'
+ * img->put++;//增加写计数
* }
*
- * - ÉϲãUIÏß³Ì(App ½çÃæ²ã)¸ºÔð»æÖÆͼÏñ:
+ * - 上层UI线程(App 界面层)负责绘制图像:
* if (img->get != img->put) {
- * '½çÃæ»æÖƲÙ×÷: ¼´Ê¹ÓÃimgÖеÄdata, ¸üнçÃæ¿Ø¼þ'
- * img->get = img->put;//Ôö¼Ó¶Á¼ÆÊý
+ * '界面绘制操作: 即使用img中的data, 更新界面控件'
+ * img->get = img->put;//增加读计数
* }
*
- * ÔÚjrtc_open()ÖÐÓÃÓÚÉèÖý¨ÒéÖµ, ͨ»°¹ý³ÌÖÐÓÃÓÚ»ñȡͼÏñÊý¾Ý.
- * ÀýÈç, Ï£Íû½ÓÊպͷ¢ËͶ¼ÊÇ240x240, 8Ö¡/ÃëµÄÊÓƵͨ»°:
+ * 在jrtc_open()中用于设置建议值, 通话过程中用于获取图像数据.
+ * 例如, 希望接收和发送都是240x240, 8帧/秒的视频通话:
* static struct jrtc_image_t video, camera;
* video.width = camera.width = 240;
* video.height = camera.height = 240;
* video.fps = camera.fps = 8;
* video.kbps = camera.kbps = 120;
- * //×¢Òâ,ÒÔÉϽöÊǽ¨ÒéÖµ, ÔÚ×îÖÕ½Óͨʱ, ÓÉ·þÎñÆ÷¾ö¶¨Êµ¼ÊÖµ
- * //ÈôÄÚ²¿Ê¹ÓÃjpeg ±àÂë,Ôò»áºöÂÔ kbps Öµ
+ * //注意,以上仅是建议值, 在最终接通时, 由服务器决定实际值
+ * //若内部使用jpeg 编码,则会忽略 kbps 值
*
* jc = jrtc_open(roomid, 0, &video, &camera);
*/
struct jrtc_image_t
-{/* ¿ÉǿתΪ jrtc_photo_t ʹÓà */
+{/* 可强转为 jrtc_photo_t 使用 */
void* data;
unsigned bytes;
unsigned short width, height;
extern void* _jrtc_net_info;
-/** µ±Ç°µÄ°æ±¾ºÅ */
+/** 当前的版本号 */
#define JRTC_VERSION "1.7.2"
-/** ÅäÖÃÈ«¾Ö²ÎÊý,Ö»Ðèµ÷ÓÃÒ»´Î.
- * ×¢Òâ:
- * - appkey ¹Ì¶¨³¤¶ÈΪ24
- * - key ¹Ì¶¨³¤¶ÈΪ16
- * - uid ÏÞÖÆ×î´ó×Ö·ûÊýΪ64
- * - tokens ÏÞÖÆ×î´ó×Ö·ûÊýΪ128
+/** 配置全局参数,只需调用一次.
+ * 注意:
+ * - appkey 固定长度为24
+ * - key 固定长度为16
+ * - uid 限制最大字符数为64
+ * - tokens 限制最大字符数为128
*
- * @param[in] appkey µ±Ç°APPÌØÓеıêʶ, ÐèÏòJuphoonÉêÇë»ñµÃ
- * @param[in] uid ÕË»§
- * @param[in] key ͨѶÃÜÔ¿, ±ØÐëÓëappkeyÆ¥Åä, ÐèÏòJuphoonÉêÇë»ò×¢²á
- * @param[in] ÓÃÓÚ¼øȨµÄtokens,ĬÈÏΪ""
+ * @param[in] appkey 当前APP特有的标识, 需向Juphoon申请获得
+ * @param[in] uid 账户
+ * @param[in] key 通讯密钥, 必须与appkey匹配, 需向Juphoon申请或注册
+ * @param[in] 用于鉴权的tokens,默认为""
*/
void jrtc_config (const char* appkey, const char* uid, const char key[16], const char* tokens);
-/**Õ¹Èñ UIX9117 ƽ̨ ÐèÒªÉèÖÃPDPÁ÷³Ìºó»ñµÃµÄÍøÂç ID */
+/**展锐 UIX9117 平台 需要设置PDP流程后获得的网络 ID */
extern unsigned _jrtc_net_id;
-/**Õ¹Èñ UIX9117 ƽ̨µÄ¾µÍ·½Ç¶È,¼´²É¼¯Í¼ÏñÐèҪ˳ʱÕëÐýת¸ÃÖµ,²ÅÄÜÕýÁ¢. ĬÈÏ90 */
+/**展锐 UIX9117 平台的镜头角度,即采集图像需要顺时针旋转该值,才能正立. 默认90 */
extern unsigned _jrtc_cam_angle;
-/** ·ÖÅäͨ»°×ÊÔ´²¢Æô¶¯ÍøÂçÏß³Ì
- * ×¢Òâ:
- * - ¶Ôticket³¤¶ÈºÍ²ÎÊýroomid¶¼ÏÞÖÆ×î´ó×Ö·ûÊýΪ64
- * - ÄÚ²¿É豸³õʼûÓ줻î,ºóÐøÐèÒªµ÷ÈçÏ¿ªÆô
+/** 分配通话资源并启动网络线程
+ * 注意:
+ * - 对ticket长度和参数roomid都限制最大字符数为64
+ * - 内部设备初始没有激活,后续需要调如下开启
* jrtc_activate(jc,JRTC_AUDIO|JRTC_CAMERA)
*
- * ticket ×÷Ϊͨ»°ID, Ψһ±êʶÿ´Îͨ»°:
- * - ²»ÄÜ°üº¬JSONÐèתÒåµÄ×Ö·û
- * - ÿ´Îͨ»°, ҪʹÓò»Í¬µÄ ticket,(Ëæ»ú²úÉú»òÏò·þÎñÆ÷ÉêÇë)
- * - A ºô½ÐÇ°,ÉêÇë»ñµÃ ticket
- * - A ÐèҪͨ"ijÖÖÍÆËÍ»úÖÆ"(³¤Á¬½Ó,ÍÆËÍ·½Ê½) ½« ticket ֪ͨµ½B
- * - A ºÍB ¶Ôºôʱ, ±ØÐëʹÓÃÏàͬµÄticket, ÒÔ±ã·þÎñÆ÷¾«È·±êʶ»á»°
+ * ticket 作为通话ID, 唯一标识每次通话:
+ * - 不能包含JSON需转义的字符
+ * - 每次通话, 要使用不同的 ticket,(随机产生或向服务器申请)
+ * - A 呼叫前,申请获得 ticket
+ * - A 需要通"某种推送机制"(长连接,推送方式) 将 ticket 通知到B
+ * - A 和B 对呼时, 必须使用相同的ticket, 以便服务器精确标识会话
*
- * @param[in] id ¼ÓÈëÒ»¶ÔÒ»»á»°(¶Ô·½µÄuid)»ò·¿¼ä(ÒÔroom:ǰ׺µÄ·¿¼äµØÖ·)
- * @param[in] ticket hashÖµ,¿Éͨ¹ýÆäËû·¾¶»ñµÃ,ĬÈÏΪNULL,½öÓÃÓÚµ÷ÊÔ.
- * @param[in,out] video ÆÚÍû½ÓÊÕµÄÊÓƵ³ß´çºÍÖ¡ËÙ,ÂëÂÊ. Èô NULL,Ôò²»½ÓÊÕÊÓƵ
- * @param[in,out] camera ÓÃÓÚÔ¤ÀÀͼÏñ,½¨ÒéµÄ·¢ËͳߴçºÍÖ¡ËÙ,ÂëÂÊ. Èô NULL, Ôò²»Ê¹ÓþµÍ·.
- * ×îÖÕµÄÊÓƵ³ß´çºÍ¾µÍ·µÄ³ß´ç,¶¼ÓÉ·þÎñÆ÷ÐÉ̾ö¶¨.
+ * @param[in] id 加入一对一会话(对方的uid)或房间(以room:前缀的房间地址)
+ * @param[in] ticket hash值,可通过其他路径获得,默认为NULL,仅用于调试.
+ * @param[in,out] video 期望接收的视频尺寸和帧速,码率. 若 NULL,则不接收视频
+ * @param[in,out] camera 用于预览图像,建议的发送尺寸和帧速,码率. 若 NULL, 则不使用镜头.
+ * 最终的视频尺寸和镜头的尺寸,都由服务器协商决定.
*/
struct jrtc_t* jrtc_open (const char* id, const char* ticket, struct jrtc_image_t* video, struct jrtc_image_t* camera);
-/** ÊÍ·Åͨ»°×ÊÔ´,²¢µÈ´ýÍøÂçÏ߳̽áÊø.
+/** 释放通话资源,并等待网络线程结束.
*
- * @param[in] err Ö÷¶¯¹Ò¶ÏΪ JRTC_EBYE
- * µ«µ±ÓïÒôµç»°ÖжÏʱ, ÐëÉèÖÃΪJRTC_EAUDIOCALL,
- * ÆäËûδ֪Çé¿ö,¿ÉÉèÖÃΪ JRTC_ENIL(²»Ð޸ĹҶÏÔÒò)
+ * @param[in] err 主动挂断为 JRTC_EBYE
+ * 但当语音电话中断时, 须设置为JRTC_EAUDIOCALL,
+ * 其他未知情况,可设置为 JRTC_ENIL(不修改挂断原因)
*/
void jrtc_close (struct jrtc_t* jc, enum jrtc_error err);
-/** ±àÂëÇ°µÄµÄÊÓƵ֡ */
+/** 编码前的的视频帧 */
struct jrtc_photo_t
{
void* data;
char reserve[3];
};
-/** ¶¯Ì¬ÉèÖÃÇ°ºó¾µÍ·
- * @param[in] camera 0Ϊºó¾µÍ·,1ÊÇÇ°¾µÍ·
- * @param[in] effect ±àÂëǰͼÏñµÄ´¦Àí»Øµ÷
- * ½ûÖ¹¸Ä±äͼÏñ³ß´çºÍ¸ñʽ.
- * ¿ÉÉèÖÃΪ NULL
+/** 动态设置前后镜头
+ * @param[in] camera 0为后镜头,1是前镜头
+ * @param[in] effect 编码前图像的处理回调
+ * 禁止改变图像尺寸和格式.
+ * 可设置为 NULL
* @code
* static char* encoding = NULL;
- * //Ö»¾µÏñ·¢ËÍͼÏñ
+ * //只镜像发送图像
* jrtc_set_camera(jc, 1, [](struct jrtc_photo_t* frame){
* auto preview = frame->data;
* if (!encoding) encoding = new char[frame->bytes];
*
- * assert (frame->format == JRTC_NV16 && "¸ù¾Ýƽ̨ѡÔñת»»º¯Êý");
+ * assert (frame->format == JRTC_NV16 && "根据平台选择转换函数");
* jrtc_nv16_mirror(frame, frame->width, frame->height, encoding);
* frame->data = encoding;
* });
- * //Ö»¾µÏñÔ¤ÀÀͼÏñ
+ * //只镜像预览图像
* jrtc_set_camera(jc, 1, [](struct jrtc_photo_t* frame){
* auto preview = frame->data;
* if (!encoding) encoding = new char[frame->bytes];
* frame->data = memcpy(encoding, preview, frame->bytes);
*
- * assert (frame->format == JRTC_NV16 && "¸ù¾Ýƽ̨ѡÔñת»»º¯Êý");
+ * assert (frame->format == JRTC_NV16 && "根据平台选择转换函数");
* jrtc_nv16_mirror(frame, frame->width, frame->height, preview);
* });
- * //ͬʱ¾µÏñÔ¤ÀÀºÍ·¢ËÍͼÏñ
+ * //同时镜像预览和发送图像
* jrtc_set_camera(jc, 1, [](struct jrtc_photo_t* frame){
* auto preview = frame->data;
* if (!encoding) encoding = new char[frame->bytes];
* frame->data = memcpy(encoding, preview, frame->bytes);
*
- * assert (frame->format == JRTC_NV16 && "¸ù¾Ýƽ̨ѡÔñת»»º¯Êý");
+ * assert (frame->format == JRTC_NV16 && "根据平台选择转换函数");
* jrtc_nv16_mirror(frame, frame->width, frame->height, preview);
* frame->data = preview;
* });
void jrtc_set_camera (struct jrtc_t* jc, int camera,
void (*effect) (struct jrtc_photo_t* frame));
-/** ¼¤»îÉ豸, ¿ªÆô·¢ËÍÄÜÁ¦
- * @param[in] devices jrtc_device µÄ¼¯ºÏ
+/** 激活设备, 开启发送能力
+ * @param[in] devices jrtc_device 的集合
*/
void jrtc_activate (struct jrtc_t* jc, int devices);
-/** ½û»îÉ豸, ¹Ø±Õ·¢ËÍÄÜÁ¦
- * @param[in] devices jrtc_device µÄ¼¯ºÏ
+/** 禁活设备, 关闭发送能力
+ * @param[in] devices jrtc_device 的集合
*/
void jrtc_deactivate (struct jrtc_t* jc, int devices);
-/** ·µ»Øͨ»°×´Ì¬ */
+/** 返回通话状态 */
enum jrtc_state jrtc_state (const struct jrtc_t *jc);
-/** ·µ»Ø×î½üµÄ³ö´íÖµ */
+/** 返回最近的出错值 */
enum jrtc_error jrtc_error (const struct jrtc_t *jc);
-/** ·µ»ØÍøÂç״̬
- * @param[out] remote_active_devices ¶Ô¶ËµÄµÄÊý¾ÝÁ÷״̬. jrtc_device µÄ¼¯ºÏ
- * ÔÊÐí NULL.
+/** 返回网络状态
+ * @param[out] remote_active_devices 对端的的数据流状态. jrtc_device 的集合
+ * 允许 NULL.
*/
enum jrtc_netstat jrtc_netstat(struct jrtc_t* jc, int *remote_active_devices);
extern "C" {
#endif
-/** ͨ»°×´Ì¬
+/** 通话状态
* jrtc_alloc jrtc_schedule jrtc_schedule
- * ´´½¨ÊµÀý ·¢ËÍÇëÇó ÊÕµ½Ó¦´ð
+ * 创建实例 发送请求 收到应答
* JRTC_CLOSED ----------> JRTC_OPENED ------------------> JRTC_JOINING -------------> JRTC_JOINED
* ^ |
* | jrtc_schedule | jrtc_schedule
- * | Ïú»ÙʵÀý jrtc_leave »ò ÄÚ²¿³ö´í | ÊÕµ½Ã½ÌåÊý¾Ý
+ * | 销毁实例 jrtc_leave 或 内部出错 | 收到媒体数据
* JRTC_LEAVING <---------------------------+------------- JRTC_TALKING <-------------+
* | ^
* | jrtc_schedule |
* +------------------+
*/
-/** ÖØÖ÷þÎñÆ÷µØÖ·
- * ×¢Òâ:
- * - ÊÖ¹¤ÉèÖÃеØÖ·,ͨ³£Ö»ÓÃÓÚ²âÊÔ
- * - srvURL ÏÞÖÆ×î´ó×Ö·ûÊýΪ128
- * - srvURL Ϊ¿Õʱ, »Ö¸´ÎªÄÚÖõÄĬÈÏ·þÎñÆ÷µØÖ·
+/** 重置服务器地址
+ * 注意:
+ * - 手工设置新地址,通常只用于测试
+ * - srvURL 限制最大字符数为128
+ * - srvURL 为空时, 恢复为内置的默认服务器地址
*
- * @param[in] srvURL ·þÎñÆ÷µØÖ·
+ * @param[in] srvURL 服务器地址
*/
void jrtc_config_server (const char* srvURL);
-/** ·ÖÅäͨ»°×ÊÔ´
- * ×¢Òâ:
- * - ÄÚ²¿Ö±½ÓÒýÓõØÖ·,ÓÉÍⲿ±£Ö¤ÄÚ´æµÄÓÐЧÐÔ
- * - ÄÚ²¿Ã»ÓÐÆô¶¯ÍøÂçÏß³Ì,ÐèÒª²»¶ÏµÄµ÷ÓÃÈçÏÂÇý¶¯
+/** 分配通话资源
+ * 注意:
+ * - 内部直接引用地址,由外部保证内存的有效性
+ * - 内部没有启动网络线程,需要不断的调用如下驱动
* jrtc_schedule(jc, nowMs);
- * - ÄÚ²¿É豸³õʼûÓ줻î,ºóÐøÐèÒªµ÷ÈçÏ¿ªÆô
+ * - 内部设备初始没有激活,后续需要调如下开启
* jrtc_activate(jc,JRTC_AUDIO|JRTC_CAMERA)
*
- * ticket ×÷Ϊͨ»°ID, Ψһ±êʶÿ´Îͨ»°:
- * - ²»ÄÜ°üº¬JSONÐèתÒåµÄ×Ö·û
- * - ÿ´Îͨ»°, ҪʹÓò»Í¬µÄ ticket,(Ëæ»ú²úÉú»òÏò·þÎñÆ÷ÉêÇë)
- * - A ºô½ÐÇ°,ÉêÇë»ñµÃ ticket
- * - A ÐèҪͨ"ijÖÖÍÆËÍ»úÖÆ"(³¤Á¬½Ó,ÍÆËÍ·½Ê½) ½« ticket ֪ͨµ½B
- * - A ºÍB ¶Ôºôʱ, ±ØÐëʹÓÃÏàͬµÄticket, ÒÔ±ã·þÎñÆ÷¾«È·±êʶ»á»°
+ * ticket 作为通话ID, 唯一标识每次通话:
+ * - 不能包含JSON需转义的字符
+ * - 每次通话, 要使用不同的 ticket,(随机产生或向服务器申请)
+ * - A 呼叫前,申请获得 ticket
+ * - A 需要通"某种推送机制"(长连接,推送方式) 将 ticket 通知到B
+ * - A 和B 对呼时, 必须使用相同的ticket, 以便服务器精确标识会话
*
- * @param[in] roomid ¼ÓÈëµÄ·¿¼äºÅ(¶Ô·½ÕË»§)
- * @param[in] ticket ÓÃÓÚ·¿¼äµÄhashÖµ,¿Éͨ¹ýÆäËû·¾¶»ñµÃ,ĬÈÏΪNULL,½öÓÃÓÚµ÷ÊÔ.
- * @param[in] video ÆÚÍû½ÓÊÕµÄÊÓƵ³ß´çºÍÖ¡ËÙ,ÂëÂÊ. Èô NULL,Ôò²»½ÓÊÕÊÓƵ
- * @param[in] camera ÓÃÓÚÔ¤ÀÀͼÏñ,½¨ÒéµÄ·¢ËͳߴçºÍÖ¡ËÙ,ÂëÂÊ. Èô NULL, Ôò²»Ê¹ÓþµÍ·.
- * ×îÖÕµÄÊÓƵ³ß´çºÍ¾µÍ·µÄ³ß´ç,¶¼ÓÉ·þÎñÆ÷ÐÉ̾ö¶¨.
+ * @param[in] roomid 加入的房间号(对方账户)
+ * @param[in] ticket 用于房间的hash值,可通过其他路径获得,默认为NULL,仅用于调试.
+ * @param[in] video 期望接收的视频尺寸和帧速,码率. 若 NULL,则不接收视频
+ * @param[in] camera 用于预览图像,建议的发送尺寸和帧速,码率. 若 NULL, 则不使用镜头.
+ * 最终的视频尺寸和镜头的尺寸,都由服务器协商决定.
*/
struct jrtc_t* jrtc_alloc (const char* roomid, const char* ticket, struct jrtc_image_t* video, struct jrtc_image_t* camera);
-/** µ¥²½¸üÐÂͨ»°
- * ÒªÇóʵʱÐÔ´¦Àí, Îñ±ØÔÚ¶ÀÁ¢Ïß³ÌÖгÖÐø¸üÐÂ,
- * µ±·µ»Ø JRTC_CLOSED ʱ, ¿ÉÒÔÍ˳ö¸ÃÏß³Ì.
- * ÀýÈç:
- * Æô¶¯ÍøÂçÏß³Ì([jc]{
+/** 单步更新通话
+ * 要求实时性处理, 务必在独立线程中持续更新,
+ * 当返回 JRTC_CLOSED 时, 可以退出该线程.
+ * 例如:
+ * 启动网络线程([jc]{
* do {
- * state = jrtc_schedule(jc, µ±Ç°ºÁÃë);
+ * state = jrtc_schedule(jc, 当前毫秒);
* } while(state != JRTC_CLOSED);
* }
*
- * @param[in] ms µ±Ç°ºÁÃë
+ * @param[in] ms 当前毫秒
*/
enum jrtc_state jrtc_schedule (struct jrtc_t* jc, unsigned ms);
-/** Ö÷¶¯À뿪/¹Ò¶Ï
- * ×¢Òâ: ÕâÀïÖ»¸Ä±ä״̬, Ïú»Ù½«ÔÚjrtc_schedule()ÖÐ×Ô¶¯´¦Àí
+/** 主动离开/挂断
+ * 注意: 这里只改变状态, 销毁将在jrtc_schedule()中自动处理
*
- * @param[in] err Ö÷¶¯¹Ò¶ÏΪ JRTC_EBYE
- * µ«µ±ÓïÒôµç»°ÖжÏʱ, ÐëÉèÖÃΪJRTC_EAUDIOCALL,
- * ÆäËûδ֪Çé¿ö,¿ÉÉèÖÃΪ JRTC_ENIL(²»Ð޸ĹҶÏÔÒò)
+ * @param[in] err 主动挂断为 JRTC_EBYE
+ * 但当语音电话中断时, 须设置为JRTC_EAUDIOCALL,
+ * 其他未知情况,可设置为 JRTC_ENIL(不修改挂断原因)
*/
enum jrtc_state jrtc_leave (struct jrtc_t *jc, enum jrtc_error err);
-/** ¾µÏñ
- * @param[in] dst_w Ä¿±ê¿í¶È, »á×Ô¶¯²Ã¼ô,µ«²»Ëõ·Å
- * @param[in] dst_h Ä¿±ê¸ß¶È, ¸ºÊýʱ»áÏÈÉÏÏ·ת(µÈ¼ÛÓÚÐýת180¶È)
- * @param[out] dst Ä¿±êÄÚ´æ
+/** 镜像
+ * @param[in] dst_w 目标宽度, 会自动裁剪,但不缩放
+ * @param[in] dst_h 目标高度, 负数时会先上下翻转(等价于旋转180度)
+ * @param[out] dst 目标内存
*/
void jrtc_i420_mirror(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv12_mirror(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_uyvy_mirror(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv16_mirror(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
-/** ˳ʱÕëת90¶È
- * @param[in] dst_w Ä¿±ê¿í¶È, »á×Ô¶¯²Ã¼ô,µ«²»Ëõ·Å
- * @param[in] dst_h Ä¿±ê¸ß¶È, ¸ºÊýʱ»áÏÈÉÏÏ·ת(µÈ¼ÛÓÚת90ºóˮƽ¾µÏñ)
- * @param[out] dst Ä¿±êÄÚ´æ
+/** 顺时针转90度
+ * @param[in] dst_w 目标宽度, 会自动裁剪,但不缩放
+ * @param[in] dst_h 目标高度, 负数时会先上下翻转(等价于转90后水平镜像)
+ * @param[out] dst 目标内存
*/
void jrtc_i420_rotate90(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv12_rotate90(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_uyvy_rotate90(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv16_rotate90(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
-/** ˳ʱÕëת270¶È
- * @param[in] dst_w Ä¿±ê¿í¶È, »á×Ô¶¯²Ã¼ô,µ«²»Ëõ·Å
- * @param[in] dst_h Ä¿±ê¸ß¶È, ¸ºÊýʱ»áÏÈÉÏÏ·ת(µÈ¼ÛÓÚת270ºóˮƽ¾µÏñ)
- * @param[out] dst Ä¿±êÄÚ´æ
+/** 顺时针转270度
+ * @param[in] dst_w 目标宽度, 会自动裁剪,但不缩放
+ * @param[in] dst_h 目标高度, 负数时会先上下翻转(等价于转270后水平镜像)
+ * @param[out] dst 目标内存
*/
void jrtc_i420_rotate270(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv12_rotate270(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_uyvy_rotate270(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv16_rotate270(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
-/** ²Ã¼ô
- * @param[in] dst_w Ä¿±ê¿í¶È, »á×Ô¶¯²Ã¼ô,µ«²»Ëõ·Å
- * @param[in] dst_h Ä¿±ê¸ß¶È, ¸ºÊýʱ»áÏÈÉÏÏ·ת
- * @param[out] dst Ä¿±êÄÚ´æ
+/** 裁剪
+ * @param[in] dst_w 目标宽度, 会自动裁剪,但不缩放
+ * @param[in] dst_h 目标高度, 负数时会先上下翻转
+ * @param[out] dst 目标内存
*/
void jrtc_i420_copy(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv12_copy(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_uyvy_copy(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv16_copy(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
-/** ת»»Îª RGB565
- * @param[in] dst_w Ä¿±ê¿í¶È, »á×Ô¶¯²Ã¼ô,µ«²»Ëõ·Å
- * @param[in] dst_h Ä¿±ê¸ß¶È, ¸ºÊýʱ»áÏÈÉÏÏ·ת
- * @param[out] dst Ä¿±êÄÚ´æ, Êä³ö³¤¶ÈΪ dst_w*dst_h*sizeof(short)
+/** 转换为 RGB565
+ * @param[in] dst_w 目标宽度, 会自动裁剪,但不缩放
+ * @param[in] dst_h 目标高度, 负数时会先上下翻转
+ * @param[out] dst 目标内存, 输出长度为 dst_w*dst_h*sizeof(short)
*/
void jrtc_i420_torgb565(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv12_torgb565(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_uyvy_torgb565(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
void jrtc_nv16_torgb565(const struct jrtc_photo_t* src, int dst_w, int dst_h, char* dst);
-/** ¿ÉÓÅ»¯ÅäÖõIJÎÊý @{ */
-extern unsigned JRTC_SESSION_TIMEOUT; /*< ½¨Á¢Í¨»°×ܵij¬Ê±·§Öµ,ĬÈÏ 300 Ãë*/
-extern unsigned JRTC_REPLY_TIMEOUT; /*< ½¨Á¢Í¨»°Öеȴý·þÎñÆ÷Ó¦´ðµÄ³¬Ê±·§Öµ,ĬÈÏ120 Ãë */
-extern unsigned JRTC_MEDIA_TIMEOUT; /*< ½ÓÊÕýÌåÊý¾ÝµÄ³¬Ê±·§Öµ, ĬÈÏ 20 Ãë */
-extern unsigned JRTC_MAX_RTP_SIZE; /*< ·¢Ë͵Ä×î´ó RTP °ü·§Öµ, ĬÈÏ1200,²»ÄÜ´óÓÚ1500 */
-extern unsigned JRTC_AUDIO_RED_LOSS;/*< ¿ªÆôÒôƵÈßÓà±àÂëµÄ¶ª°üÂÊ·§Öµ, ĬÈÏ 10 % */
-extern unsigned JRTC_VIDEO_FEC_LOSS; /*< ¿ªÆôÊÓƵÈßÓà±àÂëµÄ¶ª°üÂÊ·§Öµ, ĬÈÏ 5 % */
-extern unsigned JRTC_VIDEO_FEC_MAX_RTT;/*< ¿ªÆôÊÓƵÈßÓà±àÂëµÄRTTÉÏÏÞ, ĬÈÏ 3000 ms, 0 ÔòÇ¿ÖƹرÕFEC */
-extern unsigned JRTC_VIDEO_FEC_MAX_BW_RATIO; /*< ¿ªÆôÊÓƵÈßÓà±àÂëµÄ¶îÍâµÄÂëÂÊÕ¼±È, ĬÈÏ 80 %, 0 ÔòÇ¿ÖƹرÕFEC */
-extern unsigned JRTC_VIDEO_INIT_GOP; /*< ³õʼĬÈϵÄÊÓƵ¹Ø¼üÖ¡¼ä¸ô, ĬÈÏ2000 ms */
-extern unsigned JRTC_TASK_STACK_KB; /*< ÄÚ²¿Ï̵߳ÄÕ»´óС,Óëƽ̨Ïà¹Ø */
-extern unsigned JRTC_TASK_PRIORITY; /*< ÄÚ²¿Ï̵߳ÄÓÅÏȼ¶,Óëƽ̨Ïà¹Ø */
+/** 可优化配置的参数 @{ */
+extern unsigned JRTC_SESSION_TIMEOUT; /*< 建立通话总的超时阀值,默认 300 秒*/
+extern unsigned JRTC_REPLY_TIMEOUT; /*< 建立通话中等待服务器应答的超时阀值,默认120 秒 */
+extern unsigned JRTC_MEDIA_TIMEOUT; /*< 接收媒体数据的超时阀值, 默认 20 秒 */
+extern unsigned JRTC_MAX_RTP_SIZE; /*< 发送的最大 RTP 包阀值, 默认1200,不能大于1500 */
+extern unsigned JRTC_AUDIO_RED_LOSS;/*< 开启音频冗余编码的丢包率阀值, 默认 10 % */
+extern unsigned JRTC_VIDEO_FEC_LOSS; /*< 开启视频冗余编码的丢包率阀值, 默认 5 % */
+extern unsigned JRTC_VIDEO_FEC_MAX_RTT;/*< 开启视频冗余编码的RTT上限, 默认 3000 ms, 0 则强制关闭FEC */
+extern unsigned JRTC_VIDEO_FEC_MAX_BW_RATIO; /*< 开启视频冗余编码的额外的码率占比, 默认 80 %, 0 则强制关闭FEC */
+extern unsigned JRTC_VIDEO_INIT_GOP; /*< 初始默认的视频关键帧间隔, 默认2000 ms */
+extern unsigned JRTC_TASK_STACK_KB; /*< 内部线程的栈大小,与平台相关 */
+extern unsigned JRTC_TASK_PRIORITY; /*< 内部线程的优先级,与平台相关 */
/** @} */
-/** ¿É¸¨Öúµ÷ÊÔµÄÈ«¾ÖÖµ @{ */
-extern char _jrtc_errstr[256]; /* ×î½ü´íÎóÃèÊö */
-extern const char* _jrtc_version; /* µ±Ç°°æ±¾ºÅ */
-/* ÒÔÏÂÊÇjrtc_config(...)ÖеÄÈë²ÎÖµ */
+/** 可辅助调试的全局值 @{ */
+extern char _jrtc_errstr[256]; /* 最近错误描述 */
+extern const char* _jrtc_version; /* 当前版本号 */
+/* 以下是jrtc_config(...)中的入参值 */
extern char _jrtc_appkey[25];
extern char _jrtc_uid[65];
extern char _jrtc_srvURL[129];
#include "mperrno.h"
#include "binary.h"
+
#if CONFIG_GH301x
#include "hbd_ctrl.h"
#endif
} SC7A20_obj_t;
STATIC SC7A20_obj_t *g_SC7A20 = NULL;
char is_set_cb = 0;
+//#include "jrtc0.h"
unsigned char SL_SC7A20_I2c_Spi_Write(bool sl_spi_iic,unsigned char reg, unsigned char data)
{
uint8_t reg_addr = reg;
+ //jrtc_config_server("192.168.1.1");
//SC7A20_LOG("SL_SC7A20_I2c_Spi_Write reg_addr:%d, data:%02x\n", reg_addr, data);
if(HELIOS_I2C_Write((Helios_I2CEnum)0, SC7A20_IIC_ADDRESS, ®_addr, 1, &data, 1) == 0)
{
#define MICROPY_PORT_BUILTIN_MODULES_Hsensor
#endif
+#if 1 //MICROPY_QPY_MODULE_VideoCall
+extern const struct _mp_obj_module_t mp_module_VideoCall;
+#define MICROPY_PORT_BUILTIN_MODULES_VideoCall { MP_OBJ_NEW_QSTR(MP_QSTR_VideoCall), (mp_obj_t)&mp_module_VideoCall},
+#else
+#define MICROPY_PORT_BUILTIN_MODULES_VideoCall
+#endif
extern const struct _mp_obj_module_t mp_module_code128;
#define MICROPY_PORT_BUILTIN_MODULES_code128 { MP_OBJ_NEW_QSTR(MP_QSTR_code128), (mp_obj_t)&mp_module_code128 }, /* ע��`code128`ģ�� */
MICROPY_PORT_BUILTIN_MODULES_G729 \
MICROPY_PORT_BUILTIN_MODULES_Gsensor \
MICROPY_PORT_BUILTIN_MODULES_Hsensor \
+ MICROPY_PORT_BUILTIN_MODULES_VideoCall \
MICROPY_PORT_BUILTIN_MODULES_code128\
MICROPY_PORT_BUILTIN_MODULES_NETWORK
import _thread
import usys
-
-
+import uos
+import utime
class EventStore(object):
def __init__(self):
self.map = dict()
source/modGsensor_SC7A20.c \
source/modHsensor.c \
source/modHsensor_GH3018.c \
+ source/modVideoCall.c \
+ source/modVideoCall_juphoon.c \
source/modrsa.c \
source/utils_crc32.c \
source/http_parser.c \
ifeq ($(CONFIG_SC7A20), y)
INC += -I$(ROOT)/components/SC7A20
endif
-
+ifeq ($(CONFIG_juphoon), y)
+INC += -I$(ROOT)/components/juphoon
+endif
ifeq ($(CONFIG_POC_BND), y)
INC += -I$(ROOT)/components/poc
INC += -I$(ROOT)/components/poc/bnd/inc
$(BUILD)/EventMesh.mpy \
$(BUILD)/initTP.mpy \
$(BUILD)/lcd.mpy \
- $(BUILD)/location.mpy \
$(BUILD)/mgr.mpy \
$(BUILD)/protocol.mpy \
$(BUILD)/ui.mpy \
$(BUILD)/ui_WatchFaceScreen.mpy \
$(BUILD)/ui_health.mpy \
$(BUILD)/main_init.mpy \
+ $(BUILD)/calculator.mpy \
$(BUILD)/versions.mpy \
endif
import ql_fs
from misc import Power
import audio
-from ui import style_img,style_screen,style_font_youyuan_20
+from ui import style_screen_btn_1_main_main_default,style_font_youyuan_20_gray,style_img,style_screen,style_font_youyuan_20
import ntptime
#ntptime.settime(timezone=8)
clk_list_screen.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
clk_list_screen.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
-clk_list_title_bg= lv.btn(clk_list_screen)
-clk_list_title_bg.set_size(112,25)
-clk_list_title_bg.set_pos(8,5)
-clk_list_title_bg.add_style(style_cont_alarm, lv.PART.MAIN | lv.STATE.DEFAULT)
-clk_list_title_bg.set_ext_click_area(25)
+# clk_list_title_bg= lv.btn(clk_list_screen)
+# clk_list_title_bg.set_size(112,25)
+# clk_list_title_bg.set_pos(8,5)
+# clk_list_title_bg.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+# clk_list_title_bg.set_ext_click_area(25)
-clk_list_title = lv.label(clk_list_title_bg)
+clk_list_title = lv.label(clk_list_screen)
clk_list_title.set_pos(4, 5)
clk_list_title.set_size(112, 20)
-clk_list_title.set_text("闹钟列表")
+clk_list_title.set_text("闹钟")
clk_list_title.set_long_mode(lv.label.LONG.WRAP)
clk_list_title.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
clk_list_title.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
label_ok.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
#闹钟信息
-alarm_list = [{'hour': 16, 'repeart': 10, 'idx': 0, 'enabled': 0, 'days': [], 'minute': 39},
- {'hour': 16, 'repeart': 10, 'idx': 1, 'enabled': 0, 'days': [], 'minute': 39}]
+alarm_list = [{'hour': 16, 'repeart': 10, 'idx': 0, 'enabled': 0, 'days': [0,1,2,3,4,5,6], 'minute': 39},
+ {'hour': 16, 'repeart': 10, 'idx': 1, 'enabled': 0, 'days': [0,1,2,3,4,5,6], 'minute': 39},
+ {'hour': 16, 'repeart': 1, 'idx': 1, 'enabled': 0, 'days': [0,1,2,3,4,5,6], 'minute': 39},
+ {'hour': 16, 'repeart': 1, 'idx': 1, 'enabled': 0, 'days': [], 'minute': 39},
+ {'hour': 16, 'repeart': 1, 'idx': 1, 'enabled': 0, 'days': [], 'minute': 39},]
#用于显示闹钟列表不包含开关机信息
class ClockManager(Abstract):
style_common_pressed.set_pad_top(0)
style_common_pressed.set_pad_bottom(0)
+alarm_main_default = lv.style_t()
+alarm_main_default.init()
+alarm_main_default.set_radius(5)
+alarm_main_default.set_bg_color(lv.color_make(0x64,0x64,0x64))
+alarm_main_default.set_bg_grad_color(lv.color_make(0x64,0x64,0x64))
+alarm_main_default.set_bg_grad_dir(lv.GRAD_DIR.NONE)
+alarm_main_default.set_bg_opa(255)
+alarm_main_default.set_border_color(lv.color_make(0x64,0x64,0x64))
+alarm_main_default.set_border_width(0)
+alarm_main_default.set_border_opa(255)
+alarm_main_default.set_pad_left(0)
+alarm_main_default.set_pad_right(0)
+alarm_main_default.set_pad_top(0)
+alarm_main_default.set_pad_bottom(0)
+
+alarm_style_font_youyuan_20_gray = lv.style_t()
+alarm_style_font_youyuan_20_gray.init()
+alarm_style_font_youyuan_20_gray.set_text_color(lv.color_make(200, 200, 200))
+alarm_style_font_youyuan_20_gray.set_text_font(lv.K01_font_16_ALL)
#闹钟列表
class ClkListScreen(Screen):
NAME = "clk_list"
self.weekdays_list = ["日","一","二","三","四","五","六"]
EventMesh.subscribe("push_update_alarm_show", self.update_show_info)
self.alarm_show_list = lv.obj(clk_list_screen)
- self.alarm_show_list.set_pos(0, 35)
- self.alarm_show_list.set_size(128, 128-35)
+ self.alarm_show_list.set_pos(0, 25)
+ self.alarm_show_list.set_size(128, 128-25)
self.alarm_show_list.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
self.alarm_show_list.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
self.timer=osTimer()
for i in range(self.MXA_clk_num):
_btn = lv.btn(self.alarm_show_list)
+ _btn.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+ _btn.add_style(alarm_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
_btn.add_flag(lv.obj.FLAG.CLICKABLE)
- _btn.add_style(style_cont_alarm, lv.PART.MAIN | lv.STATE.DEFAULT)
- _btn.add_flag(lv.obj.FLAG.HIDDEN)
_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.edit_alarm(e)),
lv.EVENT.CLICKED, None)
+
_btn_label1 = lv.label(_btn)
_btn_label2 = lv.label(_btn)
_btn_label2.set_long_mode(lv.label.LONG.DOT)
_btn_label2.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
_btn_label3 = lv.label(_btn)
_btn_label3.set_long_mode(lv.label.LONG.DOT)
- _btn_label3.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+ _btn_label3.add_style(alarm_style_font_youyuan_20_gray, lv.PART.MAIN | lv.STATE.DEFAULT)
self.contact_detail_listt_dict.append({"_btn":_btn,"_btn_label1":_btn_label1,"_btn_label2":_btn_label2,"_btn_label3":_btn_label3})
def initialization(self):
global alarm_list
self.clock_list = alarm_list
IFEXIST = ql_fs.path_exists("/usr/static/storage_file/alarm_msg.json")
- if IFEXIST == True:
+ if IFEXIST == False:
if self.clock_list:
no_add_alarm.add_flag(lv.obj.FLAG.HIDDEN)
continue
print("alarm!!!!!!!!!!")
#_btn = lv.btn(self.alarm_show_list)
- self.contact_detail_listt_dict[count]["_btn"].set_size(112,45)
- self.contact_detail_listt_dict[count]["_btn"].set_pos(8,49*count)
+ self.contact_detail_listt_dict[count]["_btn"].set_size(120,35)
+ self.contact_detail_listt_dict[count]["_btn"].set_pos(4,39*count)
#_btn_label1 = lv.label(_btn)
- self.contact_detail_listt_dict[count]["_btn_label1"].set_pos(50, 0)
+ self.contact_detail_listt_dict[count]["_btn_label1"].set_pos(20, 0)
self.contact_detail_listt_dict[count]["_btn_label1"].set_size(0, 0)
self.contact_detail_listt_dict[count]["_btn_label1"].set_text(str(num))
#_btn_label2 = lv.label(_btn)
- self.contact_detail_listt_dict[count]["_btn_label2"].set_pos(8, 5)
+ self.contact_detail_listt_dict[count]["_btn_label2"].set_pos(10, 0)
self.contact_detail_listt_dict[count]["_btn_label2"].set_size(97, 20)
self.contact_detail_listt_dict[count]["_btn_label2"].set_text("%02d" % each["hour"] + ":"+"%02d" % each["minute"])
self.contact_detail_listt_dict[count]["_btn_label2"].set_style_text_align(lv.TEXT_ALIGN.LEFT, 0)
repeart = each["repeart"]
_output = [self.weekdays_list[x] for x in _new_list]
#_btn_label3 = lv.label(_btn)
- self.contact_detail_listt_dict[count]["_btn_label3"].set_pos(8, 25)
+ self.contact_detail_listt_dict[count]["_btn_label3"].set_pos(10, 18)
self.contact_detail_listt_dict[count]["_btn_label3"].set_size(128-8, 20)
print("_new_list:{} repeart:{}".format(_new_list,repeart))
if repeart == 1:
self.time_count = 0
self.time_GNSS = 0
self.GNSS_status = 0
-
+ self.timer_c = 0
def initialization(self):
FactoryModeLocation_GNSS_label.set_text("GNSS:\n")
# FactoryModeLocation_WIFI_label.set_text("WIFI:")
EventMesh.publish(constants.EVENT.START_LOCATION_TEST) #测试模式
def timer_FactoryModeLocation_cb(self, *args, **kwargs):
- EventMesh.publish("system_sleep_rest")#防止黑屏
+ EventMesh.publish("system_sleep_rest")#防止黑屏
+ self.timer_c += 1
+ if self.timer_c >= 7:
+ get_location_flag = EventMesh.publish("get_location_flag")
+ self.timer_c = 0
+ if get_location_flag != None:
+ if(get_location_flag == 0):
+ EventMesh.publish(constants.EVENT.START_LOCATION_TEST) #测试模式
+ self.time_count = utime.mktime(utime.localtime())
def GET_LOCATION_DATA(self, event, msg):
- print("GPS:{}".format(msg[0]))
- print("WIFI:{}".format(msg[1]))
- print("CALL:{}".format(msg[2]))
+ # print("GPS:{}".format(msg[0]))
+ # print("WIFI:{}".format(msg[1]))
+ # print("CALL:{}".format(msg[2]))
EventMesh.publish("system_sleep_rest")#防止黑屏
_DATA = ""
time_tmp = utime.mktime(utime.localtime())
if len(msg[0]) > 1 : #GPS
GNSS_DATA = "GNSS:------\n"
-
+ gnss_data = msg[0][0]
+ if gnss_data :
+ GNSS_DATA = GNSS_DATA + "{},{},{}\n".format("A",gnss_data["latitude"],gnss_data["longitude"])
+
+ self.time_GNSS = time_tmp-self.time_count
+ EventMesh.txt_log("test location time:{}".format(self.time_GNSS))
+ self.time_count = utime.mktime(utime.localtime())
+ else:
+
+ GNSS_DATA = GNSS_DATA + "{},{},{}\n".format("V",0,0)
_DATA += "定位时间:{};{}秒\n".format(self.time_GNSS,time_tmp-self.time_count)
- rmc_data = msg[0][1].split("RMC")
- gsv_data = msg[0][1].split("GSV")
- if len(rmc_data) >= 2 :
- rmc_data = rmc_data[1:]
- rmc_tmp = rmc_data[0].split(",")
- if len(rmc_tmp) >= 2:
- GNSS_DATA = GNSS_DATA + "{},{},{}\n".format(rmc_tmp[2],rmc_tmp[3],rmc_tmp[5])
- if rmc_tmp[2] == 'A':
- if self.GNSS_status == 0:
- self.time_GNSS = time_tmp-self.time_count
- EventMesh.txt_log("test location time:{}".format(self.time_GNSS))
- self.GNSS_status = 1
- else:
- self.GNSS_status = 0
- self.time_GNSS = 0
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- GSV_dict= {}
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
+
+ GSV_dict = msg[0][1]
+ #print("GET_LOCATION_DATA:{}".format(GSV_dict))
+ if GSV_dict :
count = 0
try:
for j in range(200):
for key in GSV_dict :
- if(int(key) != j):
+ if(key != j):
continue
#print("GSV_dict[key]:len:{}".format(len(GSV_dict[key])))
- if len(GSV_dict[key]) >= 1 :
- GNSS_DATA+="{:<3}:[{:<3}]".format(key,GSV_dict[key])#:<3 宽度为3左对齐
+ if GSV_dict[key] >= 1 :
+ GNSS_DATA+=" {:<3}:[{:<3}] ".format(key,GSV_dict[key])#:<3 宽度为3左对齐
count+=1
if count % 2 == 0:
GNSS_DATA+="\n"
- if count > 30:
+ if count > 50:
break
except Exception as e:
usys.print_exception(e)
_DATA += "CALL:------\n{}".format(msg[2][0])
#FactoryModeLocation_CALL_label.set_text("CALL:{}".format(msg[2][0]))
print("GET_LOCATION_DATA:data:{}".format(_DATA))
- FactoryModeLocation_GNSS_label.set_text(_DATA)
+ FactoryModeLocation_GNSS_label.set_text(_DATA)
+ self.timer_c = 0
def Close(self):
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)
self.timer_FactoryModeLocation.stop()
--- /dev/null
+import lvgl as lv
+import ql_fs
+import EventMesh
+from misc import Power
+from ui import style_screen,style_font_youyuan_20_black,style_btn,style_img,Screen,style_contact_btn,style_bar,style_bar_indic
+import constants
+import osTimer
+import audio
+from machine import Pin
+import usys
+
+
+calculator_screen = lv.obj()
+print("calculator_screen")
+calculator_screen.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+calculator_screen.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+# 创建文本框
+calculator_label = lv.textarea(calculator_screen)
+calculator_label.set_one_line(True) # 关闭1行模式
+calculator_label.set_size(128, 32) # 设置宽高
+calculator_label.align(lv.ALIGN.TOP_MID, 0, -2) # 设置位置
+calculator_label.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF) #不显示滚动条
+#calculator_label.add_event_cb(lambda e: self.textarea_event_handler(e, ta), lv.EVENT.READY, None) # 添加回调函数
+calculator_label.add_state(lv.STATE.FOCUSED) # 设置光标
+calculator_label.add_style(style_font_youyuan_20_black, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+
+calculator_num = lv.btnmatrix(calculator_screen)
+calculator_num.set_pos(int(0),int(30))
+calculator_num.set_size(128,90)
+calculator_num.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+btnm_map = [
+"C","<-","=","\n",
+"1","2","3","+","\n",
+"4","5","6","-","\n",
+"7","8","9","*","\n",
+".","0","%","/",""]
+calculator_num.set_map(btnm_map)
+# create style style_calculator_num_main_default
+style_calculator_num_main_default = lv.style_t()
+style_calculator_num_main_default.init()
+style_calculator_num_main_default.set_radius(4)
+style_calculator_num_main_default.set_bg_color(lv.color_make(0xff,0xff,0xff))
+style_calculator_num_main_default.set_bg_grad_color(lv.color_make(0xff,0xff,0xff))
+style_calculator_num_main_default.set_bg_grad_dir(lv.GRAD_DIR.NONE)
+style_calculator_num_main_default.set_bg_opa(255)
+style_calculator_num_main_default.set_border_color(lv.color_make(0xff,0xff,0xff))
+style_calculator_num_main_default.set_border_width(1)
+style_calculator_num_main_default.set_border_opa(255)
+style_calculator_num_main_default.set_pad_left(2)
+style_calculator_num_main_default.set_pad_right(0)
+style_calculator_num_main_default.set_pad_top(2)
+style_calculator_num_main_default.set_pad_bottom(0)
+style_calculator_num_main_default.set_pad_row(1)
+style_calculator_num_main_default.set_pad_column(1)
+
+# add style for calculator_num
+calculator_num.add_style(style_calculator_num_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+
+# create style style_calculator_num_items_default
+style_calculator_num_items_default = lv.style_t()
+style_calculator_num_items_default.init()
+style_calculator_num_items_default.set_radius(4)
+style_calculator_num_items_default.set_bg_color(lv.color_make(0xe6,0xe6,0xe6))
+style_calculator_num_items_default.set_bg_grad_color(lv.color_make(0xe6,0xe6,0xe6))
+style_calculator_num_items_default.set_bg_grad_dir(lv.GRAD_DIR.NONE)
+style_calculator_num_items_default.set_bg_opa(255)
+style_calculator_num_items_default.set_border_color(lv.color_make(0xd6,0xdd,0xe3))
+style_calculator_num_items_default.set_border_width(1)
+style_calculator_num_items_default.set_border_opa(255)
+style_calculator_num_items_default.set_text_color(lv.color_make(0x00,0x00,0x00))
+try:
+ style_calculator_num_items_default.set_text_font(lv.K01_font_16_ALL)
+except AttributeError:
+ print("set_font:error")
+
+# add style for calculator_num
+calculator_num.add_style(style_calculator_num_items_default, lv.PART.ITEMS|lv.STATE.DEFAULT)
+def my_round(src, idx):
+ src_flag = 1 #正负数
+ if src < 0:
+ src_flag = 0
+ src = abs(src)
+ tmp_str = "{}".format(src)
+ tmp_str_l= tmp_str.split(".")
+ print("tmp_str1:{} {}".format(tmp_str,tmp_str_l))
+ if len(tmp_str_l)>1 :
+ if len(tmp_str_l[1]) > idx:
+ for i in range(idx):
+ src *=10
+ dest = int(src)
+ if src >= dest+0.5 :
+ dest += 1
+ print("dest:{}".format(dest))
+ tmp_str = "{}".format(dest)
+ if len(tmp_str) > idx:
+ tmp_str = tmp_str[:len(tmp_str)-idx]+'.'+tmp_str[len(tmp_str)-idx:]
+ else : #位数不够，补0
+ zero_str = ""
+ for j in range(idx-len(tmp_str)):
+ zero_str += "0"
+ print("zero_str:{}".format(zero_str))
+ tmp_str = '0.'+zero_str+tmp_str
+ tmp_str = tmp_str.rstrip('0')#去掉尾数的 0
+ if "." in tmp_str:
+ tmp_str = tmp_str.rstrip('.')#去掉尾数的 .
+ # for i in range(idx):
+ # dest /=10
+ print("tmp_str:{}".format(tmp_str))
+ if src_flag == 0 :
+ tmp_str = "-" + tmp_str
+ return tmp_str
+
+class calculatorScreen(Screen):
+ NAME = "calculator"
+
+ def __init__(self):
+
+ super().__init__()
+ self.meta = None
+ self.calculator_num = ''
+ self.calculator_list = []
+ self.button = 0
+ self.timer = osTimer()
+ self.timer_cb = 0
+ self.count = 0
+ self.str = ""
+ calculator_num.add_event_cb(lambda e: self.calculator_event_cb(e,calculator_num), lv.EVENT.VALUE_CHANGED, None)
+ self.calculator_flag = 0
+ self.result = ""
+ self.num_count = 0 #限制输入位数 20位
+ def initialization(self):
+
+ self.meta = calculator_screen
+
+ def calculator_eval(self,str):
+ print("calculator_eval:str{}".format)
+ try :
+ num = eval(str)
+ ret = "{}".format((my_round(num,8))) #只保留小数点8位
+ # tmp = ret.split('.')
+ # if len(tmp) > 1:
+ # if len(tmp[1]) > 8 : #保留小数点失败
+ # str_tmp = tmp[0]+"."+tmp[1][:-1]
+ # ret = "{}".format((float(str_tmp)))
+
+ return ret
+ except Exception as e:
+ usys.print_exception(e)
+ e_tmp = "{}".format(e)
+ if e_tmp.find("divide by zero") != -1 :
+ calculator_label.set_text("除数不能为0")
+ elif e_tmp.find("invalid syntax") != -1 :
+ EventMesh.txt_log("calculator:{} {}".format(self.calculator_flag,self.str))
+ calculator_label.set_text("无效语法")
+ else :
+ EventMesh.txt_log("calculator:{} {}".format(self.calculator_flag,self.str))
+ calculator_label.set_text("运算异常")
+ self.str = ""
+ self.calculator_flag = 0
+ return -1
+ def calculator_event_cb(self,e,calculator_num):
+ src = e.get_target()
+ code = e.get_code()
+ #print("calculator_clicked:{} {}".format(src,code))
+ if code == lv.EVENT.VALUE_CHANGED:
+ txt = src.get_btn_text(src.get_selected_btn()) # 获取被点击的按钮的内容
+ try :
+ if txt == "<-": # 如果是退格键，那么就删除1个字符
+ if self.calculator_flag != 2 :
+ if len(self.str) > 1:
+ str_tmp = self.str[-1]
+ if str_tmp == "/" or str_tmp == "*" or str_tmp == "-" or str_tmp == "+" : #最后一个是运算符
+ self.calculator_flag = 0
+ self.str = self.str[0:-1]
+ else :
+ self.str = ""
+ self.calculator_flag = 0
+ if self.num_count > 0 :
+ self.num_count-=1
+ #calculator_label.del_char()
+ elif txt == "C": #清除键
+ self.num_count = 0
+ self.str = ""
+ calculator_label.set_text("")
+ self.calculator_flag = 0
+ elif txt == "=" :
+ if(self.calculator_flag == 1): #有运算符
+ str_tmp = self.str[-1]
+ if str_tmp == "/" or str_tmp == "*" or str_tmp == "-" or str_tmp == "+" : #最后一个是运算符
+ return
+ else:
+ self.num_count = 0
+ self.result = self.calculator_eval(self.str)
+ if self.result == -1:
+ return
+ self.str += txt+self.result
+ self.calculator_flag = 2
+ elif txt == "%" :
+ str_tmp = self.str[-1]
+ if str_tmp == "/" or str_tmp == "*" or str_tmp == "-" or str_tmp == "+" : #最后一个是运算符
+ self.str = self.str[:-1]
+
+ self.num_count = 0
+ self.result = self.calculator_eval(self.str+"/100")
+ if self.result == -1:
+ return
+ self.str += txt+"="+self.result
+ self.calculator_flag = 2
+ elif txt == "/" or txt == "*" or txt == "-" or txt == "+" : # 如果是符号,就运算
+ self.num_count = 0
+ if self.calculator_flag == 0:#无运算符
+ if len(self.str) == 0: #开头不能为运算符
+ return
+ self.calculator_flag = 1
+ self.str += txt
+ elif self.calculator_flag == 1 : #有运算符
+ str_tmp = self.str[-1]
+ if str_tmp == "/" or str_tmp == "*" or str_tmp == "-" or str_tmp == "+" : #最后一个是运算符
+ self.str = self.str[:-1]+txt
+
+ elif str_tmp == ".": #最后一个是.,去除再运算
+ self.str = self.str[0:-1]
+ self.result = self.calculator_eval(self.str)
+ if self.result == -1:
+ return
+ self.str = self.result+txt
+ else :
+ self.result = self.calculator_eval(self.str)
+ if self.result == -1:
+ return
+ self.str = self.result+txt
+ elif self.calculator_flag == 2 : #已经运算了一次
+ self.str = self.result + txt
+ self.calculator_flag = 1
+ elif txt == ".":
+ if self.num_count >=20:
+ return
+ self.num_count += 1
+ str_tmp = self.str[-1]
+ if str_tmp == "." :#最后一个是. 不再添加
+ pass
+ elif str_tmp == "/" or str_tmp == "*" or str_tmp == "-" or str_tmp == "+": #最后一个是符号 前面加一个0
+ self.str = self.str + "0"+ txt
+ else :
+ self.str+=txt
+ elif txt:#数字
+ if self.num_count >=20:
+ return
+ self.num_count += 1
+ #calculator_label.add_text(txt) # 如果不是回车键，那么就将当前数字显示到文本框
+ self.str+=txt
+ if self.calculator_flag == 2 :
+ self.str=txt
+ self.calculator_flag = 0
+ calculator_label.set_text(self.str)
+ except Exception as e:
+ usys.print_exception(e)
+ e_tmp = "{}".format(e)
+ if e_tmp.find("divide by zero") != -1 :
+ calculator_label.set_text("0不能为除数")
+ self.str = ""
+ self.calculator_flag = 0
+ else :
+ EventMesh.txt_log("calculator:{} {} {}".format(self.calculator_flag,self.str,txt))
+ calculator_label.set_text("运算异常")
+ self.str = ""
+ self.calculator_flag = 0
+ #print("ui_queue_thread:ERROR:{}".format(e))
+
+ print("calculator_clicked:flag:{} str{} ".format(self.calculator_flag,self.str))
+
+
+
+ def lcd_on(self):
+ if self.timer_cb != 0:
+ self.timer_cb = 0
+ #self.timer.start(1000,1,self.refresh_line)
+
+ def lcd_off(self):
+ self.timer_cb = 1
+ self.timer.stop()
+
+
+ def done_return(self):
+ EventMesh.publish("load_screen", {"screen": "main_menu"})
+
+ def btn1_release(self):
+ EventMesh.publish("load_screen", {"screen": "main_menu"})
+
+ def btn8_press(self):
+ EventMesh.publish("watch_top_show")
+ EventMesh.publish("load_screen", {"screen": "main_menu"})
+
-from usr.main_init import main_init
+from main_init import main_init
main_init()
\ No newline at end of file
ui.add_screen(WechatScreen())
from alarm import ClkListScreen,ClockManager,NewEditClk,CLKTimeScreen,ClkPeriod,PopupAlarmScreen
from ui_health import HealthScreen
+ from calculator import calculatorScreen
ui.add_screen(ClkListScreen())
ui.add_screen(_ui.CountdownEndScreen())
ui.add_screen(NewEditClk())
ui.add_screen(_ui_setting.PhoneringScreen())
ui.add_screen(_ui_setting.totalvolumeScreen())
ui.add_screen(_ui_setting.PoweroffConfirmScreen())
+ ui.add_screen(_ui_setting.RestartScreen())
ui.add_screen(_ui.DialingScreen())
ui.add_screen(_ui.CallLogScreen())
ui.add_screen(_ui.UIFINDScreen())
ui.add_screen(_ui.RemoveMessageScreen())
ui.add_screen(_ui.keyboardScreen())
ui.add_screen(_ui.classMgrPopupScreen())
- ui.add_screen(_ui.calculatorScreen())
+ ui.add_screen(calculatorScreen())
ui.add_screen(_ui.cameraScreen())
ui.add_screen(_ui.cameraalbumScreen())
ui.add_screen(_ui.cameraVdieoScreen())
from machine import I2C
from Gsensor import SC7A20
import pm
+import ure
try :
from Hsensor import GH3018
except Exception as e:
self.location_thread_id = 0
self.location_queue = Queue(100)
self.lpm_fd = None
- #quecgnss.init()
- #quecgnss.gnssEnable(0)
+ self.start_agps = 0
+ quecgnss.init()
+ quecgnss.gnssEnable(0)
@staticmethod
def get_date():
return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])
def post_processor_after_instantiation(self):
- _gps_cfg = {
- "UARTn": UART.UART1,
- "buadrate": 115200,
- "databits": 8,
- "parity": 0,
- "stopbits": 1,
- "flowctl": 0,
- "PowerPin": Pin.GPIO2,
- "StandbyPin": Pin.GPIO3,
- "BackupPin": None,
- "gps_mode": 0x01,
- }
- self.gps = GPS(**_gps_cfg)
- self.gps.power_switch(0)#关闭GPS
+ # _gps_cfg = {
+ # "UARTn": UART.UART1,
+ # "buadrate": 115200,
+ # "databits": 8,
+ # "parity": 0,
+ # "stopbits": 1,
+ # "flowctl": 0,
+ # "PowerPin": Pin.GPIO2,
+ # "StandbyPin": Pin.GPIO3,
+ # "BackupPin": None,
+ # "gps_mode": 0x01,
+ # }
+ # self.gps = GPS(**_gps_cfg)
+ # self.gps.power_switch(0)#关闭GPS
EventMesh.subscribe(constants.EVENT.GPSOPEN, self.gps_open)
EventMesh.subscribe(constants.EVENT.GPSCLOSE, self.gps_close)
EventMesh.subscribe(constants.EVENT.START_LOCATION, self.start_location)
return
self.location_thread_id = _thread.start_new_thread(self.location_thread, ())
self.location_flag = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
#self.gps_open(event, msg)
self.location_flag = 1
#self.gps_open(event, msg)
self.location_type = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
def close_location(self, event, msg):
self.location_flag = 0
self.location_type = 0
+ self.timer_read_GPS_info.stop()
def gps_open(self, event, msg):
#print("publish:gps_open")
#quecgnss.init()
- quecgnss.gnssEnable(1)
- self.gps.__gps_nmea_data_clean()
+ quecgnss.gnssEnable(2)
+ #self.gps.__gps_nmea_data_clean()
def gps_close(self, event, msg):
quecgnss.gnssEnable(0)
def location_timer(self, *args, **kwargs):
else :
break
-
+ def GxGGA_latitude(self, gga_data):
+ """Parse latitude from GGA"""
+ if gga_data:
+ latitude_re = ure.search(r",[0-9]+\.[0-9]+,[NS],", gga_data)
+ if latitude_re:
+ latitude = latitude_re.group(0)[1:-3]
+ return str(float(latitude[:2]) + float(latitude[2:]) / 60)
+ return ""
+ def GxGGA_longitude(self, gga_data):
+ """Parse longitude from GGA"""
+ if gga_data:
+ longitude_re = ure.search(r",[0-9]+\.[0-9]+,[EW],", gga_data)
+ if longitude_re:
+ longitude = longitude_re.group(0)[1:-3]
+ return str(float(longitude[:3]) + float(longitude[3:]) / 60)
+ return ""
+
+ def GxGGA_altitude(self, gga_data):
+ """Parse altitude from GGA"""
+ if gga_data:
+ altitude_re = ure.search(r",-*[0-9]+\.[0-9]+,M,", gga_data)
+ if altitude_re:
+ return altitude_re.group(0)[1:-3]
+ return ""
def location_thread(self):
self.wifi_data = []
self.cell_data = []
gnss_r_data = []
self.GSV_sig_ok_count = 0
+ self.GSV_sig_very_ok_count = 0
self.GGA_count = 0
self.RMC_A_count = 0
+ # if self.start_agps == 1: #开启agps
+ # self.start_agps = 0
+ # quecgnss.configSet(2,1)
if self.lpm_fd == None:
self.lpm_fd = pm.create_wakelock("test_lock", len("test_lock"))
pm.wakelock_lock(self.lpm_fd)
print("location_thread:1")
EventMesh.publish(constants.EVENT.GPSOPEN)
print("location_thread:2")
- self.timer_read_GPS_info.start(1000, 1, self.location_timer)
-
+ #self.timer_read_GPS_info.start(1000, 1, self.location_timer)
+ print("location_thread:3")
#utime.sleep_ms(1000)
self.location_timer_count = 0
#quecgnss.read(4096)#去掉第一次错误数据
#EventMesh.txt_log("START_LOCATION")
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
+ GSV_dict= {}
while self.location_flag == 1:
try :
# if self.location_check_data_timer_count >= 3:
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
- if self.location_check_data_timer_count >= 5 :#5秒查一次基站数据和wifi数据
+ if self.location_check_data_timer_count >= 1 :#3秒查一次基站数据和wifi数据
self.location_check_data_timer_count = 0
#print(self.location_timer_count)
- #GSV_dict= {}
+ GSV_dict= {}
#检查GNSS数据
if ( self.gps_data == {} or self.location_type == 1) and quecgnss.get_state() == 2:
-
- self.gps.__gps_nmea_data_clean()
- #gnss_r_data = [0,1]
- gnss_r_data = quecgnss.read(4096)
- #EventMesh.txt_log("gps Datalen:{}".format(gnss_r_data[0]))
- print("location gnss_r_data:len{}\n{}".format(gnss_r_data[0],gnss_r_data[1].decode()))
- #print("gnss_r_data len:{}".format(gnss_r_data[0]))
- if gnss_r_data[0] > 0 : #有数据
- tmp_ok_count = 0
- gsv_data = gnss_r_data[1].split("GSV")
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
-
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- #GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- try:
- #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
- if gsv_tmp[i+3] != "" :
- if int(gsv_tmp[i+3])>=20:
- tmp_ok_count +=1
- except Exception as e:
- usys.print_exception(e)
- #print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
-
- if(tmp_ok_count > self.GSV_sig_ok_count ):
- self.GSV_sig_ok_count = tmp_ok_count
-
- # if len(match_gga_data) > 8:
- # #print(match_gga_data)
- # if(match_gga_data[7] ):
- # gga_count_tmp = int(match_gga_data[7]) #可用卫星
- # if(gga_count_tmp > self.GGA_count):
- # self.GGA_count = gga_count_tmp
- print("GGA_count:{} GSV_sig_ok_coun:{} ".format(self.GGA_count,self.GSV_sig_ok_count))
+ pass
+ tmp_ok_count = 0
+ tmp_very_ok_count = 0
+ gsv_data = quecgnss.get_gsv()
+ rmc_data = quecgnss.get_rmc()
+ gga_data = quecgnss.get_gga()
+ vtg_data = quecgnss.get_vtg()
+ print("gsv:{}".format(quecgnss.get_gsv()))
+ print("gga:{}".format(quecgnss.get_gga()))
+ print("rmc:{}".format(quecgnss.get_rmc()))
+ print("vtg:{}".format(quecgnss.get_vtg()))
+ for i in range(len(gsv_data)) :
- match_rmc_data = self.match.GxRMC(gnss_r_data[1]).split(",")
-
- #print("match_rmc_data:\n{}".format(match_rmc_data))
- if len (match_rmc_data)>3: #有rmc数据
- if match_rmc_data[2] == 'A':
-
- if self.gps.__check_gps_valid(gnss_r_data[1].decode()): #数据齐全 :
-
- #print("hhhhhh:{}\n\n".format(self.gps.__gsv_data))
- match_vtg_data = self.gps.__vtg_data.split(",")#self.match.GxVTG(gnss_r_data[1]).split(",")
- match_gga_data = self.gps.__gga_data.split(",")#self.match.GxGGA(gnss_r_data[1]).split(",")
- #match_gga_data = self.match.GxGGA(gnss_r_data[1]).split(",")
-
- EventMesh.txt_log("GGA:{}".format(match_gga_data))
- # EventMesh.txt_log("VTG:{}".format(match_vtg_data))
- # EventMesh.txt_log("RMC:{}".format(match_rmc_data))
- # EventMesh.txt_log("timer:{} ok_count:{} count:{}\n".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
- print("LOCATION_ok :time:{}!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n".format(self.location_timer_count))
+ if i % 2 == 0:
+ if i+1 >= len(gsv_data) :
+ print("gsv_data num error!!")
+ break
+ GSV_dict[gsv_data[i]] = gsv_data[i+1]
+ #print("type:gsv_data{}".format(type(gsv_data[i+1])))
+ try:
+ #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
+ if gsv_data[i+1] :
+ if (gsv_data[i+1])>=20:
+ tmp_ok_count +=1
+ if (gsv_data[i+1])>=30:
+ tmp_very_ok_count +=1
+
+ except Exception as e:
+ usys.print_exception(e)
+
+ if(tmp_ok_count > self.GSV_sig_ok_count ):
+ self.GSV_sig_ok_count = tmp_ok_count
+ if(tmp_very_ok_count > self.GSV_sig_very_ok_count ):
+ self.GSV_sig_very_ok_count = tmp_very_ok_count
+ match_rmc_data = rmc_data.split(",")
+ if len (match_rmc_data)>3: #有rmc数据
+ if match_rmc_data[2] == 'A':
+ match_gga_data = gga_data.split(",")
+ if len(match_gga_data) >4: #数据全
+ match_vtg_data = vtg_data.split(",")
gps_date = "%s,%s"%(match_rmc_data[9],match_rmc_data[1][:6])#日期
- gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
+ #gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
latitude = "0,N" #纬度
- latitude_tmp = str(gps_data_tmp[1]).split(".")
+ latitude_tmp = str(self.GxGGA_latitude(gga_data)).split(".")
if len(latitude_tmp) >= 2 and len(latitude_tmp[1])>=5:
latitude = "%s.%s"%(latitude_tmp[0],latitude_tmp[1][:6])
latitude = "%s,%s"%(latitude,match_rmc_data[4] )
longitude = "0,E"#经度
- longitude_tmp = str(gps_data_tmp[0]).split(".")
+ longitude_tmp = str(self.GxGGA_longitude(gga_data)).split(".")
if len(longitude_tmp) >= 2 and len(longitude_tmp[1])>=5:
longitude = "%s.%s"%(longitude_tmp[0],longitude_tmp[1][:6])
longitude = "%s,%s"%(longitude,match_rmc_data[6] ) #match_rmc_data[6] + str(gnss_r_data[1])
high = "0"#高度
- high = str(gps_data_tmp[2])
+ high = str(self.GxGGA_altitude(gga_data))
number = "0"#可用卫星
precision = "5.8"#精度
if len(match_gga_data)>5 :
"date": gps_date,
"precision": precision
}
- else :
- EventMesh.txt_log("gps数据不全")
- else :
- EventMesh.txt_log("gps 无数据")
-
+# ***********************************************************************************
#检查wifi数据
if self.location_type == 1: #测试模式
self.location_timer_count = 0
- if len(gnss_r_data) >= 1:
- if gnss_r_data[0] > 0:
- EventMesh.publish("PUSH_LOCATION_DATA", [gnss_r_data,self.wifi_data,self.cell_data])
+
+ EventMesh.publish("PUSH_LOCATION_DATA", [[self.gps_data,GSV_dict],self.wifi_data,self.cell_data])
if self.gps_data != {} : #发送数据
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
self.location_queue.put(constants.PROTOCOL.UD_SEND)
elif self.location_type == 0: #正常模式
if self.gps_data != {} or self.location_timer_count > 100: #or( self.wifi_data != [] and self.cell_data != []):
if self.location_queue.empty() == False:#有定位队列
- EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
- upload_time = EventMesh.publish("get_upload_data")
-
-
+ EventMesh.txt_log("LOCATION timer:{} ok:{} very_ok:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GSV_sig_very_ok_count))
+ #EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
+ if self.gps_data == {}: #定位超时，且信噪比多个大于30，下次启动agps
+ if self.GSV_sig_very_ok_count > 3:#3个超30以上
+ self.start_agps = 1
+ EventMesh.txt_log("open agps:{}".format(GSV_dict))
+ #upload_time = EventMesh.publish("get_upload_data")
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#if upload_time > 200 :
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
if self.GSV_sig_ok_count <= 1 and self.wifi_data != [] and self.cell_data != [] and self.location_timer_count > 20: #超过40秒且信号大于30的不足3个
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
- EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} count:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
+ EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#break
# if self.location_type != 1 and self.location_timer_count >= 60*4 : #4分钟关闭
#self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
utime.sleep_ms(500)
- self.timer_read_GPS_info.stop()
- self.gps.power_switch(0)
+
+ #self.timer_read_GPS_info.stop()
+ #self.gps.power_switch(0)
wifiScan.control(0)
+ EventMesh.publish(constants.EVENT.GPSCLOSE)
# if EventMesh.publish("get_lcd_state" ) == 0:#休眠的时候，恢复休眠
# pm.autosleep(1)
# pm.sclkEx_set(1, 1, 5)
self.publish_timer.start(1000, 0, self.publish_timer_cb)
except Exception as e:
- usys.print_exception(e)
+ #usys.print_exception(e)
self.run_flag = False
else:
self.run_flag = True
data = b''
except Exception as e:
- print("TCP:ERROR:recv:")
- usys.print_exception(e)
+ #print("TCP:ERROR:recv:")
+ #usys.print_exception(e)
self.run_flag = False
self.reconnect()
# EventMesh.publish("add_alarm",[0,msg_tmp])
EventMesh.publish(constants.PROTOCOL.REMIND_SEND)
+
+
+
+
+
+
class HRSTART_ProtoCol(ProtoCol):
"""心率频率数据"""
TYPE = "hrtstart"
def handler(self, data):
# 这里接收数据
- print("handler -> {}".format(data))
+ # print("handler -> {}".format(data))
# if data.startswith('Init;'):
# data = data[5:]
# EventMesh.publish(constants.EVENT.SET_KEY, {"value": ujson.loads(data)['KEY']})
from queue import Queue
import camera
from machine import RTC
+
LCD_X = 128
LCD_Y = 128
def audio_cb(event):
style_font_youyuan_20_red.set_text_font(lv.K01_font_16_ALL)
#style_font_youyuan_20_red.set_text_font_v2("font_28.bin",28,0)
+style_font_youyuan_20_gray = lv.style_t()
+style_font_youyuan_20_gray.init()
+style_font_youyuan_20_gray.set_text_color(lv.color_make(128, 128, 128))
+style_font_youyuan_20_gray.set_text_font(lv.K01_font_16_ALL)
style_img = lv.style_t()
style_img.init()
style_img.set_img_opa(255)
style_contact_btn_pressed.set_text_color(lv.color_make(0x00,0x00,0x00))
-
+style_screen_btn_1_main_main_default = lv.style_t()
+style_screen_btn_1_main_main_default.init()
+style_screen_btn_1_main_main_default.set_radius(5)
+style_screen_btn_1_main_main_default.set_bg_color(lv.color_make(0x64,0x64,0x64))
+style_screen_btn_1_main_main_default.set_bg_grad_color(lv.color_make(0x64,0x64,0x64))
+style_screen_btn_1_main_main_default.set_bg_grad_dir(lv.GRAD_DIR.NONE)
+style_screen_btn_1_main_main_default.set_bg_opa(255)
+style_screen_btn_1_main_main_default.set_border_color(lv.color_make(0x64,0x64,0x64))
+style_screen_btn_1_main_main_default.set_border_width(0)
+style_screen_btn_1_main_main_default.set_border_opa(255)
style_circle = lv.style_t()
style_circle.init()
def __init__(self):
super().__init__()
+ self.timer = osTimer()
self.meta = None
self.meta_type = "popup"
self.call_log = {}
EventMesh.publish("set_UI_high_priority", 0)
EventMesh.publish("set_hangup_mode", 1)
voiceCall.callEnd()
+ self.timer.start(5000,0,self.call_end)
+
+ def Close(self):
+ self.timer.stop()
+
+ def call_end(self,*argc):
+ print("call_end!!!!!!!!")
+ call_state = EventMesh.publish("get_call_state")#设置关机时间
+ if call_state != None:
+ if call_state == 0:#未打通
+ EventMesh.publish("load_screen", {"screen": "main_menu"})
def done_return(self):
pass
self.sms_detail_list_dict[i]["_btn_label5"].set_size(LCD_X-15, 20)
self.sms_detail_list_dict[i]["_btn_label5"].set_text(title1)
self.sms_detail_list_dict[i]["_btn_label5"].set_long_mode(lv.label.LONG.DOT)
- # self.sms_detail_list_dict[i]["_btn_label5"].add_style(style_font_youyuan_20_black, lv.PART.MAIN | lv.STATE.DEFAULT)
+ self.sms_detail_list_dict[i]["_btn_label5"].add_style(style_font_youyuan_20_black, lv.PART.MAIN | lv.STATE.DEFAULT)
self.sms_detail_list_dict[i]["msg_btn"].clear_flag(lv.obj.FLAG.HIDDEN)
#if msg == 1:
def __init__(self):
super().__init__()
+ self.is_sliding = 0
self.meta = None
def initialization(self):
toolbox_countdown_img,toolbox_stopwatch_img
if toolbox_screen == None:
tool_set_y = 5
+ tool_set_y_offset = 40
toolbox_screen = lv.obj()
print("toolbox_screen")
toolbox_screen.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
# toolbox_title.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
toolbox_cont = lv.obj(toolbox_screen)
- toolbox_cont.set_pos(0, 0)
- toolbox_cont.set_size(128, 128)
+ toolbox_cont.set_pos(0, 5)
+ toolbox_cont.set_size(128, 123)
toolbox_cont.add_style(toolbox_cont_style,lv.PART.MAIN | lv.STATE.DEFAULT)
+ toolbox_step_img_btn_1 = lv.btn(toolbox_cont)
+ toolbox_step_img_btn_1.set_pos(int(0),int(tool_set_y-5))
+ toolbox_step_img_btn_1.set_size(120,35)
+ toolbox_step_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+ toolbox_step_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+ toolbox_step_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+
toolbox_step_img = lv.img(toolbox_cont)
toolbox_step_img.set_pos(5, tool_set_y)
toolbox_step_img.set_size(25, 25)
- toolbox_step_img.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_step_img.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_step_img.set_src("U:/static/IMAGE_SECMENU_STEP.png")
toolbox_step_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
toolbox_step_img_label.set_size(128-35, 35)
toolbox_step_img_label.set_text("计步")
toolbox_step_img_label.set_long_mode(lv.label.LONG.WRAP)
- toolbox_step_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_step_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_step_img_label.set_style_text_align(lv.TEXT_ALIGN.LEFT, 0)
toolbox_step_img_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
- tool_set_y+=35
+ tool_set_y+=tool_set_y_offset
+
+ toolbox_weather_img_btn_1 = lv.btn(toolbox_cont)
+ toolbox_weather_img_btn_1.set_pos(int(0),int(tool_set_y-5))
+ toolbox_weather_img_btn_1.set_size(120,35)
+ toolbox_weather_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+ toolbox_weather_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+ toolbox_weather_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
toolbox_weather_img = lv.img(toolbox_cont)
toolbox_weather_img.set_pos(5, tool_set_y)
toolbox_weather_img.set_size(25, 25)
- toolbox_weather_img.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_weather_img.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_weather_img.set_src("U:/static/IMAGE_SECMENU_WEATHER.png")
toolbox_weather_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
toolbox_weather_img_label.set_size(128-35, 35)
toolbox_weather_img_label.set_text("天气")
toolbox_weather_img_label.set_long_mode(lv.label.LONG.WRAP)
- toolbox_weather_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_weather_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_weather_img_label.set_style_text_align(lv.TEXT_ALIGN.LEFT, 0)
toolbox_weather_img_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
- tool_set_y+=35
+ tool_set_y+=tool_set_y_offset
+
+ toolbox_alarm_img_btn_1 = lv.btn(toolbox_cont)
+ toolbox_alarm_img_btn_1.set_pos(int(0),int(tool_set_y-5))
+ toolbox_alarm_img_btn_1.set_size(120,35)
+ toolbox_alarm_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+ toolbox_alarm_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+ toolbox_alarm_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+
toolbox_alarm_img = lv.img(toolbox_cont)
toolbox_alarm_img.set_pos(5, tool_set_y)
toolbox_alarm_img.set_size(25, 25)
- toolbox_alarm_img.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_alarm_img.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_alarm_img.set_src("U:/static/IMAGE_SECMENU_ALARM.png")
toolbox_alarm_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
toolbox_alarm_img_label.set_size(128-35, 35)
toolbox_alarm_img_label.set_text("闹钟")
toolbox_alarm_img_label.set_long_mode(lv.label.LONG.WRAP)
- toolbox_alarm_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_alarm_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_alarm_img_label.set_style_text_align(lv.TEXT_ALIGN.LEFT, 0)
toolbox_alarm_img_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
# toolbox_sms_img.set_src("U:/static/tool/sms_setting.png")
# toolbox_sms_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- tool_set_y+=35
+ tool_set_y+=tool_set_y_offset
+
+ toolbox_countdown_img_btn_1 = lv.btn(toolbox_cont)
+ toolbox_countdown_img_btn_1.set_pos(int(0),int(tool_set_y-5))
+ toolbox_countdown_img_btn_1.set_size(120,35)
+ toolbox_countdown_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+ toolbox_countdown_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+ toolbox_countdown_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+
toolbox_countdown_img = lv.img(toolbox_cont)
toolbox_countdown_img.set_pos(5, tool_set_y)
toolbox_countdown_img.set_size(25, 25)
- toolbox_countdown_img.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_countdown_img.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_countdown_img.set_src("U:/static/IMAGE_SECMENU_COUNTDOWN.png")
toolbox_countdown_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
toolbox_countdown_img_label.set_size(128-35, 35)
toolbox_countdown_img_label.set_text("倒计时")
toolbox_countdown_img_label.set_long_mode(lv.label.LONG.WRAP)
- toolbox_countdown_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_countdown_img_label.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_countdown_img_label.set_style_text_align(lv.TEXT_ALIGN.LEFT, 0)
toolbox_countdown_img_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
- tool_set_y+=35
+ tool_set_y+=tool_set_y_offset
+ toolbox_stopwatch_img_btn_1 = lv.btn(toolbox_cont)
+ toolbox_stopwatch_img_btn_1.set_pos(int(0),int(tool_set_y-5))
+ toolbox_stopwatch_img_btn_1.set_size(120,35)
+ toolbox_stopwatch_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+ toolbox_stopwatch_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+ toolbox_stopwatch_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+
toolbox_stopwatch_img = lv.img(toolbox_cont)
toolbox_stopwatch_img.set_pos(5, tool_set_y)
toolbox_stopwatch_img.set_size(25, 25)
- toolbox_stopwatch_img.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_stopwatch_img.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_stopwatch_img.set_src("U:/static/IMAGE_SECMENU_STOPWATCH.png")
toolbox_stopwatch_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
toolbox_stopwatch_img_label_btn.set_size(128, 45)
toolbox_stopwatch_img_label_btn.set_text(" ")
toolbox_stopwatch_img_label_btn.set_long_mode(lv.label.LONG.WRAP)
- toolbox_stopwatch_img_label_btn.add_flag(lv.obj.FLAG.CLICKABLE)
+ # toolbox_stopwatch_img_label_btn.add_flag(lv.obj.FLAG.CLICKABLE)
toolbox_stopwatch_img_label_btn.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
- toolbox_step_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "step"})), lv.EVENT.CLICKED, None)
- toolbox_weather_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "weather"})), lv.EVENT.CLICKED, None)
- toolbox_alarm_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "clk_list"})), lv.EVENT.CLICKED, None)
+ toolbox_step_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "step")), lv.EVENT.CLICKED, None)
+ toolbox_weather_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "weather")), lv.EVENT.CLICKED, None)
+ toolbox_alarm_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "clk_list")), lv.EVENT.CLICKED, None)
# toolbox_sms_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "popup"})), lv.EVENT.CLICKED, None)
- toolbox_countdown_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "countdown"})), lv.EVENT.CLICKED, None)
- toolbox_stopwatch_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "stopwatch"})), lv.EVENT.CLICKED, None)
+ toolbox_countdown_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e,"countdown")), lv.EVENT.CLICKED, None)
+ toolbox_stopwatch_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "stopwatch")), lv.EVENT.CLICKED, None)
- toolbox_step_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "step"})), lv.EVENT.CLICKED, None)
- toolbox_weather_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "weather"})), lv.EVENT.CLICKED, None)
- toolbox_alarm_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "clk_list"})), lv.EVENT.CLICKED, None)
- # toolbox_sms_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "popup"})), lv.EVENT.CLICKED, None)
- toolbox_countdown_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "countdown"})), lv.EVENT.CLICKED, None)
- toolbox_stopwatch_img_label_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "stopwatch"})), lv.EVENT.CLICKED, None)
+ # toolbox_step_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "step")), lv.EVENT.CLICKED, None)
+ # toolbox_weather_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "weather")), lv.EVENT.CLICKED, None)
+ # toolbox_alarm_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "clk_list")), lv.EVENT.CLICKED, None)
+ # # toolbox_sms_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "popup"})), lv.EVENT.CLICKED, None)
+ # toolbox_countdown_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "countdown")), lv.EVENT.CLICKED, None)
+ # toolbox_stopwatch_img_label_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "stopwatch")), lv.EVENT.CLICKED, None)
+ toolbox_step_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "step")), lv.EVENT.PRESSING, None)
+ toolbox_weather_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "weather")), lv.EVENT.PRESSING, None)
+ toolbox_alarm_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "clk_list")), lv.EVENT.PRESSING, None)
+ # toolbox_sms_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "popup"})), lv.EVENT.CLICKED, None)
+ toolbox_countdown_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "countdown")), lv.EVENT.PRESSING, None)
+ toolbox_stopwatch_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "stopwatch")), lv.EVENT.PRESSING, None)
+
+ # toolbox_step_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e,"step")), lv.EVENT.PRESSING, None)
+ # toolbox_weather_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "weather")), lv.EVENT.PRESSING, None)
+ # toolbox_alarm_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "clk_list")), lv.EVENT.PRESSING, None)
+ # # toolbox_sms_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "popup"})), lv.EVENT.CLICKED, None)
+ # toolbox_countdown_img_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "countdown")), lv.EVENT.PRESSING, None)
+ # toolbox_stopwatch_img_label_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_tool_cb(e, "stopwatch")), lv.EVENT.PRESSING, None)
+
self.meta = toolbox_screen
+ def ui_tool_cb(self, e, msg):
+ code = e.get_code()
+ EventMesh.publish("publish_message_event_ui",{"func":self.ui_tool_cb_do,"data":[code,msg]})
+ def ui_tool_cb_do(self, data):
+ #code = e.get_code()
+
+ code = data[0]
+ msg = data[1]
+
+ #print("code!!!!!!!!",code,msg)
+ if code == lv.EVENT.PRESSING:
+ #print("PRESSING")
+ self.is_sliding += 1
+
+ elif code == lv.EVENT.CLICKED:
+ #utime.sleep_ms(10)
+ print("1self.is_sliding",self.is_sliding)
+ if self.is_sliding <= 5 and self.is_sliding != 0:#如果是在滑动中则不需要点击事件
+ EventMesh.publish("load_screen", {"screen": "{}".format(msg)})
+ print("2self.is_sliding",self.is_sliding)
+
+ self.is_sliding =0
+
+
def done_return(self):
EventMesh.publish("load_screen", {"screen": "main_menu"})
EventMesh.publish("watch_top_show")
EventMesh.publish("load_screen", {"screen": "main_menu"})
+ def done_bottom_to_top(self):
+ #print("done_bottom_to_top")
+ self.is_sliding = 0
+ pass
+
+ def done_top_to_bottom(self):
+ #print("done_top_to_bottom")
+ self.is_sliding = 0
+ pass
+ def done_left_to_right(self):
+ #print("done_left_to_right")
+ self.is_sliding = 0
+ pass
+ def done_right_to_left(self):
+ #print("done_right_to_left")
+ self.is_sliding = 0
+ pass
incoming_call_screen = None
incoming_call_img = None
temp = self.weather_data[4]
if temp == None:
+ no_weather_degree.set_pos(88, 15)
weather_tem_label.set_text("_ _")
else:
+ if len(temp) > 2:
+ no_weather_degree.set_pos(100, 15)
+ else:
+ no_weather_degree.set_pos(88, 15)
weather_tem_label.set_text("{}".format(temp))
date = self.weather_data[0]
no_connect_label.set_text("--")
else:#已联网未获取到天气数据
# no_connect_label.set_text(" ")
+ no_weather_degree.set_pos(88, 15)
weather_detail_label.set_text("-/-")
weather_tem_label.set_text("_ _")
-
+ no_weather_degree.set_pos(88, 15)
no_connect_label.set_text("未获取网络数据")
no_connect_label1.set_text("请稍候重试")
else:
-
weather_detail_label.set_text("-/-")
weather_tem_label.set_text("_ _")
-
+ no_weather_degree.set_pos(88, 15)
no_weather_img.clear_flag(lv.obj.FLAG.HIDDEN)
weather_img.add_flag(lv.obj.FLAG.HIDDEN)
no_connect_label.set_text("找不到服务器")
temperature_degree_img = lv.img(temperature_screen)
temperature_degree_img.set_pos(156, 242)
- temperature_degree_img.set_size(22, 22)
+ temperature_degree_img.set_size(11, 11)
temperature_degree_img.set_src("U:/static/degree.png")
temperature_degree_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
print("hour_down:",self.hour)
self.show_value()
+
+
def start(self,e):
global countdown_screen ,countdown_title,countdown_hour ,countdown_mao ,countdown_mao ,countdown_mao1 ,\
countdown_sec ,countdown_hour_up ,countdown_hour_up_btn ,countdown_hour_down ,countdown_hour_down_btn ,\
countdown_end_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
countdown_end_label.set_long_mode(lv.label.LONG.WRAP)
countdown_end_label.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+
+
self.meta = countdown_end_screen
self.FIND_timer_count = 0
EventMesh.publish("close_count_show_info")
-calculator_CALL_MAX_DATA = 16
-
-calculator_line_points = [{"x":0,"y":0},{"x":0,"y":40}]
-calculator_screen = None
-calculator_line = None
-calculator_label = None
-calculator_one = None
-calculator_two = None
-calculator_three = None
-calculator_four = None
-calculator_five = None
-calculator_six = None
-calculator_seven = None
-calculator_eight = None
-calculator_nine = None
-calculator_start = None
-calculator_zero = None
-calculator_hash = None
-calculator_call = None
-calculator_call_btn = None
-calculator_contact = None
-calculator_contact_btn = None
-calculator_delete = None
-calculator_delete_btn = None
-
-class calculatorScreen(Screen):
- NAME = "calculator"
-
- def __init__(self):
-
- super().__init__()
- self.meta = None
- self.phone_num = ''
- self.phone_list = []
- self.button = 0
- self.timer = osTimer()
- self.timer_cb = 0
- self.count = 0
-
-
-
- def initialization(self):
- self.phone_num=''
- self.phone_list = []
- global calculator_screen ,calculator_line,calculator_label,calculator_one,calculator_two,calculator_three,calculator_four,calculator_five,calculator_six,calculator_seven,calculator_eight,calculator_nine,calculator_start,\
- calculator_zero,calculator_hash,calculator_call,calculator_call_btn,calculator_contact,calculator_contact_btn,calculator_delete,calculator_delete_btn
-
- size_x = 36 #按钮大小
- size_y = 22
- start_x = 5
- start_y = 25
-
- offset_y = 4
- if calculator_screen == None:
- calculator_screen = lv.obj()
- print("phone_screen")
- calculator_screen.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
-
- # phone_line = lv.line(phone_screen)
- # phone_line.set_points(phone_line_points,2)
- # phone_line.set_pos(125,5)
- # phone_line.set_size(2,18)
- # phone_line.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
- # phone_line.add_style(style_line,0)
- calculator_label_screen = lv.obj(calculator_screen)
- calculator_label_screen.set_pos(0,0)
- calculator_label_screen.set_size(128,16)
- calculator_label_screen.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
- print("phone_screen")
- calculator_label_screen.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
-
-
- calculator_label = lv.label(calculator_label_screen)
- calculator_label.set_pos(0, 0)
- calculator_label.set_size(0, 20)
- calculator_label.set_text(" ")
- calculator_label.add_style(style_font_youyuan_40, lv.PART.MAIN | lv.STATE.DEFAULT)
-
- calculator_label.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-
- calculator_one = lv.img(calculator_screen)
- calculator_one.set_src("U:/static/IMAGE_NUMBER_KEY1_ICON.png")
- calculator_one.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_one.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_one.set_pos(start_x, start_y)
- calculator_one.set_size(size_x, size_y)
-
- calculator_two = lv.img(calculator_screen)
- calculator_two.set_size(size_x, size_y)
- calculator_two.set_src("U:/static/IMAGE_NUMBER_KEY2_ICON.png")
- calculator_two.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_two.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_two.set_pos(start_x+size_x+5*1, start_y)
-
- calculator_three = lv.img(calculator_screen)
- calculator_three.set_size(size_x, size_y)
- calculator_three.set_src("U:/static/IMAGE_NUMBER_KEY3_ICON.png")
- calculator_three.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_three.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_three.set_pos(start_x+size_x*2+5*2, start_y)
-
- calculator_four = lv.img(calculator_screen)
- calculator_four.set_size(size_x, size_y)
- calculator_four.set_src("U:/static/IMAGE_NUMBER_KEY4_ICON.png")
- calculator_four.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_four.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_four.set_pos(start_x, start_y+size_y+offset_y)
-
- calculator_five = lv.img(calculator_screen)
- calculator_five.set_size(size_x, size_y)
- calculator_five.set_src("U:/static/IMAGE_NUMBER_KEY5_ICON.png")
- calculator_five.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_five.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_five.set_pos(start_x+size_x+5*1, start_y+size_y+offset_y)
-
- calculator_six = lv.img(calculator_screen)
- calculator_six.set_size(size_x, size_y)
- calculator_six.set_src("U:/static/IMAGE_NUMBER_KEY6_ICON.png")
- calculator_six.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_six.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_six.set_pos(start_x+size_x*2+5*2, start_y+size_y+offset_y)
-
- calculator_seven = lv.img(calculator_screen)
- calculator_seven.set_size(size_x, size_y)
- calculator_seven.set_src("U:/static/IMAGE_NUMBER_KEY7_ICON.png")
- calculator_seven.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_seven.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_seven.set_pos(start_x, start_y+size_y*2+offset_y*2)
-
- calculator_eight = lv.img(calculator_screen)
- calculator_eight.set_size(size_x, size_y)
- calculator_eight.set_src("U:/static/IMAGE_NUMBER_KEY8_ICON.png")
- calculator_eight.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_eight.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_eight.set_pos(start_x+size_x+5*1, start_y+size_y*2+offset_y*2)
-
- calculator_nine = lv.img(calculator_screen)
- calculator_nine.set_size(size_x, size_y)
- calculator_nine.set_src("U:/static/IMAGE_NUMBER_KEY9_ICON.png")
- calculator_nine.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_nine.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_nine.set_pos(start_x+size_x*2+5*2, start_y+size_y*2+offset_y*2)
-
- # phone_start = lv.img(phone_screen)
- # phone_start.set_size(size_x, size_y)
- # phone_start.set_src("U:/static/IMAGE_NUMBER_KEYSTAR_ICON.png")
- # phone_start.add_flag(lv.obj.FLAG.CLICKABLE)
- # phone_start.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- # phone_start.set_pos(start_x, start_y+size_y*3)
-
- # calculator_delete = lv.img(calculator_screen)
- # calculator_delete.set_size(size_x, size_y)
- # calculator_delete.set_src("U:/static/IMAGE_BUTTON_DELKEY.png")
- # calculator_delete.add_flag(lv.obj.FLAG.CLICKABLE)
- # calculator_delete.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- # calculator_delete.set_pos(start_x, start_y+size_y*3+offset_y*3)
-
- calculator_delete = lv.label(calculator_screen)
- calculator_delete.set_pos(start_x, start_y+size_y*3+offset_y*3)
- calculator_delete.set_size(start_x+size_x+5*1-start_x, 128-(start_y+size_y*3+offset_y*3))
- calculator_delete.set_text("/")
- calculator_delete.add_style(style_font_youyuan_40, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_delete.set_long_mode(lv.label.LONG.CLIP)
- calculator_delete.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_delete.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-
-
-
- calculator_zero = lv.img(calculator_screen)
- calculator_zero.set_size(size_x, size_y)
- calculator_zero.set_src("U:/static/IMAGE_NUMBER_KEY0_ICON.png")
- calculator_zero.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_zero.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_zero.set_pos(start_x+size_x+5*1, start_y+size_y*3+offset_y*3)
-
- calculator_call = lv.label(calculator_screen)
- calculator_call.set_pos(start_x+size_x*2+5*2, start_y+size_y*3+offset_y*3)
- calculator_call.set_size(128-(start_x+size_x*2+5*2), 128-(start_y+size_y*3+offset_y*3))
- calculator_call.set_text("-")
- calculator_call.add_style(style_font_youyuan_40, lv.PART.MAIN | lv.STATE.DEFAULT)
- calculator_call.set_long_mode(lv.label.LONG.CLIP)
- calculator_call.add_flag(lv.obj.FLAG.CLICKABLE)
- calculator_call.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
- # calculator_call = lv.img(calculator_screen)
- # calculator_call.set_size(size_x, size_y)
- # calculator_call.set_src("U:/static/IMAGE_BUTTON_DIAL.png")
- # calculator_call.add_flag(lv.obj.FLAG.CLICKABLE)
- # calculator_call.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
- # calculator_call.set_pos(start_x+size_x*2+5*2, start_y+size_y*3+offset_y*3)
-
-
-
- self.meta = calculator_screen
-
- calculator_one.add_event_cb(lambda e: EventMesh.callback_wrapper(self.one(e)),
- lv.EVENT.CLICKED, None)
- calculator_two.add_event_cb(lambda e: EventMesh.callback_wrapper(self.two(e)),
- lv.EVENT.CLICKED, None)
- calculator_three.add_event_cb(lambda e: EventMesh.callback_wrapper(self.three(e)),
- lv.EVENT.CLICKED, None)
- calculator_four.add_event_cb(lambda e: EventMesh.callback_wrapper(self.four(e)),
- lv.EVENT.CLICKED, None)
- calculator_five.add_event_cb(lambda e: EventMesh.callback_wrapper(self.five(e)),
- lv.EVENT.CLICKED, None)
- calculator_six.add_event_cb(lambda e: EventMesh.callback_wrapper(self.six(e)),
- lv.EVENT.CLICKED, None)
- calculator_seven.add_event_cb(lambda e: EventMesh.callback_wrapper(self.start(e)),
- lv.EVENT.CLICKED, None)
-
- calculator_seven.add_event_cb(lambda e: EventMesh.callback_wrapper(self.pressed_start(e)),
- lv.EVENT.LONG_PRESSED, None)#长按显示+
-
- calculator_seven.add_event_cb(lambda e: EventMesh.callback_wrapper(self.endpressed_start(e)),
- lv.EVENT.RELEASED, None)#释放按键
-
- calculator_eight.add_event_cb(lambda e: EventMesh.callback_wrapper(self.eight(e)),
- lv.EVENT.CLICKED, None)
- calculator_nine.add_event_cb(lambda e: EventMesh.callback_wrapper(self.start(e)),
- lv.EVENT.CLICKED, None)
-
- calculator_nine.add_event_cb(lambda e: EventMesh.callback_wrapper(self.pressed_start(e)),
- lv.EVENT.LONG_PRESSED, None)#长按显示+
-
- calculator_nine.add_event_cb(lambda e: EventMesh.callback_wrapper(self.nine_endpressed_start(e)),
- lv.EVENT.RELEASED, None)#释放按键
-
- # phone_zero.add_event_cb(lambda e: EventMesh.callback_wrapper(self.zero(e)),
- # lv.EVENT.CLICKED, None)
-
- calculator_zero.add_event_cb(lambda e: EventMesh.callback_wrapper(self.start(e)),
- lv.EVENT.CLICKED, None)#短按显示*
-
- calculator_zero.add_event_cb(lambda e: EventMesh.callback_wrapper(self.pressed_start(e)),
- lv.EVENT.LONG_PRESSED, None)#长按显示+
-
- calculator_zero.add_event_cb(lambda e: EventMesh.callback_wrapper(self.zero_endpressed_start(e)),
- lv.EVENT.RELEASED, None)#释放按键
-
- calculator_call.add_event_cb(lambda e: EventMesh.callback_wrapper(self.call(e)),
- lv.EVENT.CLICKED, None)
- # phone_contact_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.contact(e)),
- # lv.EVENT.CLICKED, None)
- calculator_delete.add_event_cb(lambda e: EventMesh.callback_wrapper(self.delete(e)),
- lv.EVENT.CLICKED, None)
-
- # phone_start.add_event_cb(lambda e: EventMesh.callback_wrapper(self.start(e)),
- # lv.EVENT.CLICKED, None)#短按显示*
-
- # phone_start.add_event_cb(lambda e: EventMesh.callback_wrapper(self.pressed_start(e)),
- # lv.EVENT.LONG_PRESSED, None)#长按显示+
-
- # phone_start.add_event_cb(lambda e: EventMesh.callback_wrapper(self.endpressed_start(e)),
- # lv.EVENT.RELEASED, None)#释放按键
-
-
- # phone_hash.add_event_cb(lambda e: EventMesh.callback_wrapper(self.hash(e)),
- # lv.EVENT.CLICKED, None)
-
-
- self.phone_num=''
- self.calcul_num=''
- self.phone_list = []
- self.one_buf = ''
- self.two_buf = ''
- self.operator = ''
- self.result_buf = ''#计算结果
-
-
- self.count = 0
- self.show_num()
- if calculator_label != None:
- calculator_label.set_pos(0, 0)
- calculator_label.set_size(0, 0)
- calculator_label.set_text(" ")
- #phone_label.set_text(" ")
- # print("self.phone_list :{} self.phone_num:{}".format(self.phone_list,self.phone_num))
- if self.timer_cb == 0:
- self.timer_cb = 1
- # self.timer.start(1000,1,self.refresh_line)
-
-
- def refresh_line(self,e):
- return
- if self.count > 2 :
- self.count = 1
- if self.count%2 == 0:
- phone_line.clear_flag(lv.obj.FLAG.HIDDEN)
- else:
- phone_line.add_flag(lv.obj.FLAG.HIDDEN)
- self.count+=1
- def one(self,e):
- self.input_num("1")
-
- def two(self,e):
- self.input_num("2")
-
- def three(self,e):
- self.input_num(".")
- # self.input_num("3")
-
- def four(self,e):
- self.input_num("4")
-
- def five(self,e):
- self.input_num("5")
-
- def six(self,e):
- self.input_num("6")
-
- def seven(self,e):
- self.input_num("7")
-
- def eight(self,e):
- self.input_num("8")
-
- def nine(self,e):
- self.input_num("9")
-
- def zero(self,e):
- self.input_num("0")
-
- def start(self,e):
- self.button = 0
-
- def pressed_start(self,e):
- self.button = 1
- def Close(self):
- self.timer_cb = 0
- self.timer.stop()
-
- def nine_endpressed_start(self,e):
-
- if self.button == 1:#长按
- self.input_char("=")
-
- else:#短按
- self.input_num("9")
-
-
-
- def zero_endpressed_start(self,e):
-
- if self.button == 1:#长按
- self.input_char("+")
- else:#短按
- self.input_num("0")
-
-
-
- def endpressed_start(self,e):
- if self.button == 1:#长按
- self.input_char("*")
- else:#短按
- self.input_num("7")
-
-
- def hash(self,e):
-
- self.calculator_fun("#")
-
- def is_all_zero(self,lst):
- return all(element == 0 for element in lst)
-
- def input_num(self,msg):#输入数字
- if msg == 'delete':
- if len(self.result_buf) == 0:
- if self.one_buf != '':
- if self.operator != '':
- if self.two_buf != '':
- self.phone_list = list(self.two_buf)
- self.phone_list.pop()
- self.two_buf = ''.join(self.phone_list)
- print("two_buf!!!")
- else:
- self.phone_list = list(self.operator)
- self.phone_list.pop()
- self.operator = ''.join(self.phone_list)
- print("self.operator!!!")
- else:
- self.phone_list = list(self.one_buf)
- self.phone_list.pop()
- self.one_buf = ''.join(self.phone_list)
- print("self.one_buf!!!")
- self.show_result()#显示计算结果以及输入结果
- return
- global calculator_label
- print("input_num",msg)
- if len(self.result_buf) > 0:
- self.result_buf = ''
- self.two_buf = ''
- self.one_buf = ''
-
- if self.one_buf == '':#第一个数字为空
- if msg == '.':#如果第一个数据为空并且输入的第一个数字是.就直接置0.开始
- self.one_buf = "0."
- else:
- self.one_buf = self.one_buf+msg
- else:
- if self.operator == '':#没有特殊字符 + - / * 一直会将数字添加到数字1中 否则添加到数字2中
- if self.one_buf.find('.') == -1:
- if len(self.one_buf) <= 10 and len(self.one_buf) > 0:#第二个数据超过10个数据不让输入 0
- if len(self.one_buf) == 1 and self.one_buf == '0' and msg != '.':
- self.one_buf = msg
- else:
- self.one_buf = self.one_buf+msg#还是第一个数据继续加 0
- pass
- else:
- if len(self.one_buf) > 10:
- print("大于是10位数字")
- pass
- else:
- if msg == '.':
- self.one_buf = '0.'
- else:
- self.one_buf = self.one_buf+msg#还是第一个数据继续加 0
- pass
- else:
- if self.one_buf.find('.') != -1:#找到一个点如果还是点的话不让点
- if msg != '.':
- if len(self.one_buf) <= 10:
- self.one_buf = self.one_buf+msg#还是第一个数据继续加 0
-
- else:
-
- if self.two_buf.find('.') == -1:
- if len(self.two_buf) <= 10 and len(self.two_buf) > 0:#第二个数据超过10个数据不让输入 0
- if len(self.two_buf) == 1 and self.two_buf == '0' and msg != '.':
- self.two_buf = msg
- else:
- self.two_buf = self.two_buf+msg#还是第一个数据继续加 0
- pass
- else:
- if len(self.two_buf) > 10:
- pass
- else:
- if msg == '.':
- self.two_buf = '0.'
- else:
- self.two_buf = self.two_buf+msg#还是第一个数据继续加 0
- pass
- else:
- if self.two_buf.find('.') != -1:
- if msg != '.':
- if len(self.two_buf) <= 10:
- self.two_buf = self.two_buf+msg#还是第一个数据继续加 0
-
-
- self.show_result()#显示计算结果以及输入结果
- pass
-
-
- def input_char(self,msg):#输入字符
-
- if self.one_buf != '':
- if self.one_buf.find(".") != -1:
- tmp = self.one_buf.split(".")[1]
- if len(tmp) == 0:
- self.one_buf = self.one_buf.split('.')[0]
- if self.two_buf != '':
- if self.two_buf.find(".") != -1:
- tmp = self.two_buf.split(".")[1]
- if len(tmp) == 0:
- self.two_buf = self.two_buf.split('.')[0]
-
- global calculator_label
- if len(self.two_buf) != 0 and float(self.two_buf) == 0:#0.000
- if self.operator == '/' and (msg == '/' or msg == '=' or msg == '*'or msg == '+' or msg =='-'):#如果第二个数据为0并且符号是除号就提示除数不为0
- print("除数不可以为0")
- self.operator = ''
- self.one_buf = ''
- self.two_buf = ''
- calculator_label.set_text("除数不可以为0")
- return
- else:
- print("除数不为0")
- self.show_result()
-
- self.result_buf = ''
- print("input_char",msg)
- if self.one_buf != '':#只有第一个数据不为空的时候才可以输入特殊字符
- if msg == "+":#加
- if self.one_buf != '':
- if self.operator != '':#90
- print("operator")
- if self.two_buf != '':#90+90 计算结果 -0.9
-
- if self.one_buf.find('.') != -1:
- if self.one_buf.find('e') == -1:#1.2e
- if int(self.one_buf.split(".")[1]) == 0:
- self.one_buf = self.one_buf.split('.')[0]
-
- if self.two_buf.find('.') != -1:
- if self.two_buf.find('e') == -1:#1.2e
- if int(self.two_buf.split('.')[1]) == 0:
- self.two_buf = self.two_buf.split('.')[0]
-
- str_sum = ''
- # if self.one_buf.find('e') != -1:#1.2e
- # tmp1 = (self.one_buf.split('e')[0])#2.1717041952680391897126070275863e-15
- # tmp2 = (self.one_buf.split('e')[1])
- # if len(tmp2) > 0:
- # self.result_buf = str(eval(tmp1 + "*"+"10**"+tmp2))
- # else:
- # self.result_buf = str(eval(tmp1 + "*"+"10**"+"0"))
- # pass
- # pass
- # else:
- str_sum = (self.one_buf.split()[0])+self.operator+(self.two_buf.split()[0])
- self.result_buf = str(eval(str_sum))
- # pass
-
- print("str_sum",str_sum,self.result_buf)
- if self.result_buf.find('e') == -1:
- if self.result_buf.find('.') != -1:#有小数点
- print("input_dot",self.result_buf)
- if int(self.result_buf.split(".")[1]) == 0:#小数点后面全是0 就取整数
- self.result_buf = (self.result_buf.split(".")[0])
-
- if len(self.result_buf) > 14:#99978654.087766666
- tmp = str(self.result_buf[:14])
- self.result_buf = tmp
-
- self.one_buf = str(self.result_buf)
- self.two_buf = ''
- self.operator = ''
- self.show_result()#显示计算结果以及输入结果
- else:
- if self.operator != '+':#有+就不需要再显示+
- self.operator = msg#90 没有特殊字符则加上不计算结果
- if self.one_buf.split()[0] == 0:#如果数字是0.就显示0负数不在内
- self.one_buf = "0"
- self.show_result()#显示计算结果以及输入结果
- else:
- print("operator !!!!!")
- self.operator = msg
- self.show_result()#显示计算结果以及输入结果
- pass
- elif msg == '-':#减
- if self.one_buf != '':
- if self.operator != '':#90
- print("operator!!!!!!!!!!!!")
- if self.two_buf != '':#90+90 计算结果 -0.9
- if self.one_buf.find('.') != -1:
- if self.one_buf.find('e') == -1:#1.2e
- if int(self.one_buf.split(".")[1]) == 0:
- self.one_buf = self.one_buf.split('.')[0]
-
- if self.two_buf.find('.') != -1:
- if self.two_buf.find('e') == -1:#1.2e
- if int(self.two_buf.split('.')[1]) == 0:
- self.two_buf = self.two_buf.split('.')[0]
- str_sum = ''
- # if self.one_buf.find('e') != -1:#1.2e
- # tmp1 = (self.one_buf.split('e')[0])#2.1717041952680391897126070275863e-15
- # tmp2 = (self.one_buf.split('e')[1])
- # if len(tmp2) > 0:
- # self.result_buf = str(eval(tmp1 + "*"+"10**"+tmp2))
- # else:
- # self.result_buf = str(eval(tmp1 + "*"+"10**"+"0"))
- # pass
- # pass
- # else:
- str_sum = (self.one_buf.split()[0])+self.operator+(self.two_buf.split()[0])
- self.result_buf = str(eval(str_sum))
-
- print("str_sum",str_sum,self.result_buf)
- if self.result_buf.find('e') == -1:
- if self.result_buf.find('.') != -1:#有小数点
- print("input_dot",self.result_buf)
- if int(self.result_buf.split(".")[1]) == 0:#小数点后面全是0 就取整数
- self.result_buf = (self.result_buf.split(".")[0])
-
- if len(self.result_buf) > 14:#99978654.087766666
- tmp = str(self.result_buf[:14])
- self.result_buf = tmp
-
- self.one_buf = str(self.result_buf)
- self.two_buf = ''
- self.operator = ''
- self.show_result()#显示计算结果以及输入结果
- else:
- if self.operator != '-':#有+就不需要再显示+
- self.operator = msg#90 没有特殊字符则加上不计算结果
- if self.one_buf.split()[0] == 0:#如果数字是0.就显示0负数不在内
- self.one_buf = "0"
- self.show_result()#显示计算结果以及输入结果
- else:
- print("operator ---------")
- self.operator = msg
- self.show_result()#显示计算结果以及输入结果
- pass
- elif msg == '*':#乘
- if self.one_buf != '':
- if self.operator != '':#90
- print("operator====***********")
- if self.two_buf != '':#90+90 计算结果 -0.9
- if self.one_buf.find('.') != -1:
- if self.one_buf.find('e') == -1:#1.2e
- if int(self.one_buf.split(".")[1]) == 0:
- self.one_buf = self.one_buf.split('.')[0]
-
- if self.two_buf.find('.') != -1:
- if self.two_buf.find('e') == -1:#1.2e
- if int(self.two_buf.split('.')[1]) == 0:
- self.two_buf = self.two_buf.split('.')[0]
-
- str_sum = ''
- # if self.one_buf.find('e') != -1:#1.2e
- # tmp1 = (self.one_buf.split('e')[0])#2.1717041952680391897126070275863e-15
- # tmp2 = (self.one_buf.split('e')[1])
- # if len(tmp2) > 0:
- # self.result_buf = str(eval(tmp1 + "*"+"10**"+tmp2))
- # else:
- # self.result_buf = str(eval(tmp1 + "*"+"10**"+"0"))
- # pass
- # pass
- # else:
- str_sum = (self.one_buf.split()[0])+self.operator+(self.two_buf.split()[0])
- self.result_buf = str(eval(str_sum))
- # pass
-
- print("str_sum",str_sum,self.result_buf)
- if self.result_buf.find('e') == -1:#有e
- if self.result_buf.find('.') != -1:#有小数点
- print("input_dot",self.result_buf)
- if int(self.result_buf.split(".")[1]) == 0:#小数点后面全是0 就取整数
- self.result_buf = (self.result_buf.split(".")[0])
-
- if len(self.result_buf) > 14:#99978654.087766666
- tmp = str(self.result_buf[:14])
- self.result_buf = tmp
-
- self.one_buf = str(self.result_buf)
- self.two_buf = ''
- self.operator = ''
- self.show_result()#显示计算结果以及输入结果
- else:
- if self.operator != '*':#有+就不需要再显示+
- self.operator = msg#90 没有特殊字符则加上不计算结果
- if self.one_buf.split()[0] == 0:#如果数字是0.就显示0负数不在内
- self.one_buf = "0"
- self.show_result()#显示计算结果以及输入结果
- else:
- print("operator **********")
- self.operator = msg
- self.show_result()#显示计算结果以及输入结果
- pass
-
- elif msg == '/':#除
- if self.one_buf != '':
- if self.operator != '':#90
- print("operator ==== //////////",self.two_buf)
- if self.two_buf != '':#90+90 计算结果 -0.9
- if float(self.two_buf) != 0:
- if self.one_buf.find('.') != -1:
- if self.one_buf.find('e') == -1:#1.2e
- if int(self.one_buf.split(".")[1]) == 0:
- self.one_buf = self.one_buf.split('.')[0]
-
- if self.two_buf.find('.') != -1:
- if self.two_buf.find('e') == -1:#1.2e
- if int(self.two_buf.split('.')[1]) == 0:
- self.two_buf = self.two_buf.split('.')[0]
-
- str_sum = ''
- # if self.one_buf.find('e') != -1:#1.2e
-
- # tmp = (self.one_buf.split('e')[0])
-
- # str_sum = tmp + self.operator + self.two_buf
- # self.result_buf = str(eval(str_sum))+'e'
- # pass
- # else:
- str_sum = (self.one_buf.split()[0])+self.operator+(self.two_buf.split()[0])
- self.result_buf = str(eval(str_sum))
- # pass
-
- print("str_sum",str_sum,self.result_buf)
- if self.result_buf.find('e') == -1:#有小数点
- if self.result_buf.find('.') != -1:#有小数点
- print("input_dot",self.result_buf)
- if int(self.result_buf.split(".")[1]) == 0:#小数点后面全是0 就取整数
- self.result_buf = (self.result_buf.split(".")[0])
-
- # if len(self.result_buf) > 14:#99978654.087766666
- # tmp = str(self.result_buf[:14])
- # self.result_buf = tmp
-
- self.one_buf = str(self.result_buf)
- self.two_buf = ''
- self.operator = ''
- self.show_result()#显示计算结果以及输入结果
- else:
- print("除数不为0")
- else:
- if self.operator != '/':#有+就不需要再显示+
- self.operator = msg#90 没有特殊字符则加上不计算结果
- if self.one_buf.split()[0] == 0:#如果数字是0.就显示0负数不在内
- self.one_buf = "0"
- self.show_result()#显示计算结果以及输入结果
- else:
- print("operator ////////////////////")
- self.operator = msg
- self.show_result()#显示计算结果以及输入结果
- pass
-
- pass
-
- elif msg == '=':#等于
- if self.one_buf != '':
- if self.operator != '':
- print("operator ===========")
- if self.two_buf != '':#90+90 计算结果 -0.9
- if float(self.two_buf) != 0:
- if self.one_buf.find('.') != -1:
- if self.one_buf.find('e') == -1:#1.2e
- if int(self.one_buf.split(".")[1]) == 0:
- self.one_buf = self.one_buf.split('.')[0]
-
- if self.two_buf.find('.') != -1:
- if self.two_buf.find('e') == -1:#1.2e
- if int(self.two_buf.split('.')[1]) == 0:
- self.two_buf = self.two_buf.split('.')[0]
-
- str_sum = ''
- # if self.one_buf.find('e') != -1:#1.2e
- # tmp = (self.one_buf.split('e')[0])
- # str_sum = tmp + self.operator + self.two_buf
- # self.result_buf = str(eval(str_sum))+'e'
- # pass
- # else:
- str_sum = (self.one_buf.split()[0])+self.operator+(self.two_buf.split()[0])
- self.result_buf = str(eval(str_sum))
- # pass
-
- print("str_sum",str_sum,self.result_buf)
- if self.result_buf.find('e') == -1:#有小数点
- if self.result_buf.find('.') != -1:#有小数点
- print("input_dot",self.result_buf)
- if int(self.result_buf.split(".")[1]) == 0:#小数点后面全是0 就取整数
- self.result_buf = (self.result_buf.split(".")[0])
-
- if len(self.result_buf) > 14:#99978654.087766666
- tmp = str(self.result_buf[:14])
- self.result_buf = tmp
-
- self.one_buf = str(self.result_buf)
- self.two_buf = ''
- self.operator = ''
- self.show_result()#显示计算结果以及输入结果
- else:
- if self.operator != '=':#有=就不需要再显示+ 90
- self.operator = '' #90 没有特殊字符则加上不计算结果
- self.two_buf = ''
- self.show_result()#显示计算结果以及输入结果
-
- pass
- else:
- self.operator = ''
- self.two_buf = ''
- self.show_result()#显示计算结果以及输入结果 只显示第一个数据的内容
-
- pass
- else:
- #无效的数据
- pass
-
-
-
- def show_result(self):
- print("self.one_buf ",self.one_buf,self.two_buf,self.operator)
- global calculator_label
- tmp = str(self.one_buf)+str(self.operator)+str(self.two_buf)
- label_size = len(tmp)*16
- calculator_label.set_pos(0, 0)
- calculator_label.set_size(128, 16)
- calculator_label.set_text(tmp)
-
- def calculator_fun(self,msg):
- result = 0
- if len(self.phone_num) >= calculator_CALL_MAX_DATA:#限制拨号数量20个数字
- #self.phone_list.pop(0)
- return
- if len(self.phone_num) != 0:
- if len(self.calcul_num) > 0:
- self.calcul_num = ''
- if msg == "+" or msg == '-' or msg == 'X' or msg == '/':#如果是计算完结果再按特殊字符就让他继续加
- print("不包含特殊字符1")
-
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- else:#
- print("不包含特殊字符2",msg)
- if msg == '=':
- self.show_num()
- else:
-
- self.phone_num = ''
- self.phone_list = []
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
-
- else:
-
-
-
- if self.phone_num.find('/') != -1 or self.phone_num.find('+') != -1 or self.phone_num.find('x') != -1 or self.phone_num.find('-') != -1:
-
-
- tmp_2 = ''
- tmp_3 = ''
- state1 = 0
- state2 = 0
- state3 = 0
- tmp_1 = ''
- tmp = ''
- data1 = 0
- data2 = 0
-
- if self.phone_num.find('+') != -1:#加运算
- if (self.phone_num.split('+')[0]).find('.') == -1:#还没有输入小数点 0.00
- tmp = self.phone_num.split('+')[0]
- tmp = float(tmp.split()[0])
-
-
-
- pass
-
- data1 = float(self.phone_num.split('+')[0])
-
- if len(self.phone_num.split('+')[1]) > 0 and (msg == '+' or msg =='='):#计算结果
- # tmp = self.phone_num.split('+')[0]
- # data1 = float(tmp.split()[0])
- # tmp2 = self.phone_num.split('+')[1]
- # data2 = float(tmp2.split()[0])
- # if self.phone_num.split('+')[0].find('.') == -1:
- # if int(data2) == 0:
- # data1 = int(data1)
-
- # if self.phone_num.split('+')[1].find('.') == -1:
- # if int(data2) == 0:
- # data2 = int(data2)
- if self.phone_num.find('e') != -1:
- if (self.phone_num.split('+')[0]).split('e') != -1 or (self.phone_num.split('+')[1]).split('e') != -1:
- if (self.phone_num.split('+')[0]).split('e') != -1 and (self.phone_num.split('+')[1]).split('e') != -1:
- self.phone_num = "2.71828182+2.71828182"
- elif (self.phone_num.split('+')[0]).split('e') != -1:
- self.phone_num = self.phone_num.split('+')[0] +"2.71828182"
- elif (self.phone_num.split('+')[1]).split('e') != -1:
- self.phone_num = "2.71828182"+ self.phone_num.split('+')[1]
-
- sum = eval(self.phone_num)
-
- result = sum
- print("data1",data1,data2,result,sum)
- self.calcul_num = str(result)
- self.calaulator_results()
-
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
- print("加数====",result)
- else:
- if msg == '-' or msg == '/' or msg == 'X':
- self.phone_list.pop()
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- print("减数")
- else:
- if msg != '=' and msg != '+':
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- else:
- result = data1
- result_tmp = str(result)
- if result_tmp.find('.') != -1:
- tmp_zero = int(result_tmp.split('.')[1])
- if tmp_zero == 0:
- result = result_tmp.split('.')[0]
- print("data1!!!!!!!!!!",data1,data2,result)
- self.calcul_num = str(result)
- self.calaulator_results()
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
- print("减数")
- print("加数")
-
- if self.phone_num.find('-') != -1:#减运算
- data1 = float(self.phone_num.split('-')[0])
- if len(self.phone_num.split('-')[1]) > 0 and (msg == '-' or msg =='='):#计算结果
- data2 = float(self.phone_num.split('-')[1])
- # if self.phone_num.split('-')[0].find('.') == -1:
- # if int(data1) == 0:
- # data1 = int(data1)
-
- # if self.phone_num.split('-')[1].find('.') == -1:
- # if int(data2.slpit('.')[1]) == 0:
- # data2 = int(data2)
- result = data1-data2
- print("data1222222222222",data1,data2,result)
- self.calcul_num = str(result)
- self.calaulator_results()
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
- else:
- if msg == '+' or msg == '/' or msg == 'X':
- self.phone_list.pop()
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- print("减数")
- else:
- if msg != '=' and msg != '-':
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- else:
- # if self.phone_num.split('-')[1].find('.') == -1:
- # if int(data1.slpit('.')[1]) == 0:
- # data1 = int(data1)
- result = data1
- result_tmp = str(result)
- if result_tmp.find('.') != -1:
- tmp_zero = int(result_tmp.split('.')[1])
- if tmp_zero == 0:
- result = result_tmp.split('.')[0]
- print("data333333",data1)
- self.calcul_num = str(result)
- self.calaulator_results()
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
-
-
- if self.phone_num.find('X') != -1:#乘运算
- data1 = float(self.phone_num.split('X')[0])
- if len(self.phone_num.split('X')[1]) > 0 and (msg == 'X' or msg =='='):#计算结果
-
- data2 = float(self.phone_num.split('X')[1])
- # if self.phone_num.split('X')[0].find('.') == -1:
- # if int(data1.slpit('.')[1]) == 0:
- # data1 = int(data1)
-
- # if self.phone_num.split('X')[1].find('.') == -1:
- # if int(self.phone_num.split('X')[1].find('.').slpit('.')[1]) == 0:
- # data2 = int(data2)
-
- result = data1*data2
- print("data44444",data1,data2)
- self.calcul_num = str(result)
- self.calaulator_results()
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
- print("乘数====",result)
- else:
- if msg == '+' or msg == '/' or msg == '-':
- self.phone_list.pop()
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- print("乘数")
- else:
- if msg != '=' and msg != 'X':
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- else:
- # if self.phone_num.split('X')[0].find('.') == -1:
- # if (self.phone_num.split('X')[1].find('.') == -1:)
- result = data1
- result_tmp = str(result)
- if result_tmp.find('.') != -1:
- tmp_zero = int(result_tmp.split('.')[1])
- if tmp_zero == 0:
- result = result_tmp.split('.')[0]
- print("data5555555",data1,data2)
- self.calcul_num = str(result)
- self.calaulator_results()
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
-
-
- if self.phone_num.find('/') != -1:#除运算
-
- tmp = self.phone_num.split('/')[0]
- tmp_1 = self.phone_num.split('/')[1]
- if len(tmp_1) > 0 and (msg == '/' or msg == '='):
- if tmp_1.find('.') != -1:
- state1 = int(tmp_1.split('.')[0])#0.009 10:00
- state2 = int(tmp_1.split('.')[1])#0.009
-
- else:
- state1 = int(tmp_1) #10
-
- print("state3",state1,state2,state3,tmp_1)
- if (state1 == 0 and state2 == 0):
- print("除数不可以为0")
- else:
- data1 = float(self.phone_num.split('/')[0])
- data2 = 0
- # if data1.find('.') == -1:
- # if int(data1.slpit('.')[1]) == 0:
- # data1 = int(data1)
-
- # if data2.find('.') == -1:
- # if int(data2.slpit('.')[1]) == 0:
- # data2 = int(data2)
-
- if len(self.phone_num.split('/')[1]) > 0:
- data2 = float(self.phone_num.split('/')[1])
- if data2 != 0:
- result = data1/data2
- else:
- result = data1
- print("data6666666",data1,data2)
-
- result_tmp = str(result)
- if result_tmp.find('.') != -1:
- tmp_zero = int(result_tmp.split('.')[1])
- if tmp_zero == 0:
- result = result_tmp.split('.')[0]
- else:
- pass
- self.calcul_num = str(result)
- self.calaulator_results()
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
- else:
- if msg == '+' or msg == 'X' or msg == '-':
- self.phone_list.pop()
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- print("减数")
- else:
- if msg != '=' and msg != '/':
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- else:
- result = float(tmp)
- self.calcul_num = str(result)
- print("data7777777777",result)
- self.calaulator_results()
- self.phone_num = self.calcul_num
- self.phone_list = list(self.phone_num)
- print("除数没有数字")
- else:
-
-
- if msg == '=':
- self.show_num()
- pass
- else:
- if msg == "+" and msg == '-' and msg == 'X' and msg == '/':#如果是计算完结果再按特殊字符就让他继续加
- print("不包含特殊字符")
- self.calcul_num = ''
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- elif msg == ".":
- if self.phone_num.find('.') == -1:#还没有输入小数点
- self.phone_num = '0.'
- self.phone_list = list(self.phone_num)
- self.show_num()
- pass
- else:#
- print("不包含特殊字符")
- if len(self.calcul_num) > 0:#表示已计算了一次结果 全部置0
- self.phone_num = ''
- self.phone_list = []
- self.calcul_num = ''
-
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
-
- else:
- if msg != "+" and msg != '-' and msg != 'X' and msg != '/':
- print("数组为0时")
- self.phone_list.append(msg)
- self.phone_num = ''.join(self.phone_list)
- self.show_num()
- pass
-
- def delete(self,e):
- self.input_char("/")
- # if len(self.phone_list) != 0:
- # self.phone_list.pop()
- # self.phone_num = ''.join(self.phone_list)
- # self.show_num()
-
- def contact(self,e):
- EventMesh.publish("load_screen", {"screen": "contacts"})
-
- def call(self,e):
- self.input_char("-")
-
- def show_num(self):
- print("self.phone_num ",self.phone_num,self.phone_list)
- pass
- # global calculator_label
- # calculator_label.set_pos(0, 5)
- # calculator_label.set_size(128, 20)
- # calculator_label.set_text(self.phone_num)
-
- def calaulator_results(self):#计算结果显示
- pass
-
-
- def lcd_on(self):
- if self.timer_cb != 0:
- self.timer_cb = 0
- self.timer.start(1000,1,self.refresh_line)
-
- def lcd_off(self):
- self.timer_cb = 1
- self.timer.stop()
-
-
- def done_return(self):
- EventMesh.publish("load_screen", {"screen": "main_menu"})
-
- def btn1_release(self):
- EventMesh.publish("load_screen", {"screen": "main_menu"})
-
- def btn8_press(self):
- EventMesh.publish("watch_top_show")
- EventMesh.publish("load_screen", {"screen": "main_menu"})
-
rrestor_confirm_n_screen = None
rrestor_confirm_n_screen_label = None
MainMenu2_til = lv.tileview(MainMenu2)
MainMenu2_til.set_scrollbar_mode(0)
MainMenu2_til.add_style(style_MainMenu_screen_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-#表盘
-MainMenu2_Watchface = MainMenu2_til.add_tile(0, 1, lv.DIR.LEFT | lv.DIR.RIGHT)
+#工具箱
+MainMenu2_toolbox = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_toolbox)
+label_text.set_pos(0, 0)
+label_text.set_size(0, 0)
+label_text.set_text("{}".format(MainMenu2_num))
+MainMenu2_img_toolbox = lv.img(MainMenu2_toolbox)
+MainMenu2_img_toolbox.set_size(80,80)
+MainMenu2_img_toolbox.set_pos(24,10)
+MainMenu2_img_toolbox.set_src("U:/static/IMAGE_ONE_PAGE_TOOLS.png")
+MainMenu2_img_toolbox.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_toolbox.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-label_text = lv.label(MainMenu2_Watchface)
+MainMenu2_img_toolbox_txt = lv.label(MainMenu2_toolbox)
+MainMenu2_img_toolbox_txt.set_pos(int(0),int(100))
+MainMenu2_img_toolbox_txt.set_size(128,20)
+MainMenu2_img_toolbox_txt.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_toolbox_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+MainMenu2_img_toolbox_txt.set_text("工具箱")
+MainMenu2_img_toolbox_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
+MainMenu2_num+=1
+MainMenu2x+=1
+
+#加好友，暂时没有
+MainMenu2_toolbox = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_toolbox)
label_text.set_pos(0, 0)
label_text.set_size(0, 0)
label_text.set_text("{}".format(MainMenu2_num))
+MainMenu2_img_add_friends = lv.img(MainMenu2_toolbox)
+MainMenu2_img_add_friends.set_size(80,80)
+MainMenu2_img_add_friends.set_pos(24,10)
+MainMenu2_img_add_friends.set_src("U:/static/IMAGE_ONE_PAGE_TOOLS.png")
+MainMenu2_img_add_friends.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_add_friends.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+MainMenu2_img_add_friends_txt = lv.label(MainMenu2_toolbox)
+MainMenu2_img_add_friends_txt.set_pos(int(0),int(100))
+MainMenu2_img_add_friends_txt.set_size(128,20)
+MainMenu2_img_add_friends_txt.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_add_friends_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+MainMenu2_img_add_friends_txt.set_text("加好友")
+MainMenu2_img_add_friends_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
MainMenu2_num+=1
+MainMenu2x+=1
-#拨号盘
-MainMenu2_phone = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-label_text = lv.label(MainMenu2_phone)
+#微聊
+MainMenu2_wechat = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_wechat)
label_text.set_pos(0, 0)
label_text.set_size(0, 0)
label_text.set_text("{}".format(MainMenu2_num))
-MainMenu2_img_phone = lv.img(MainMenu2_phone)
-MainMenu2_img_phone.set_size(80,80)
-MainMenu2_img_phone.set_pos(24,10)
-MainMenu2_img_phone.set_src("U:/static/IMAGE_ONE_PAGE_CALL.png")
-MainMenu2_img_phone.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_phone.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+MainMenu2_img_wechat = lv.img(MainMenu2_wechat)
+MainMenu2_img_wechat.set_size(80,80)
+MainMenu2_img_wechat.set_pos(24,10)
+MainMenu2_img_wechat.set_src("U:/static/IMAGE_ONE_PAGE_WECHAT.png")
+MainMenu2_img_wechat.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_wechat.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-MainMenu2_img_phone_text = lv.label(MainMenu2_phone)
-MainMenu2_img_phone_text.set_pos(int(0),int(100))
-MainMenu2_img_phone_text.set_size(128,20)
-MainMenu2_img_phone_text.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_phone_text.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-MainMenu2_img_phone_text.set_text("拨号盘")
-MainMenu2_img_phone_text.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
+MainMenu2_img_wechat_txt = lv.label(MainMenu2_wechat)
+MainMenu2_img_wechat_txt.set_pos(int(0),int(100))
+MainMenu2_img_wechat_txt.set_size(128,20)
+MainMenu2_img_wechat_txt.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_wechat_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+MainMenu2_img_wechat_txt.set_text("微聊")
+MainMenu2_img_wechat_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
+MainMenu2_num+=1
+MainMenu2x+=1
+
+#视频通话
+MainMenu2_heartrate = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_heartrate)
+label_text.set_pos(0, 0)
+label_text.set_size(0, 0)
+label_text.set_text("{}".format(MainMenu2_num))
+MainMenu2_img_health = lv.img(MainMenu2_heartrate)
+MainMenu2_img_health.set_size(80,80)
+MainMenu2_img_health.set_pos(24,10)
+MainMenu2_img_health.set_src("U:/static/IMAGE_ONE_PAGE_HEALTH.png")
+MainMenu2_img_health.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_health.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+MainMenu2_img_health_txt = lv.label(MainMenu2_heartrate)
+MainMenu2_img_health_txt.set_pos(int(0),int(100))
+MainMenu2_img_health_txt.set_size(128,20)
+MainMenu2_img_health_txt.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_health_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+MainMenu2_img_health_txt.set_text("视频通话")
+MainMenu2_img_health_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
MainMenu2_num+=1
MainMenu2x+=1
+#表盘
+MainMenu2_Watchface = MainMenu2_til.add_tile(MainMenu2_num,0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_Watchface)
+label_text.set_pos(0, 0)
+label_text.set_size(0, 0)
+label_text.set_text("{}".format(MainMenu2_num))
+MainMenu2_num+=1
+MainMenu2x+=1
+
+
+
#通讯录
MainMenu2_contacts = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
label_text = lv.label(MainMenu2_contacts)
MainMenu2_num+=1
MainMenu2x+=1
-#短信
-MainMenu2_SMS = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-label_text = lv.label(MainMenu2_SMS)
-label_text.set_pos(0, 0)
-label_text.set_size(0, 0)
-label_text.set_text("{}".format(MainMenu2_num))
-MainMenu2_img_sms = lv.img(MainMenu2_SMS)
-MainMenu2_img_sms.set_size(80,80)
-MainMenu2_img_sms.set_pos(24,10)
-MainMenu2_img_sms.set_src("U:/static/IMAGE_ONE_PAGE_SMS.png")
-MainMenu2_img_sms.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_sms.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-
-MainMenu2_img_sms_txt = lv.label(MainMenu2_SMS)
-MainMenu2_img_sms_txt.set_pos(int(0),int(100))
-MainMenu2_img_sms_txt.set_size(128,20)
-MainMenu2_img_sms_txt.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_sms_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-MainMenu2_img_sms_txt.set_text("短信")
-MainMenu2_img_sms_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
-MainMenu2_num+=1
-MainMenu2x+=1
-#微聊
-MainMenu2_wechat = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-label_text = lv.label(MainMenu2_wechat)
+#拨号盘
+MainMenu2_phone = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_phone)
label_text.set_pos(0, 0)
label_text.set_size(0, 0)
label_text.set_text("{}".format(MainMenu2_num))
-MainMenu2_img_wechat = lv.img(MainMenu2_wechat)
-MainMenu2_img_wechat.set_size(80,80)
-MainMenu2_img_wechat.set_pos(24,10)
-MainMenu2_img_wechat.set_src("U:/static/IMAGE_ONE_PAGE_WECHAT.png")
-MainMenu2_img_wechat.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_wechat.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+MainMenu2_img_phone = lv.img(MainMenu2_phone)
+MainMenu2_img_phone.set_size(80,80)
+MainMenu2_img_phone.set_pos(24,10)
+MainMenu2_img_phone.set_src("U:/static/IMAGE_ONE_PAGE_CALL.png")
+MainMenu2_img_phone.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_phone.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-MainMenu2_img_wechat_txt = lv.label(MainMenu2_wechat)
-MainMenu2_img_wechat_txt.set_pos(int(0),int(100))
-MainMenu2_img_wechat_txt.set_size(128,20)
-MainMenu2_img_wechat_txt.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_wechat_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-MainMenu2_img_wechat_txt.set_text("微聊")
-MainMenu2_img_wechat_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
+MainMenu2_img_phone_text = lv.label(MainMenu2_phone)
+MainMenu2_img_phone_text.set_pos(int(0),int(100))
+MainMenu2_img_phone_text.set_size(128,20)
+MainMenu2_img_phone_text.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_phone_text.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+MainMenu2_img_phone_text.set_text("拨号盘")
+MainMenu2_img_phone_text.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
MainMenu2_num+=1
MainMenu2x+=1
-#健康测量
-# MainMenu2_heartrate = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-# label_text = lv.label(MainMenu2_heartrate)
-# label_text.set_pos(0, 0)
-# label_text.set_size(0, 0)
-# label_text.set_text("{}".format(MainMenu2_num))
-# MainMenu2_img_health = lv.img(MainMenu2_heartrate)
-# MainMenu2_img_health.set_size(80,80)
-# MainMenu2_img_health.set_pos(24,10)
-# MainMenu2_img_health.set_src("U:/static/IMAGE_ONE_PAGE_HEALTH.png")
-# MainMenu2_img_health.add_flag(lv.obj.FLAG.CLICKABLE)
-# MainMenu2_img_health.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-
-# MainMenu2_img_health_txt = lv.label(MainMenu2_heartrate)
-# MainMenu2_img_health_txt.set_pos(int(0),int(100))
-# MainMenu2_img_health_txt.set_size(128,20)
-# MainMenu2_img_health_txt.add_flag(lv.obj.FLAG.CLICKABLE)
-# MainMenu2_img_health_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-# MainMenu2_img_health_txt.set_text("健康测量")
-# MainMenu2_img_health_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
-# MainMenu2_num+=1
-# MainMenu2x+=1
-
-#视频通话
-MainMenu2_camera_video = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-label_text = lv.label(MainMenu2_camera_video)
+#相机
+MainMenu2_camera = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_camera)
label_text.set_pos(0, 0)
label_text.set_size(0, 0)
label_text.set_text("{}".format(MainMenu2_num))
-MainMenu2_img_camera_video = lv.img(MainMenu2_camera_video)
-MainMenu2_img_camera_video.set_size(80,80)
-MainMenu2_img_camera_video.set_pos(24,10)
-MainMenu2_img_camera_video.set_src("U:/static/IMAGE_ONE_PAGE_VIDEOCALL.png")
-MainMenu2_img_camera_video.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_camera_video.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-
-MainMenu2_img_camera_video_txt = lv.label(MainMenu2_camera_video)
-MainMenu2_img_camera_video_txt.set_pos(int(0),int(100))
-MainMenu2_img_camera_video_txt.set_size(128,20)
-MainMenu2_img_camera_video_txt.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_camera_video_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-MainMenu2_img_camera_video_txt.set_text("视频通话")
-MainMenu2_img_camera_video_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
+MainMenu2_img_camera = lv.img(MainMenu2_camera)
+MainMenu2_img_camera.set_size(80,80)
+MainMenu2_img_camera.set_pos(24,10)
+MainMenu2_img_camera.set_src("U:/static/IMAGE_ONE_PAGE_CAMERA.png")
+MainMenu2_img_camera.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_camera.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+MainMenu2_img_camera_txt = lv.label(MainMenu2_camera)
+MainMenu2_img_camera_txt.set_pos(int(0),int(100))
+MainMenu2_img_camera_txt.set_size(128,20)
+MainMenu2_img_camera_txt.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_camera_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+MainMenu2_img_camera_txt.set_text("相机")
+MainMenu2_img_camera_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
MainMenu2_num+=1
MainMenu2x+=1
-# #相机
-# MainMenu2_camera = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-# label_text = lv.label(MainMenu2_camera)
-# label_text.set_pos(0, 0)
-# label_text.set_size(0, 0)
-# label_text.set_text("{}".format(MainMenu2_num))
-# MainMenu2_img_camera = lv.img(MainMenu2_camera)
-# MainMenu2_img_camera.set_size(80,80)
-# MainMenu2_img_camera.set_pos(24,10)
-# MainMenu2_img_camera.set_src("U:/static/IMAGE_ONE_PAGE_CAMERA.png")
-# MainMenu2_img_camera.add_flag(lv.obj.FLAG.CLICKABLE)
-# MainMenu2_img_camera.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-
-# MainMenu2_img_camera_txt = lv.label(MainMenu2_camera)
-# MainMenu2_img_camera_txt.set_pos(int(0),int(100))
-# MainMenu2_img_camera_txt.set_size(128,20)
-# MainMenu2_img_camera_txt.add_flag(lv.obj.FLAG.CLICKABLE)
-# MainMenu2_img_camera_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-# MainMenu2_img_camera_txt.set_text("相机")
-# MainMenu2_img_camera_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
-# MainMenu2_num+=1
-# MainMenu2x+=1
-
-
-# #相册
-# MainMenu2_camera_album = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-# label_text = lv.label(MainMenu2_camera_album)
-# label_text.set_pos(0, 0)
-# label_text.set_size(0, 0)
-# label_text.set_text("{}".format(MainMenu2_num))
-# MainMenu2_img_camera_album = lv.img(MainMenu2_camera_album)
-# MainMenu2_img_camera_album.set_size(80,80)
-# MainMenu2_img_camera_album.set_pos(24,10)
-# MainMenu2_img_camera_album.set_src("U:/static/IMAGE_ONE_PAGE_ALBUM.png")
-# MainMenu2_img_camera_album.add_flag(lv.obj.FLAG.CLICKABLE)
-# MainMenu2_img_camera_album.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-
-# MainMenu2_img_camera_album_txt = lv.label(MainMenu2_camera_album)
-# MainMenu2_img_camera_album_txt.set_pos(int(0),int(100))
-# MainMenu2_img_camera_album_txt.set_size(128,20)
-# MainMenu2_img_camera_album_txt.add_flag(lv.obj.FLAG.CLICKABLE)
-# MainMenu2_img_camera_album_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-# MainMenu2_img_camera_album_txt.set_text("相册")
-# MainMenu2_img_camera_album_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
-# MainMenu2_num+=1
-# MainMenu2x+=1
-#工具箱
-MainMenu2_toolbox = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
-label_text = lv.label(MainMenu2_toolbox)
+#相册
+MainMenu2_camera_album = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+label_text = lv.label(MainMenu2_camera_album)
label_text.set_pos(0, 0)
label_text.set_size(0, 0)
label_text.set_text("{}".format(MainMenu2_num))
-MainMenu2_img_toolbox = lv.img(MainMenu2_toolbox)
-MainMenu2_img_toolbox.set_size(80,80)
-MainMenu2_img_toolbox.set_pos(24,10)
-MainMenu2_img_toolbox.set_src("U:/static/IMAGE_ONE_PAGE_TOOLS.png")
-MainMenu2_img_toolbox.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_toolbox.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
-
-MainMenu2_img_toolbox_txt = lv.label(MainMenu2_toolbox)
-MainMenu2_img_toolbox_txt.set_pos(int(0),int(100))
-MainMenu2_img_toolbox_txt.set_size(128,20)
-MainMenu2_img_toolbox_txt.add_flag(lv.obj.FLAG.CLICKABLE)
-MainMenu2_img_toolbox_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-MainMenu2_img_toolbox_txt.set_text("工具箱")
-MainMenu2_img_toolbox_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
+MainMenu2_img_camera_album = lv.img(MainMenu2_camera_album)
+MainMenu2_img_camera_album.set_size(80,80)
+MainMenu2_img_camera_album.set_pos(24,10)
+MainMenu2_img_camera_album.set_src("U:/static/IMAGE_ONE_PAGE_ALBUM.png")
+MainMenu2_img_camera_album.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_camera_album.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+MainMenu2_img_camera_album_txt = lv.label(MainMenu2_camera_album)
+MainMenu2_img_camera_album_txt.set_pos(int(0),int(100))
+MainMenu2_img_camera_album_txt.set_size(128,20)
+MainMenu2_img_camera_album_txt.add_flag(lv.obj.FLAG.CLICKABLE)
+MainMenu2_img_camera_album_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+MainMenu2_img_camera_album_txt.set_text("相册")
+MainMenu2_img_camera_album_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
MainMenu2_num+=1
MainMenu2x+=1
+
+
#设置
MainMenu2_setting = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
#MainMenu2_setting.set_tile_act(0,0,lv.ANIM.ON)
+# #短信
+# MainMenu2_SMS = MainMenu2_til.add_tile(MainMenu2x, 0, lv.DIR.LEFT | lv.DIR.RIGHT)
+# label_text = lv.label(MainMenu2_SMS)
+# label_text.set_pos(0, 0)
+# label_text.set_size(0, 0)
+# label_text.set_text("{}".format(MainMenu2_num))
+# MainMenu2_img_sms = lv.img(MainMenu2_SMS)
+# MainMenu2_img_sms.set_size(80,80)
+# MainMenu2_img_sms.set_pos(24,10)
+# MainMenu2_img_sms.set_src("U:/static/IMAGE_ONE_PAGE_SMS.png")
+# MainMenu2_img_sms.add_flag(lv.obj.FLAG.CLICKABLE)
+# MainMenu2_img_sms.add_style(style_MainMenu_img_default, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+# MainMenu2_img_sms_txt = lv.label(MainMenu2_SMS)
+# MainMenu2_img_sms_txt.set_pos(int(0),int(100))
+# MainMenu2_img_sms_txt.set_size(128,20)
+# MainMenu2_img_sms_txt.add_flag(lv.obj.FLAG.CLICKABLE)
+# MainMenu2_img_sms_txt.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+# MainMenu2_img_sms_txt.set_text("短信")
+# MainMenu2_img_sms_txt.add_style(style_font_youyuan_font_60, lv.PART.MAIN|lv.STATE.DEFAULT)
+# MainMenu2_num+=1
+# MainMenu2x+=1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
MainMenu2_img_phone.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "Phone")), lv.EVENT.CLICKED, None)
MainMenu2_img_toolbox.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "toolbox")), lv.EVENT.CLICKED, None)
MainMenu2_img_setting.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "setting")), lv.EVENT.CLICKED, None)
- MainMenu2_img_camera_video.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "camera_video")), lv.EVENT.CLICKED, None)
+ MainMenu2_img_add_friends.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "toolbox")), lv.EVENT.CLICKED, None)
+ # MainMenu2_img_camera_video.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "camera_video")), lv.EVENT.CLICKED, None)
# MainMenu2_img_camera.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "camera")), lv.EVENT.CLICKED, None)
# MainMenu2_img_camera_album.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "camera_album")), lv.EVENT.CLICKED, None)
MainMenu2_img_contacts.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "contacts")), lv.EVENT.CLICKED, None)
MainMenu2_img_wechat.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "wechat")), lv.EVENT.CLICKED, None)
# MainMenu2_img_spo2.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "spo2")), lv.EVENT.CLICKED, None)
- MainMenu2_img_sms.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "popup")), lv.EVENT.CLICKED, None)
+ #MainMenu2_img_sms.add_event_cb(lambda e: EventMesh.callback_wrapper(self.img_cb(e, "popup")), lv.EVENT.CLICKED, None)
EventMesh.subscribe("watch_top_show", self.watch_top_show)
def initialization(self):
self.watchface.initialization(MainMenu2_Watchface)
-
+ print("self.menu_id",self.menu_id)
if self.menu_id =="0":
- MainMenu2_til.set_tile_id(0,1,lv.ANIM.OFF)
+ MainMenu2_til.set_tile_id(4,0,lv.ANIM.OFF)
# if self.meta_info in globals() :
# MainMenu2_til.set_tile_id(self.meta_info[0],self.meta_info[1],lv.ANIM.OFF)
pass#
if code == lv.EVENT.SCROLL_END:
pass
def watch_top_show(self, event, msg): #
- MainMenu2_til.set_tile_id(0,1,lv.ANIM.OFF)
+ MainMenu2_til.set_tile_id(4,0,lv.ANIM.OFF)
def img_cb(self, e, msg):
state = EventMesh.publish("get_key_board", "key_board")
self.watchface.timer_update.stop()
def done_return(self):
- MainMenu2_til.set_tile_id(0,1,lv.ANIM.OFF)
+ MainMenu2_til.set_tile_id(4,0,lv.ANIM.OFF)
def btn1_release(self):
flag = EventMesh.publish("get_lcd_state")
else:
if MainMenu2_til.get_tile_act() != None:
id = MainMenu2_til.get_tile_act().get_child(0).get_text()
- if id != "0":
- MainMenu2_til.set_tile_id(0,1,lv.ANIM.OFF)
+ #if id != "0":
+
+ MainMenu2_til.set_tile_id(4,0,lv.ANIM.OFF)
def return_setiing(self, event, msg):
MainMenu2_til.set_tile_id(7,0,lv.ANIM.OFF)
flag = EventMesh.publish("get_lcd_state")
if MainMenu2_til.get_tile_act() != None:
id = MainMenu2_til.get_tile_act().get_child(0).get_text()
- if id == "0":
+ if id == "4":
if flag == 1:
EventMesh.publish(constants.EVENT.SYSTEM_SLEEP)
else:
EventMesh.publish(constants.EVENT.SYSTEM_UP)
else:
if flag == 1:
- MainMenu2_til.set_tile_id(0,1,lv.ANIM.OFF)
+ MainMenu2_til.set_tile_id(4,0,lv.ANIM.OFF)
else:
EventMesh.publish(constants.EVENT.SYSTEM_UP)
else:
if flag == 1:
- MainMenu2_til.set_tile_id(0,1,lv.ANIM.OFF)
+ MainMenu2_til.set_tile_id(4,0,lv.ANIM.OFF)
else:
EventMesh.publish(constants.EVENT.SYSTEM_UP)
def done_bottom_to_top(self):
id = MainMenu2_til.get_tile_act().get_child(0).get_text()
- if id == "0":
+ if id == "4":
EventMesh.publish("load_screen", {"screen": "call_log"})
self.menu_id = id
def done_top_to_bottom(self):
id = MainMenu2_til.get_tile_act().get_child(0).get_text()
- if id == "0":
+ if id == "4":
EventMesh.publish("load_screen", {"screen": "popup"})
self.menu_id = id
def done_left_to_right(self):
- id = MainMenu2_til.get_tile_act().get_child(0).get_text()
- print("done_left_to_right:ID{}".format(id))
- if id == "0":
- MainMenu2_til.set_tile_id(MainMenu2_num-2,0,lv.ANIM.OFF)
- elif self.menu_id != '2' and id == '1':
- MainMenu2_til.set_tile_id(MainMenu2_num-2,0,lv.ANIM.OFF)
self.menu_id = id
+ # id = MainMenu2_til.get_tile_act().get_child(0).get_text()
+ # print("done_left_to_right:ID{}".format(id))
+ # if id == "0":
+ # MainMenu2_til.set_tile_id(MainMenu2_num-2,0,lv.ANIM.OFF)
+ # elif self.menu_id != '2' and id == '1':
+ # MainMenu2_til.set_tile_id(MainMenu2_num-2,0,lv.ANIM.OFF)
+ # self.menu_id = id
+ pass
def done_right_to_left(self):
- id = MainMenu2_til.get_tile_act().get_child(0).get_text()
- print("done_right_to_left:ID{}".format(id))
- if id == "0":
- MainMenu2_til.set_tile_id(0,0,lv.ANIM.OFF)
- elif (self.menu_id != str(MainMenu2_num-2) ) and id == str(MainMenu2_num-1) :
- MainMenu2_til.set_tile_id(0,0,lv.ANIM.OFF)
- self.menu_id = id
-
+ self.menu_id = id
+ # id = MainMenu2_til.get_tile_act().get_child(0).get_text()
+ # print("done_right_to_left:ID{}".format(id))
+ # if id == "0":
+ # MainMenu2_til.set_tile_id(0,0,lv.ANIM.OFF)
+ # elif (self.menu_id != str(MainMenu2_num-2) ) and id == str(MainMenu2_num-1) :
+ # MainMenu2_til.set_tile_id(0,0,lv.ANIM.OFF)
+ # self.menu_id = id
+ pass
def Close(self):
self.watchface.Close()
print("main_menu Close !!!!!!!!")
- self.menu_id = '1'
+ # self.menu_id = '0'
return
import ql_fs
import EventMesh
from misc import Power
-from ui import style_screen,style_font_youyuan_20,style_btn,style_img,Screen,style_contact_btn,style_bar,style_bar_indic
+from ui import style_screen,style_font_youyuan_20_gray,style_screen_btn_1_main_main_default,style_font_youyuan_20,style_btn,style_img,Screen,style_contact_btn,style_bar,style_bar_indic
import constants
import osTimer
import audio
# -------------------------------------------setting screen----------------------------------------------------------
+
set_icon_x = 25
set_icon_y = 25
style_volume_btn.set_bg_color(lv.color_make(0x80, 0x80, 0x80))
-
setting_cont_y = 5
+setting_cont_offset = 40
setting_screen = lv.obj()
print("setting_screen")
setting_screen.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
setting_cont = lv.obj(setting_screen)
-setting_cont.set_pos(0, 0)
-setting_cont.set_size(128, 128)
+setting_cont.set_pos(0, 5)
+setting_cont.set_size(128, 123)
setting_cont.add_style(setting_cont_style,lv.PART.MAIN | lv.STATE.DEFAULT)
# setting_language = lv.btn(setting_cont)
# setting_language_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
#setting_cont_y += 60
+setting_dialswitch_img_btn_1 = lv.btn(setting_cont)
+setting_dialswitch_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_dialswitch_img_btn_1.set_size(120,35)
+setting_dialswitch_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_dialswitch_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+setting_dialswitch_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
setting_dialswitch_label = lv.label(setting_cont)
setting_dialswitch_label.set_text("表盘切换")
setting_dialswitch_label.set_pos(34, setting_cont_y+5)
setting_dialswitch_label.set_size(128-34, 35)
-setting_dialswitch_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_dialswitch_label.add_flag(lv.obj.FLAG.CLICKABLE)
# setting_dialswitch_label.set_text_align(lv.ALIGN.LEFT_MID, 30, setting_cont_y)
setting_dialswitch_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_dialswitch_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
setting_dialswitch_img = lv.img(setting_cont)
setting_dialswitch_img.set_pos(4, setting_cont_y)
setting_dialswitch_img.set_size(set_icon_x, set_icon_y)
-setting_dialswitch_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_dialswitch_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_dialswitch_img.set_src("U:/static/menu_watch_switch.png")
setting_dialswitch_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+
+
+
+setting_cont_y+=setting_cont_offset
+
+
# setting_themeswitch = lv.btn(setting_cont)
# setting_themeswitch_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
#setting_cont_y+=60
+setting_imei_img_btn_1 = lv.btn(setting_cont)
+setting_imei_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_imei_img_btn_1.set_size(120,35)
+setting_imei_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_imei_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_imei_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
setting_imei_label = lv.label(setting_cont)
setting_imei_label.set_text("设备IMEI号")
setting_imei_label.set_pos(34, setting_cont_y+5)
setting_imei_label.set_size(128-34, 35)
-setting_imei_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_imei_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_imei_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_imei_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
setting_imei_img = lv.img(setting_cont)
setting_imei_img.set_pos(4, setting_cont_y)
setting_imei_img.set_size(set_icon_x, set_icon_y)
-setting_imei_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_imei_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_imei_img.set_src("U:/static/menu_imei_qrcode.png")
setting_imei_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+setting_cont_y+=setting_cont_offset
+
+setting_app_img_btn_1 = lv.btn(setting_cont)
+setting_app_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_app_img_btn_1.set_size(120,35)
+setting_app_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_app_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_app_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+
setting_app_label = lv.label(setting_cont)
setting_app_label.set_text("手机APP")
setting_app_label.set_pos(34, setting_cont_y+5)
setting_app_label.set_size(128-34, 35)
-setting_app_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_app_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_app_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_app_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
setting_app_img = lv.img(setting_cont)
setting_app_img.set_pos(4, setting_cont_y)
setting_app_img.set_size(set_icon_x, set_icon_y)
-setting_app_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_app_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_app_img.set_src("U:/static/menu_app_qrcode.png")
setting_app_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+setting_cont_y+=setting_cont_offset
+
+setting_bright_img_btn_1 = lv.btn(setting_cont)
+setting_bright_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_bright_img_btn_1.set_size(120,35)
+setting_bright_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_bright_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_bright_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+
setting_bright_label = lv.label(setting_cont)
setting_bright_label.set_text("屏幕调节")
-setting_bright_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_bright_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_bright_label.set_size(128-34, 35)
setting_bright_label.set_pos(34, setting_cont_y+5)
setting_bright_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_bright_img = lv.img(setting_cont)
setting_bright_img.set_pos(4, setting_cont_y)
setting_bright_img.set_size(set_icon_x, set_icon_y)
-setting_bright_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_bright_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_bright_img.set_src("U:/static/menu_bright.png")
setting_bright_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+setting_cont_y+=setting_cont_offset
+
+setting_volume_img_btn_1 = lv.btn(setting_cont)
+setting_volume_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_volume_img_btn_1.set_size(120,35)
+setting_volume_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_volume_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_volume_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
setting_volume_label = lv.label(setting_cont)
setting_volume_label.set_text("铃声")
-setting_volume_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_volume_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_volume_label.set_size(128-34, 35)
setting_volume_label.set_pos(34, setting_cont_y+5)
setting_volume_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_volume_img = lv.img(setting_cont)
setting_volume_img.set_pos(4, setting_cont_y)
setting_volume_img.set_size(set_icon_x, set_icon_y)
-setting_volume_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_volume_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_volume_img.set_src("U:/static/menu_volume.png")
setting_volume_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+setting_cont_y+=setting_cont_offset
+
+setting_restore_img_btn_1 = lv.btn(setting_cont)
+setting_restore_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_restore_img_btn_1.set_size(120,35)
+setting_restore_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_restore_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_restore_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+
setting_restore_label = lv.label(setting_cont)
setting_restore_label.set_text("恢复出厂")
-setting_restore_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_restore_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_restore_label.set_size(128-34, 35)
setting_restore_label.set_pos(34, setting_cont_y+5)
setting_restore_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_restore_img = lv.img(setting_cont)
setting_restore_img.set_pos(4, setting_cont_y)
setting_restore_img.set_size(set_icon_x, set_icon_y)
-setting_restore_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_restore_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_restore_img.set_src("U:/static/menu_restore.png")
setting_restore_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+
+
+setting_cont_y+=setting_cont_offset
+
+setting_poweroff_img_btn_1 = lv.btn(setting_cont)
+setting_poweroff_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_poweroff_img_btn_1.set_size(120,35)
+setting_poweroff_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_poweroff_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_poweroff_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
setting_poweroff_label = lv.label(setting_cont)
setting_poweroff_label.set_text("关机")
-setting_poweroff_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_poweroff_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_poweroff_label.set_size(128-34, 35)
setting_poweroff_label.set_pos(34, setting_cont_y+5)
setting_poweroff_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_poweroff_img = lv.img(setting_cont)
setting_poweroff_img.set_pos(4, setting_cont_y)
setting_poweroff_img.set_size(set_icon_x, set_icon_y)
-setting_poweroff_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_poweroff_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_poweroff_img.set_src("U:/static/menu_poweroff.png")
setting_poweroff_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+setting_cont_y+=setting_cont_offset
+
+
+#重启setting_restart_img_btn_1
+setting_restart_img_btn_1 = lv.btn(setting_cont)
+setting_restart_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_restart_img_btn_1.set_size(120,35)
+setting_restart_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_restart_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_restart_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+
+
+setting_restart_label = lv.label(setting_cont)
+setting_restart_label.set_text("重启")
+# setting_poweroff_label.add_flag(lv.obj.FLAG.CLICKABLE)
+setting_restart_label.set_size(128-34, 35)
+setting_restart_label.set_pos(34, setting_cont_y+5)
+setting_restart_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
+setting_restart_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+setting_restart_img = lv.img(setting_cont)
+setting_restart_img.set_pos(4, setting_cont_y)
+setting_restart_img.set_size(set_icon_x, set_icon_y)
+# setting_poweroff_img.add_flag(lv.obj.FLAG.CLICKABLE)
+setting_restart_img.set_src("U:/static/menu_poweroff.png")
+setting_restart_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+
+setting_cont_y+=setting_cont_offset
+
+setting_version_img_btn_1 = lv.btn(setting_cont)
+setting_version_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_version_img_btn_1.set_size(120,34)
+setting_version_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_version_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_version_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+
setting_version_label = lv.label(setting_cont)
setting_version_label.set_text("关于设备")
-setting_version_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_version_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_version_label.set_size(128-34, 35)
setting_version_label.set_pos(34, setting_cont_y+5)
setting_version_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_version_img = lv.img(setting_cont)
setting_version_img.set_pos(4, setting_cont_y)
setting_version_img.set_size(set_icon_x, set_icon_y)
-setting_version_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_version_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_version_img.set_src("U:/static/menu_version.png")
setting_version_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
-setting_cont_y+=35
+setting_cont_y+=setting_cont_offset
+
+setting_update_img_btn_1 = lv.btn(setting_cont)
+setting_update_img_btn_1.set_pos(int(0),int(setting_cont_y-5))
+setting_update_img_btn_1.set_size(120,35)
+setting_update_img_btn_1.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
+setting_update_img_btn_1.add_style(style_screen_btn_1_main_main_default, lv.PART.MAIN|lv.STATE.DEFAULT)
+setting_update_img_btn_1.add_flag(lv.obj.FLAG.CLICKABLE)
+
setting_update_label = lv.label(setting_cont)
setting_update_label.set_text("系统升级")
-setting_update_label.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_update_label.add_flag(lv.obj.FLAG.CLICKABLE)
setting_update_label.set_size(128-34, 35)
setting_update_label.set_pos(34, setting_cont_y+5)
setting_update_label.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_update_label_btn = lv.label(setting_cont)
setting_update_label_btn.set_text(" ")
-setting_update_label_btn.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_update_label_btn.add_flag(lv.obj.FLAG.CLICKABLE)
setting_update_label_btn.set_size(128, 45)
setting_update_label_btn.set_pos(0, setting_cont_y)
setting_update_label_btn.set_style_text_color(lv.color_make(0xff, 0xff, 0xff), lv.STATE.DEFAULT)
setting_update_img = lv.img(setting_cont)
setting_update_img.set_pos(4, setting_cont_y)
setting_update_img.set_size(set_icon_x, set_icon_y)
-setting_update_img.add_flag(lv.obj.FLAG.CLICKABLE)
+# setting_update_img.add_flag(lv.obj.FLAG.CLICKABLE)
setting_update_img.set_src("U:/static/menu_upgrade.png")
setting_update_img.add_style(style_img, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+
class SettingScreen(Screen):
NAME = "setting"
def __init__(self):
super().__init__()
+ self.is_sliding = 0
+ self.is_left_sliding = 0
self.meta = setting_screen
# setting_language.add_event_cb(lambda e: self.load_screen(e, {"screen": "language"}), lv.EVENT.CLICKED, None)
- setting_dialswitch_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "dialswitch"})), lv.EVENT.CLICKED, None)
- # setting_themeswitch.add_event_cb(lambda e: self.load_screen(e, {"screen": "themeswitch"}), lv.EVENT.CLICKED, None)
- setting_imei_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "imei"})), lv.EVENT.CLICKED, None)
- setting_app_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "app"})), lv.EVENT.CLICKED, None)
- setting_bright_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "brightness"})), lv.EVENT.CLICKED, None)
- setting_volume_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "totalvolume"})), lv.EVENT.CLICKED, None)
- setting_restore_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "restore"})), lv.EVENT.CLICKED, None)
- setting_poweroff_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "poweroff"})), lv.EVENT.CLICKED, None)
- setting_update_label_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "update"})), lv.EVENT.CLICKED, None)
- setting_version_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "version"})), lv.EVENT.CLICKED, None)
+ # setting_dialswitch_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "dialswitch")), (lv.EVENT.CLICKED ), None)
+ # setting_imei_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "imei")), (lv.EVENT.CLICKED ), None)
+ # setting_app_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "app")), (lv.EVENT.CLICKED ), None)
+ # setting_bright_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "brightness")), (lv.EVENT.CLICKED ), None)
+ # setting_volume_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "totalvolume")), (lv.EVENT.CLICKED ), None)
+ # setting_restore_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "restore")), (lv.EVENT.CLICKED ), None)
+ # setting_poweroff_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "poweroff")), (lv.EVENT.CLICKED ), None)
+ # setting_update_label_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "update")), (lv.EVENT.CLICKED ), None)
+ # setting_version_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "version")), (lv.EVENT.CLICKED ), None)
+
+ # img regist btton
+ # setting_language.add_event_cb(lambda e: self.load_screen(e, {"screen": "language"}), (lv.EVENT.CLICKED ), None)
+ # setting_dialswitch_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "dialswitch")), (lv.EVENT.CLICKED ), None)
+
+ setting_imei_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "imei")), (lv.EVENT.CLICKED ), None)
+ setting_app_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "app")), (lv.EVENT.CLICKED ), None)
+ setting_bright_img_btn_1.add_event_cb(lambda e:EventMesh.callback_wrapper( self.ui_setting_cb(e, "brightness")), (lv.EVENT.CLICKED ), None)
+ setting_volume_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "totalvolume")), (lv.EVENT.CLICKED ), None)
+ setting_restore_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "restore")), (lv.EVENT.CLICKED ), None)
+ setting_poweroff_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "poweroff")), (lv.EVENT.CLICKED ), None)
+ setting_restart_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "restart")), lv.EVENT.CLICKED, None)
+ setting_update_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "update")), (lv.EVENT.CLICKED ), None)
+ setting_version_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "version")), (lv.EVENT.CLICKED ), None)
+ setting_dialswitch_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "dialswitch")), lv.EVENT.CLICKED, None)
+
+ # # setting_themeswitch.add_event_cb(lambda e: self.load_screen(e, {"screen": "themeswitch"}), lv.EVENT.CLICKED, None)
+ # setting_imei_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "imei")), lv.EVENT.PRESSING, None)
+ # setting_app_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "app")), lv.EVENT.PRESSING, None)
+ # setting_bright_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "brightness")), lv.EVENT.PRESSING, None)
+ # setting_volume_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "totalvolume")), lv.EVENT.PRESSING, None)
+ # setting_restore_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "restore")), lv.EVENT.PRESSING, None)
+ # setting_poweroff_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "poweroff")), lv.EVENT.PRESSING, None)
+ # setting_update_label_btn.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "update")), lv.EVENT.PRESSING, None)
+ # setting_version_label.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "version")), lv.EVENT.PRESSING, None)
# img regist btton
# setting_language.add_event_cb(lambda e: self.load_screen(e, {"screen": "language"}), lv.EVENT.CLICKED, None)
- setting_dialswitch_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "dialswitch"})), lv.EVENT.CLICKED, None)
+ setting_dialswitch_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "dialswitch")), lv.EVENT.PRESSING, None)
# setting_themeswitch.add_event_cb(lambda e: self.load_screen(e, {"screen": "themeswitch"}), lv.EVENT.CLICKED, None)
- setting_imei_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "imei"})), lv.EVENT.CLICKED, None)
- setting_app_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "app"})), lv.EVENT.CLICKED, None)
- setting_bright_img.add_event_cb(lambda e:EventMesh.callback_wrapper( self.load_screen(e, {"screen": "brightness"})), lv.EVENT.CLICKED, None)
- setting_volume_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "totalvolume"})), lv.EVENT.CLICKED, None)
- setting_restore_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "restore"})), lv.EVENT.CLICKED, None)
- setting_poweroff_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "poweroff"})), lv.EVENT.CLICKED, None)
- setting_update_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "update"})), lv.EVENT.CLICKED, None)
- setting_version_img.add_event_cb(lambda e: EventMesh.callback_wrapper(self.load_screen(e, {"screen": "version"})), lv.EVENT.CLICKED, None)
-
-
+ setting_imei_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "imei")), lv.EVENT.PRESSING, None)
+ setting_app_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "app")), lv.EVENT.PRESSING, None)
+ setting_bright_img_btn_1.add_event_cb(lambda e:EventMesh.callback_wrapper( self.ui_setting_cb(e, "brightness")), lv.EVENT.PRESSING, None)
+ setting_volume_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "totalvolume")), lv.EVENT.PRESSING, None)
+ setting_restore_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "restore")), lv.EVENT.PRESSING, None)
+ setting_poweroff_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "poweroff")), lv.EVENT.PRESSING, None)
+ setting_restart_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "restart")), lv.EVENT.PRESSING, None)
+ setting_update_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "update")), lv.EVENT.PRESSING, None)
+ setting_version_img_btn_1.add_event_cb(lambda e: EventMesh.callback_wrapper(self.ui_setting_cb(e, "version")), lv.EVENT.PRESSING, None)
+
+ def initialization(self):
+ self.is_left_sliding = 0
+ self.is_sliding = 0
+ pass
+ def ui_setting_cb(self, e, msg):
+ code = e.get_code()
+ EventMesh.publish("publish_message_event_ui",{"func":self.ui_setting_cb_do,"data":[code,msg]})
+ def ui_setting_cb_do(self, data):
+ #code = e.get_code()
+
+ code = data[0]
+ msg = data[1]
+
+ #print("code!!!!!!!!",code,msg)
+ if code == lv.EVENT.PRESSING:
+ #print("PRESSING")
+ self.is_sliding += 1
+
+ elif code == lv.EVENT.CLICKED:
+ #utime.sleep_ms(10)
+ print("1self.is_sliding",self.is_sliding)
+ if self.is_sliding <= 5 and self.is_sliding != 0:#如果是在滑动中则不需要点击事件
+ EventMesh.publish("load_screen", {"screen": "{}".format(msg)})
+ print("2self.is_sliding",self.is_sliding)
+
+ self.is_sliding =0
+
def done_return(self):
EventMesh.publish("load_screen", {"screen": "main_menu"})
def btn8_press(self):
EventMesh.publish("watch_top_show")
EventMesh.publish("load_screen", {"screen": "main_menu"})
+ def done_bottom_to_top(self):
+ #print("done_bottom_to_top")
+ self.is_sliding = 0
+ pass
+
+ def done_top_to_bottom(self):
+ #print("done_top_to_bottom")
+ self.is_sliding = 0
+ pass
+ def done_left_to_right(self):
+ #print("done_left_to_right")
+ self.is_sliding = 0
+ pass
+ def done_right_to_left(self):
+ #print("done_right_to_left")
+ self.is_sliding = 0
+ pass
##################################################################
# -------------------------------------------language screen----------------------------------------------------------
language_screen = lv.obj()
restore_label = lv.label(restore_screen)
restore_label.set_pos(0, 20)
-restore_label.set_size(128, 20)
-restore_label.set_text("恢复出厂设置?")
+restore_label.set_size(128, 40)
+restore_label.set_text("设备所有的数据将被清除,是否继续?")
restore_label.set_long_mode(lv.label.LONG.WRAP)
restore_label.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
restore_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
restore_confirm_label.set_text("确认")
restore_confirm_label.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
restore_confirm_label.set_size(64, 20)
-restore_confirm_label.set_pos(0,60)
+restore_confirm_label.set_pos(0,80)
restore_confirm_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
restore_confirm = lv.label(restore_screen)
restore_confirm.set_text(" ")
-restore_confirm.set_size(64, 40)
-restore_confirm.set_pos(0,60)
+restore_confirm.set_size(64, 48)
+restore_confirm.set_pos(0,80)
restore_confirm.add_flag(lv.obj.FLAG.CLICKABLE)
restore_cancel_label = lv.label(restore_screen)
restore_cancel_label.set_text("返回")
restore_cancel_label.set_size(64, 20)
restore_cancel_label.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-restore_cancel_label.set_pos(64,60)
+restore_cancel_label.set_pos(64,80)
restore_cancel_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
restore_cancel = lv.label(restore_screen)
restore_cancel.set_text(" ")
-restore_cancel.set_size(64, 40)
-restore_cancel.set_pos(64,60)
+restore_cancel.set_size(64, 48)
+restore_cancel.set_pos(64,80)
restore_cancel.add_flag(lv.obj.FLAG.CLICKABLE)
import versions
version_label1 = lv.label(version_screen)
-version_label1.set_pos(0, 5)
-version_label1.set_size(128, 40)
+version_label1.set_pos(10, 5)
+version_label1.set_size(118, 20)
version_label1.set_long_mode(lv.label.LONG.WRAP)
-version_label1.set_text("Software Version:")
-version_label1.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+# version_label1.set_text("Software Version:")
+version_label1.set_text("产品名称:")
+version_label1.set_style_text_align(lv.TEXT_ALIGN.LEFT, 10)
version_label1.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
-version_label2 = lv.label(version_screen)
-version_label2.set_pos(0, 45)
-version_label2.set_size(128, 20)
-version_label2.set_long_mode(lv.label.LONG.WRAP)
-version_label2.set_text("Python Lvgl")
-version_label2.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-version_label2.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+# version_label2 = lv.label(version_screen)
+# version_label2.set_pos(0, 45)
+# version_label2.set_size(128, 20)
+# version_label2.set_long_mode(lv.label.LONG.WRAP)
+# version_label2.set_text("Python Lvgl")
+# version_label2.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+# version_label2.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
-version_label3 = lv.label(version_screen)
-version_label3.set_pos(0, 65)
-version_label3.set_size(128, 20)
-version_label3.set_long_mode(lv.label.LONG.WRAP)
-version_label3.set_text("Version:")
-version_label3.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-version_label3.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+# version_label3 = lv.label(version_screen)
+# version_label3.set_pos(0, 65)
+# version_label3.set_size(128, 20)
+# version_label3.set_long_mode(lv.label.LONG.WRAP)
+# version_label3.set_text("Version:")
+# version_label3.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+# version_label3.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
version_label3 = lv.label(version_screen)
-version_label3.set_pos(0, 90)
-version_label3.set_size(128, 20)
+version_label3.set_pos(10, 25)
+version_label3.set_size(118, 40)
version_label3.set_long_mode(lv.label.LONG.WRAP)
version_label3.set_text(versions.Version)
-version_label3.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-version_label3.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+version_label3.set_style_text_align(lv.TEXT_ALIGN.LEFT, 10)
+version_label3.add_style(style_font_youyuan_20_gray, lv.PART.MAIN | lv.STATE.DEFAULT)
# version_label4 = lv.label(version_screen)
# version_label4.set_pos(0, version_label_y)
# version_label4.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
version_label5 = lv.label(version_screen)
-version_label5.set_pos(0, 115)
-version_label5.set_size(128, 20)
+version_label5.set_pos(10, 55)
+version_label5.set_size(118, 20)
version_label5.set_long_mode(lv.label.LONG.WRAP)
-version_label5.set_text("Build Time:")
-version_label5.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+version_label5.set_text("软件版本:")
+version_label5.set_style_text_align(lv.TEXT_ALIGN.LEFT, 10)
version_label5.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
version_label6 = lv.label(version_screen)
-version_label6.set_pos(0, 140)
-version_label6.set_size(128, 40)
+version_label6.set_pos(10, 75)
+version_label6.set_size(118, 40)
version_label6.set_long_mode(lv.label.LONG.WRAP)
version_label6.set_text(versions.Build_Time)
-version_label6.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-version_label6.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+version_label6.set_style_text_align(lv.TEXT_ALIGN.LEFT, 10)
+version_label6.add_style(style_font_youyuan_20_gray, lv.PART.MAIN | lv.STATE.DEFAULT)
# version_label7 = lv.label(version_screen)
# version_label7.set_pos(0, 210)
# version_label7.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
# version_label7.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
-version_label8 = lv.label(version_screen)
-version_label8.set_pos(0, 180)
-version_label8.set_size(128, 20)
-version_label8.set_long_mode(lv.label.LONG.WRAP)
-version_label8.set_text("IMEI:")
-version_label8.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-version_label8.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+# version_label8 = lv.label(version_screen)
+# version_label8.set_pos(0, 180)
+# version_label8.set_size(128, 20)
+# version_label8.set_long_mode(lv.label.LONG.WRAP)
+# version_label8.set_text("IMEI:")
+# version_label8.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+# version_label8.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
-version_label9 = lv.label(version_screen)
-version_label9.set_pos(0, 200)
-version_label9.set_size(128, 38)
-version_label9.set_text(" ")
-version_label9.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
-version_label9.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+# version_label9 = lv.label(version_screen)
+# version_label9.set_pos(0, 200)
+# version_label9.set_size(128, 38)
+# version_label9.set_text(" ")
+# version_label9.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+# version_label9.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
EventMesh.publish("load_screen", {"screen": "main_menu"})
+# -------------------------------------------restore screen----------------------------------------------------------
+restart_screen = lv.obj()
+print("restart_screen")
+restart_screen.add_style(style_screen, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+restart_confirm_label = lv.label(restart_screen)
+restart_confirm_label.set_text("确认")
+restart_confirm_label.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+restart_confirm_label.set_size(64, 20)
+restart_confirm_label.set_pos(0,60)
+restart_confirm_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+
+restart_confirm = lv.label(restart_screen)
+restart_confirm.set_text(" ")
+restart_confirm.set_size(64, 40)
+restart_confirm.set_pos(0,60)
+restart_confirm.add_flag(lv.obj.FLAG.CLICKABLE)
+
+restart_cancel_label = lv.label(restart_screen)
+restart_cancel_label.set_text("返回")
+restart_cancel_label.set_size(64, 20)
+restart_cancel_label.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
+restart_cancel_label.set_pos(64,60)
+restart_cancel_label.add_style(style_font_youyuan_20, lv.PART.MAIN | lv.STATE.DEFAULT)
+
+restart_cancel = lv.label(restart_screen)
+restart_cancel.set_text(" ")
+restart_cancel.set_size(64, 40)
+restart_cancel.set_pos(64,60)
+restart_cancel.add_flag(lv.obj.FLAG.CLICKABLE)
+
+class RestartScreen(Screen):
+ NAME = "restart"
+
+ def __init__(self):
+ super().__init__()
+ self.meta = restart_screen
+ restore_confirm.add_event_cb(lambda e: EventMesh.callback_wrapper(self.confirm(e)),lv.EVENT.CLICKED, None)
+ restart_cancel.add_event_cb(lambda e: EventMesh.callback_wrapper(self.concel(e)),lv.EVENT.CLICKED, None)
+
+
+ def confirm(self, e):
+ Power.powerRestart()
+
+ def concel(self, e):
+ EventMesh.publish("load_screen", {"screen": "setting"})
+
+ def done_return(self):
+ EventMesh.publish("load_screen", {"screen": "setting"})
+
+ def btn1_release(self):
+ EventMesh.publish("load_screen", {"screen": "setting"})
+
+ def btn8_press(self):
+ EventMesh.publish("watch_top_show")
+ EventMesh.publish("load_screen", {"screen": "main_menu"})
+
class UpdateScreen(Screen):
NAME = "update"
self.btn_count = 0
def initialization(self):
imei = EventMesh.publish(constants.EVENT.GET_IMEI)
- print("imei",imei)
- version_label9.set_text("{}".format(imei))
+ # print("imei",imei)
+ # version_label9.set_text("{}".format(imei))
def Close(self):
self.btn_count = 0
date_tmp = utime.localtime()
time_tmp = utime.mktime(date_tmp)
EventMesh.publish("set_storage_config",["old_time",time_tmp])#关机保存一个是时间
+
self.count = 0
self.aud.play(1, 1, 'U:/static/R_VOLUME_SET_1.mp3') #文件名前面要加上路径
self.timer.start(1*1000,1,self.power_off)
#define CONFIG_CAMERA 1
#define CONFIG_JPEG 1
#define CONFIG_CAMERA_SAVEPHOTOS 1
+//菊风视频通话
+#define CONFIG_juphoon 1
\ No newline at end of file
source "../components/poc/poc_option.in"
source "../components/GH301x/GH301x_option.in"
source "../components/SC7A20/SC7A20_option.in"
-
+source "../components/juphoon/juphoon_option.in"
endmenu
# CONFIG_POC is not set
#CONFIG_GH301x=y
CONFIG_SC7A20=y
+#¾Õ·çÊÓƵͨ»°
+CONFIG_juphoon=y
$(BUILD)/EventMesh.mpy \
$(BUILD)/initTP.mpy \
$(BUILD)/lcd.mpy \
- $(BUILD)/location.mpy \
$(BUILD)/mgr.mpy \
$(BUILD)/protocol.mpy \
$(BUILD)/ui.mpy \
EventMesh.publish(constants.EVENT.START_LOCATION_TEST) #测试模式
def timer_FactoryModeLocation_cb(self, *args, **kwargs):
- EventMesh.publish("system_sleep_rest")#防止黑屏
+ EventMesh.publish("system_sleep_rest")#防止黑屏
+ self.timer_c += 1
+ if self.timer_c >= 7:
+ get_location_flag = EventMesh.publish("get_location_flag")
+ self.timer_c = 0
+ if get_location_flag != None:
+ if(get_location_flag == 0):
+ EventMesh.publish(constants.EVENT.START_LOCATION_TEST) #测试模式
+ self.time_count = utime.mktime(utime.localtime())
def GET_LOCATION_DATA(self, event, msg):
- print("GPS:{}".format(msg[0]))
- print("WIFI:{}".format(msg[1]))
- print("CALL:{}".format(msg[2]))
+ # print("GPS:{}".format(msg[0]))
+ # print("WIFI:{}".format(msg[1]))
+ # print("CALL:{}".format(msg[2]))
EventMesh.publish("system_sleep_rest")#防止黑屏
_DATA = ""
time_tmp = utime.mktime(utime.localtime())
if len(msg[0]) > 1 : #GPS
GNSS_DATA = "GNSS:------\n"
-
+ gnss_data = msg[0][0]
+ if gnss_data :
+ GNSS_DATA = GNSS_DATA + "{},{},{}\n".format("A",gnss_data["latitude"],gnss_data["longitude"])
+
+ self.time_GNSS = time_tmp-self.time_count
+ EventMesh.txt_log("test location time:{}".format(self.time_GNSS))
+ self.time_count = utime.mktime(utime.localtime())
+ else:
+
+ GNSS_DATA = GNSS_DATA + "{},{},{}\n".format("V",0,0)
_DATA += "定位时间:{};{}秒\n".format(self.time_GNSS,time_tmp-self.time_count)
- rmc_data = msg[0][1].split("RMC")
- gsv_data = msg[0][1].split("GSV")
- if len(rmc_data) >= 2 :
- rmc_data = rmc_data[1:]
- rmc_tmp = rmc_data[0].split(",")
- if len(rmc_tmp) >= 2:
- GNSS_DATA = GNSS_DATA + "{},{},{}\n".format(rmc_tmp[2],rmc_tmp[3],rmc_tmp[5])
- if rmc_tmp[2] == 'A':
- if self.GNSS_status == 0:
- self.time_GNSS = time_tmp-self.time_count
- EventMesh.txt_log("test location time:{}".format(self.time_GNSS))
- self.GNSS_status = 1
- else:
- self.GNSS_status = 0
- self.time_GNSS = 0
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- GSV_dict= {}
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
+
+ GSV_dict = msg[0][1]
+ #print("GET_LOCATION_DATA:{}".format(GSV_dict))
+ if GSV_dict :
count = 0
try:
for j in range(200):
for key in GSV_dict :
- if(int(key) != j):
+ if(key != j):
continue
#print("GSV_dict[key]:len:{}".format(len(GSV_dict[key])))
- if len(GSV_dict[key]) >= 1 :
- GNSS_DATA+="{:<3}:[{:<3}]".format(key,GSV_dict[key])#:<3 宽度为3左对齐
+ if GSV_dict[key] >= 1 :
+ GNSS_DATA+=" {:<3}:[{:<3}] ".format(key,GSV_dict[key])#:<3 宽度为3左对齐
count+=1
if count % 2 == 0:
GNSS_DATA+="\n"
- if count > 30:
+ if count > 50:
break
except Exception as e:
usys.print_exception(e)
_DATA += "CALL:------\n{}".format(msg[2][0])
#FactoryModeLocation_CALL_label.set_text("CALL:{}".format(msg[2][0]))
print("GET_LOCATION_DATA:data:{}".format(_DATA))
- FactoryModeLocation_GNSS_label.set_text(_DATA)
+ FactoryModeLocation_GNSS_label.set_text(_DATA)
+ self.timer_c = 0
def Close(self):
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)
self.timer_FactoryModeLocation.stop()
import constants
import sms
from common import Lock, Abstract, LogAdapter
-from location import GPS, GPSMatch,CellLocator
+#from location import GPS, GPSMatch,CellLocator
from misc import USB, Power, ADC
from machine import ExtInt, Pin,Timer,RTC,UART
import EventMesh
from machine import I2C
from Gsensor import SC7A20
import pm
+import ure
try :
from Hsensor import GH3018
except Exception as e:
def __init__(self):
self.gps = None
- self.match = GPSMatch()
+ #self.match = GPSMatch()
self.timer_read_GPS_info = osTimer()
self.wifi_data = []
self.gps_data = {}
self.location_thread_id = 0
self.location_queue = Queue(100)
self.lpm_fd = None
- #quecgnss.init()
- #quecgnss.gnssEnable(0)
+ self.start_agps = 0
+ quecgnss.init()
+ quecgnss.gnssEnable(0)
@staticmethod
def get_date():
return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])
def post_processor_after_instantiation(self):
- _gps_cfg = {
- "UARTn": UART.UART1,
- "buadrate": 115200,
- "databits": 8,
- "parity": 0,
- "stopbits": 1,
- "flowctl": 0,
- "PowerPin": Pin.GPIO2,
- "StandbyPin": Pin.GPIO3,
- "BackupPin": None,
- "gps_mode": 0x01,
- }
- self.gps = GPS(**_gps_cfg)
- self.gps.power_switch(0)#关闭GPS
+ # _gps_cfg = {
+ # "UARTn": UART.UART1,
+ # "buadrate": 115200,
+ # "databits": 8,
+ # "parity": 0,
+ # "stopbits": 1,
+ # "flowctl": 0,
+ # "PowerPin": Pin.GPIO2,
+ # "StandbyPin": Pin.GPIO3,
+ # "BackupPin": None,
+ # "gps_mode": 0x01,
+ # }
+ # self.gps = GPS(**_gps_cfg)
+ # self.gps.power_switch(0)#关闭GPS
EventMesh.subscribe(constants.EVENT.GPSOPEN, self.gps_open)
EventMesh.subscribe(constants.EVENT.GPSCLOSE, self.gps_close)
EventMesh.subscribe(constants.EVENT.START_LOCATION, self.start_location)
return
self.location_thread_id = _thread.start_new_thread(self.location_thread, ())
self.location_flag = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
#self.gps_open(event, msg)
self.location_flag = 1
#self.gps_open(event, msg)
self.location_type = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
def close_location(self, event, msg):
self.location_flag = 0
self.location_type = 0
+ self.timer_read_GPS_info.stop()
def WIFI_scan_open(self, event, msg):
#print("WIFI_scan_open")
-
-
if wifiScan.getState() == False :
self.wifi_data = []
wifiScan.control(1)
def gps_open(self, event, msg):
#print("publish:gps_open")
#quecgnss.init()
- quecgnss.gnssEnable(1)
- self.gps.__gps_nmea_data_clean()
+ quecgnss.gnssEnable(2)
+ #self.gps.__gps_nmea_data_clean()
def gps_close(self, event, msg):
quecgnss.gnssEnable(0)
def location_timer(self, *args, **kwargs):
else :
break
-
+ def GxGGA_latitude(self, gga_data):
+ """Parse latitude from GGA"""
+ if gga_data:
+ latitude_re = ure.search(r",[0-9]+\.[0-9]+,[NS],", gga_data)
+ if latitude_re:
+ latitude = latitude_re.group(0)[1:-3]
+ return str(float(latitude[:2]) + float(latitude[2:]) / 60)
+ return ""
+ def GxGGA_longitude(self, gga_data):
+ """Parse longitude from GGA"""
+ if gga_data:
+ longitude_re = ure.search(r",[0-9]+\.[0-9]+,[EW],", gga_data)
+ if longitude_re:
+ longitude = longitude_re.group(0)[1:-3]
+ return str(float(longitude[:3]) + float(longitude[3:]) / 60)
+ return ""
+
+ def GxGGA_altitude(self, gga_data):
+ """Parse altitude from GGA"""
+ if gga_data:
+ altitude_re = ure.search(r",-*[0-9]+\.[0-9]+,M,", gga_data)
+ if altitude_re:
+ return altitude_re.group(0)[1:-3]
+ return ""
def location_thread(self):
self.wifi_data = []
self.cell_data = []
gnss_r_data = []
self.GSV_sig_ok_count = 0
+ self.GSV_sig_very_ok_count = 0
self.GGA_count = 0
self.RMC_A_count = 0
+ # if self.start_agps == 1: #开启agps
+ # self.start_agps = 0
+ # quecgnss.configSet(2,1)
if self.lpm_fd == None:
self.lpm_fd = pm.create_wakelock("test_lock", len("test_lock"))
pm.wakelock_lock(self.lpm_fd)
print("location_thread:1")
EventMesh.publish(constants.EVENT.GPSOPEN)
print("location_thread:2")
- self.timer_read_GPS_info.start(1000, 1, self.location_timer)
-
+ #self.timer_read_GPS_info.start(1000, 1, self.location_timer)
+ print("location_thread:3")
#utime.sleep_ms(1000)
self.location_timer_count = 0
#quecgnss.read(4096)#去掉第一次错误数据
#EventMesh.txt_log("START_LOCATION")
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
+ GSV_dict= {}
while self.location_flag == 1:
try :
# if self.location_check_data_timer_count >= 3:
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
- if self.location_check_data_timer_count >= 5 :#5秒查一次基站数据和wifi数据
+ if self.location_check_data_timer_count >= 1 :#3秒查一次基站数据和wifi数据
self.location_check_data_timer_count = 0
#print(self.location_timer_count)
- #GSV_dict= {}
+ GSV_dict= {}
#检查GNSS数据
if ( self.gps_data == {} or self.location_type == 1) and quecgnss.get_state() == 2:
-
- self.gps.__gps_nmea_data_clean()
- #gnss_r_data = [0,1]
- gnss_r_data = quecgnss.read(4096)
- #EventMesh.txt_log("gps Datalen:{}".format(gnss_r_data[0]))
- print("location gnss_r_data:len{}\n{}".format(gnss_r_data[0],gnss_r_data[1].decode()))
- #print("gnss_r_data len:{}".format(gnss_r_data[0]))
- if gnss_r_data[0] > 0 : #有数据
- tmp_ok_count = 0
- gsv_data = gnss_r_data[1].split("GSV")
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
-
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- #GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- try:
- #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
- if gsv_tmp[i+3] != "" :
- if int(gsv_tmp[i+3])>=20:
- tmp_ok_count +=1
- except Exception as e:
- usys.print_exception(e)
- #print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
-
- if(tmp_ok_count > self.GSV_sig_ok_count ):
- self.GSV_sig_ok_count = tmp_ok_count
-
- # if len(match_gga_data) > 8:
- # #print(match_gga_data)
- # if(match_gga_data[7] ):
- # gga_count_tmp = int(match_gga_data[7]) #可用卫星
- # if(gga_count_tmp > self.GGA_count):
- # self.GGA_count = gga_count_tmp
- print("GGA_count:{} GSV_sig_ok_coun:{} ".format(self.GGA_count,self.GSV_sig_ok_count))
+ pass
+ tmp_ok_count = 0
+ tmp_very_ok_count = 0
+ gsv_data = quecgnss.get_gsv()
+ rmc_data = quecgnss.get_rmc()
+ gga_data = quecgnss.get_gga()
+ vtg_data = quecgnss.get_vtg()
+ print("gsv:{}".format(quecgnss.get_gsv()))
+ print("gga:{}".format(quecgnss.get_gga()))
+ print("rmc:{}".format(quecgnss.get_rmc()))
+ print("vtg:{}".format(quecgnss.get_vtg()))
+ for i in range(len(gsv_data)) :
- match_rmc_data = self.match.GxRMC(gnss_r_data[1]).split(",")
-
- #print("match_rmc_data:\n{}".format(match_rmc_data))
- if len (match_rmc_data)>3: #有rmc数据
- if match_rmc_data[2] == 'A':
-
- if self.gps.__check_gps_valid(gnss_r_data[1].decode()): #数据齐全 :
-
- #print("hhhhhh:{}\n\n".format(self.gps.__gsv_data))
- match_vtg_data = self.gps.__vtg_data.split(",")#self.match.GxVTG(gnss_r_data[1]).split(",")
- match_gga_data = self.gps.__gga_data.split(",")#self.match.GxGGA(gnss_r_data[1]).split(",")
- #match_gga_data = self.match.GxGGA(gnss_r_data[1]).split(",")
-
- EventMesh.txt_log("GGA:{}".format(match_gga_data))
- # EventMesh.txt_log("VTG:{}".format(match_vtg_data))
- # EventMesh.txt_log("RMC:{}".format(match_rmc_data))
- # EventMesh.txt_log("timer:{} ok_count:{} count:{}\n".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
- print("LOCATION_ok :time:{}!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n".format(self.location_timer_count))
+ if i % 2 == 0:
+ if i+1 >= len(gsv_data) :
+ print("gsv_data num error!!")
+ break
+ GSV_dict[gsv_data[i]] = gsv_data[i+1]
+ #print("type:gsv_data{}".format(type(gsv_data[i+1])))
+ try:
+ #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
+ if gsv_data[i+1] :
+ if (gsv_data[i+1])>=20:
+ tmp_ok_count +=1
+ if (gsv_data[i+1])>=30:
+ tmp_very_ok_count +=1
+
+ except Exception as e:
+ usys.print_exception(e)
+
+ if(tmp_ok_count > self.GSV_sig_ok_count ):
+ self.GSV_sig_ok_count = tmp_ok_count
+ if(tmp_very_ok_count > self.GSV_sig_very_ok_count ):
+ self.GSV_sig_very_ok_count = tmp_very_ok_count
+ match_rmc_data = rmc_data.split(",")
+ if len (match_rmc_data)>3: #有rmc数据
+ if match_rmc_data[2] == 'A':
+ match_gga_data = gga_data.split(",")
+ if len(match_gga_data) >4: #数据全
+ match_vtg_data = vtg_data.split(",")
gps_date = "%s,%s"%(match_rmc_data[9],match_rmc_data[1][:6])#日期
- gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
+ #gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
latitude = "0,N" #纬度
- latitude_tmp = str(gps_data_tmp[1]).split(".")
+ latitude_tmp = str(self.GxGGA_latitude(gga_data)).split(".")
if len(latitude_tmp) >= 2 and len(latitude_tmp[1])>=5:
latitude = "%s.%s"%(latitude_tmp[0],latitude_tmp[1][:6])
latitude = "%s,%s"%(latitude,match_rmc_data[4] )
longitude = "0,E"#经度
- longitude_tmp = str(gps_data_tmp[0]).split(".")
+ longitude_tmp = str(self.GxGGA_longitude(gga_data)).split(".")
if len(longitude_tmp) >= 2 and len(longitude_tmp[1])>=5:
longitude = "%s.%s"%(longitude_tmp[0],longitude_tmp[1][:6])
longitude = "%s,%s"%(longitude,match_rmc_data[6] ) #match_rmc_data[6] + str(gnss_r_data[1])
high = "0"#高度
- high = str(gps_data_tmp[2])
+ high = str(self.GxGGA_altitude(gga_data))
number = "0"#可用卫星
precision = "5.8"#精度
if len(match_gga_data)>5 :
"date": gps_date,
"precision": precision
}
- else :
- EventMesh.txt_log("gps数据不全")
- else :
- EventMesh.txt_log("gps 无数据")
-
+# ***********************************************************************************
#检查wifi数据
if self.location_type == 1: #测试模式
self.location_timer_count = 0
- if len(gnss_r_data) >= 1:
- if gnss_r_data[0] > 0:
- EventMesh.publish("PUSH_LOCATION_DATA", [gnss_r_data,self.wifi_data,self.cell_data])
+
+ EventMesh.publish("PUSH_LOCATION_DATA", [[self.gps_data,GSV_dict],self.wifi_data,self.cell_data])
if self.gps_data != {} : #发送数据
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
self.location_queue.put(constants.PROTOCOL.UD_SEND)
elif self.location_type == 0: #正常模式
if self.gps_data != {} or self.location_timer_count > 100: #or( self.wifi_data != [] and self.cell_data != []):
if self.location_queue.empty() == False:#有定位队列
- EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
- upload_time = EventMesh.publish("get_upload_data")
-
-
+ EventMesh.txt_log("LOCATION timer:{} ok:{} very_ok:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GSV_sig_very_ok_count))
+ #EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
+ if self.gps_data == {}: #定位超时，且信噪比多个大于30，下次启动agps
+ if self.GSV_sig_very_ok_count > 3:#3个超30以上
+ self.start_agps = 1
+ EventMesh.txt_log("open agps:{}".format(GSV_dict))
+ #upload_time = EventMesh.publish("get_upload_data")
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#if upload_time > 200 :
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
if self.GSV_sig_ok_count <= 1 and self.wifi_data != [] and self.cell_data != [] and self.location_timer_count > 20: #超过40秒且信号大于30的不足3个
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
- EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} count:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
+ EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#break
# if self.location_type != 1 and self.location_timer_count >= 60*4 : #4分钟关闭
#self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
utime.sleep_ms(500)
- self.timer_read_GPS_info.stop()
- self.gps.power_switch(0)
+
+ #self.timer_read_GPS_info.stop()
+ #self.gps.power_switch(0)
wifiScan.control(0)
+ EventMesh.publish(constants.EVENT.GPSCLOSE)
# if EventMesh.publish("get_lcd_state" ) == 0:#休眠的时候，恢复休眠
# pm.autosleep(1)
# pm.sclkEx_set(1, 1, 5)
$(BUILD)/EventMesh.mpy \
$(BUILD)/initTP.mpy \
$(BUILD)/lcd.mpy \
- $(BUILD)/location.mpy \
$(BUILD)/mgr.mpy \
$(BUILD)/protocol.mpy \
$(BUILD)/ui.mpy \
import constants
import sms
from common import Lock, Abstract, LogAdapter
-from location import GPS, GPSMatch,CellLocator
+#from location import GPS, GPSMatch,CellLocator
from misc import USB, Power, ADC
from machine import ExtInt, Pin,Timer,RTC,UART
import EventMesh
from machine import I2C
from Gsensor import SC7A20
import pm
+import ure
try :
from Hsensor import GH3018
except Exception as e:
def __init__(self):
self.gps = None
- self.match = GPSMatch()
+ #self.match = GPSMatch()
self.timer_read_GPS_info = osTimer()
self.wifi_data = []
self.gps_data = {}
self.location_thread_id = 0
self.location_queue = Queue(100)
self.lpm_fd = None
- #quecgnss.init()
- #quecgnss.gnssEnable(0)
+ self.start_agps = 0
+ quecgnss.init()
+ quecgnss.gnssEnable(0)
@staticmethod
def get_date():
return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])
def post_processor_after_instantiation(self):
- _gps_cfg = {
- "UARTn": UART.UART1,
- "buadrate": 115200,
- "databits": 8,
- "parity": 0,
- "stopbits": 1,
- "flowctl": 0,
- "PowerPin": Pin.GPIO2,
- "StandbyPin": Pin.GPIO3,
- "BackupPin": None,
- "gps_mode": 0x01,
- }
- self.gps = GPS(**_gps_cfg)
- self.gps.power_switch(0)#关闭GPS
+ # _gps_cfg = {
+ # "UARTn": UART.UART1,
+ # "buadrate": 115200,
+ # "databits": 8,
+ # "parity": 0,
+ # "stopbits": 1,
+ # "flowctl": 0,
+ # "PowerPin": Pin.GPIO2,
+ # "StandbyPin": Pin.GPIO3,
+ # "BackupPin": None,
+ # "gps_mode": 0x01,
+ # }
+ # self.gps = GPS(**_gps_cfg)
+ # self.gps.power_switch(0)#关闭GPS
EventMesh.subscribe(constants.EVENT.GPSOPEN, self.gps_open)
EventMesh.subscribe(constants.EVENT.GPSCLOSE, self.gps_close)
EventMesh.subscribe(constants.EVENT.START_LOCATION, self.start_location)
return
self.location_thread_id = _thread.start_new_thread(self.location_thread, ())
self.location_flag = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
#self.gps_open(event, msg)
self.location_flag = 1
#self.gps_open(event, msg)
self.location_type = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
def close_location(self, event, msg):
self.location_flag = 0
self.location_type = 0
+ self.timer_read_GPS_info.stop()
def gps_open(self, event, msg):
#print("publish:gps_open")
#quecgnss.init()
- quecgnss.gnssEnable(1)
- self.gps.__gps_nmea_data_clean()
+ quecgnss.gnssEnable(2)
+ #self.gps.__gps_nmea_data_clean()
def gps_close(self, event, msg):
quecgnss.gnssEnable(0)
def location_timer(self, *args, **kwargs):
else :
break
-
+ def GxGGA_latitude(self, gga_data):
+ """Parse latitude from GGA"""
+ if gga_data:
+ latitude_re = ure.search(r",[0-9]+\.[0-9]+,[NS],", gga_data)
+ if latitude_re:
+ latitude = latitude_re.group(0)[1:-3]
+ return str(float(latitude[:2]) + float(latitude[2:]) / 60)
+ return ""
+ def GxGGA_longitude(self, gga_data):
+ """Parse longitude from GGA"""
+ if gga_data:
+ longitude_re = ure.search(r",[0-9]+\.[0-9]+,[EW],", gga_data)
+ if longitude_re:
+ longitude = longitude_re.group(0)[1:-3]
+ return str(float(longitude[:3]) + float(longitude[3:]) / 60)
+ return ""
+
+ def GxGGA_altitude(self, gga_data):
+ """Parse altitude from GGA"""
+ if gga_data:
+ altitude_re = ure.search(r",-*[0-9]+\.[0-9]+,M,", gga_data)
+ if altitude_re:
+ return altitude_re.group(0)[1:-3]
+ return ""
def location_thread(self):
self.wifi_data = []
self.cell_data = []
gnss_r_data = []
self.GSV_sig_ok_count = 0
+ self.GSV_sig_very_ok_count = 0
self.GGA_count = 0
self.RMC_A_count = 0
+ # if self.start_agps == 1: #开启agps
+ # self.start_agps = 0
+ # quecgnss.configSet(2,1)
if self.lpm_fd == None:
self.lpm_fd = pm.create_wakelock("test_lock", len("test_lock"))
pm.wakelock_lock(self.lpm_fd)
print("location_thread:1")
EventMesh.publish(constants.EVENT.GPSOPEN)
print("location_thread:2")
- self.timer_read_GPS_info.start(1000, 1, self.location_timer)
-
+ #self.timer_read_GPS_info.start(1000, 1, self.location_timer)
+ print("location_thread:3")
#utime.sleep_ms(1000)
self.location_timer_count = 0
#quecgnss.read(4096)#去掉第一次错误数据
#EventMesh.txt_log("START_LOCATION")
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
+ GSV_dict= {}
while self.location_flag == 1:
try :
# if self.location_check_data_timer_count >= 3:
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
- if self.location_check_data_timer_count >= 5 :#5秒查一次基站数据和wifi数据
+ if self.location_check_data_timer_count >= 1 :#3秒查一次基站数据和wifi数据
self.location_check_data_timer_count = 0
#print(self.location_timer_count)
- #GSV_dict= {}
+ GSV_dict= {}
#检查GNSS数据
if ( self.gps_data == {} or self.location_type == 1) and quecgnss.get_state() == 2:
-
- self.gps.__gps_nmea_data_clean()
- #gnss_r_data = [0,1]
- gnss_r_data = quecgnss.read(4096)
- #EventMesh.txt_log("gps Datalen:{}".format(gnss_r_data[0]))
- # print("location gnss_r_data:len{}\n{}".format(gnss_r_data[0],gnss_r_data[1].decode()))
- #print("gnss_r_data len:{}".format(gnss_r_data[0]))
- if gnss_r_data[0] > 0 : #有数据
- tmp_ok_count = 0
- gsv_data = gnss_r_data[1].split("GSV")
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
-
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- #GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- try:
- #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
- if gsv_tmp[i+3] != "" :
- if int(gsv_tmp[i+3])>=20:
- tmp_ok_count +=1
- except Exception as e:
- usys.print_exception(e)
- #print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
-
- if(tmp_ok_count > self.GSV_sig_ok_count ):
- self.GSV_sig_ok_count = tmp_ok_count
-
- # if len(match_gga_data) > 8:
- # #print(match_gga_data)
- # if(match_gga_data[7] ):
- # gga_count_tmp = int(match_gga_data[7]) #可用卫星
- # if(gga_count_tmp > self.GGA_count):
- # self.GGA_count = gga_count_tmp
- print("GGA_count:{} GSV_sig_ok_coun:{} ".format(self.GGA_count,self.GSV_sig_ok_count))
+ pass
+ tmp_ok_count = 0
+ tmp_very_ok_count = 0
+ gsv_data = quecgnss.get_gsv()
+ rmc_data = quecgnss.get_rmc()
+ gga_data = quecgnss.get_gga()
+ vtg_data = quecgnss.get_vtg()
+ print("gsv:{}".format(quecgnss.get_gsv()))
+ print("gga:{}".format(quecgnss.get_gga()))
+ print("rmc:{}".format(quecgnss.get_rmc()))
+ print("vtg:{}".format(quecgnss.get_vtg()))
+ for i in range(len(gsv_data)) :
- match_rmc_data = self.match.GxRMC(gnss_r_data[1]).split(",")
-
- #print("match_rmc_data:\n{}".format(match_rmc_data))
- if len (match_rmc_data)>3: #有rmc数据
- if match_rmc_data[2] == 'A':
-
- if self.gps.__check_gps_valid(gnss_r_data[1].decode()): #数据齐全 :
-
- #print("hhhhhh:{}\n\n".format(self.gps.__gsv_data))
- match_vtg_data = self.gps.__vtg_data.split(",")#self.match.GxVTG(gnss_r_data[1]).split(",")
- match_gga_data = self.gps.__gga_data.split(",")#self.match.GxGGA(gnss_r_data[1]).split(",")
- #match_gga_data = self.match.GxGGA(gnss_r_data[1]).split(",")
-
- EventMesh.txt_log("GGA:{}".format(match_gga_data))
- # EventMesh.txt_log("VTG:{}".format(match_vtg_data))
- # EventMesh.txt_log("RMC:{}".format(match_rmc_data))
- # EventMesh.txt_log("timer:{} ok_count:{} count:{}\n".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
- print("LOCATION_ok :time:{}!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n".format(self.location_timer_count))
+ if i % 2 == 0:
+ if i+1 >= len(gsv_data) :
+ print("gsv_data num error!!")
+ break
+ GSV_dict[gsv_data[i]] = gsv_data[i+1]
+ #print("type:gsv_data{}".format(type(gsv_data[i+1])))
+ try:
+ #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
+ if gsv_data[i+1] :
+ if (gsv_data[i+1])>=20:
+ tmp_ok_count +=1
+ if (gsv_data[i+1])>=30:
+ tmp_very_ok_count +=1
+
+ except Exception as e:
+ usys.print_exception(e)
+
+ if(tmp_ok_count > self.GSV_sig_ok_count ):
+ self.GSV_sig_ok_count = tmp_ok_count
+ if(tmp_very_ok_count > self.GSV_sig_very_ok_count ):
+ self.GSV_sig_very_ok_count = tmp_very_ok_count
+ match_rmc_data = rmc_data.split(",")
+ if len (match_rmc_data)>3: #有rmc数据
+ if match_rmc_data[2] == 'A':
+ match_gga_data = gga_data.split(",")
+ if len(match_gga_data) >4: #数据全
+ match_vtg_data = vtg_data.split(",")
gps_date = "%s,%s"%(match_rmc_data[9],match_rmc_data[1][:6])#日期
- gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
+ #gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
latitude = "0,N" #纬度
- latitude_tmp = str(gps_data_tmp[1]).split(".")
+ latitude_tmp = str(self.GxGGA_latitude(gga_data)).split(".")
if len(latitude_tmp) >= 2 and len(latitude_tmp[1])>=5:
latitude = "%s.%s"%(latitude_tmp[0],latitude_tmp[1][:6])
latitude = "%s,%s"%(latitude,match_rmc_data[4] )
longitude = "0,E"#经度
- longitude_tmp = str(gps_data_tmp[0]).split(".")
+ longitude_tmp = str(self.GxGGA_longitude(gga_data)).split(".")
if len(longitude_tmp) >= 2 and len(longitude_tmp[1])>=5:
longitude = "%s.%s"%(longitude_tmp[0],longitude_tmp[1][:6])
longitude = "%s,%s"%(longitude,match_rmc_data[6] ) #match_rmc_data[6] + str(gnss_r_data[1])
high = "0"#高度
- high = str(gps_data_tmp[2])
+ high = str(self.GxGGA_altitude(gga_data))
number = "0"#可用卫星
precision = "5.8"#精度
if len(match_gga_data)>5 :
"date": gps_date,
"precision": precision
}
- else :
- EventMesh.txt_log("gps数据不全")
- else :
- EventMesh.txt_log("gps 无数据")
-
+# ***********************************************************************************
#检查wifi数据
if self.location_type == 1: #测试模式
self.location_timer_count = 0
- if len(gnss_r_data) >= 1:
- if gnss_r_data[0] > 0:
- EventMesh.publish("PUSH_LOCATION_DATA", [gnss_r_data,self.wifi_data,self.cell_data])
+
+ EventMesh.publish("PUSH_LOCATION_DATA", [[self.gps_data,GSV_dict],self.wifi_data,self.cell_data])
if self.gps_data != {} : #发送数据
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
self.location_queue.put(constants.PROTOCOL.UD_SEND)
elif self.location_type == 0: #正常模式
if self.gps_data != {} or self.location_timer_count > 100: #or( self.wifi_data != [] and self.cell_data != []):
if self.location_queue.empty() == False:#有定位队列
- EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
- upload_time = EventMesh.publish("get_upload_data")
-
-
+ EventMesh.txt_log("LOCATION timer:{} ok:{} very_ok:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GSV_sig_very_ok_count))
+ #EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
+ if self.gps_data == {}: #定位超时，且信噪比多个大于30，下次启动agps
+ if self.GSV_sig_very_ok_count > 3:#3个超30以上
+ self.start_agps = 1
+ EventMesh.txt_log("open agps:{}".format(GSV_dict))
+ #upload_time = EventMesh.publish("get_upload_data")
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#if upload_time > 200 :
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
if self.GSV_sig_ok_count <= 1 and self.wifi_data != [] and self.cell_data != [] and self.location_timer_count > 20: #超过40秒且信号大于30的不足3个
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
- EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} count:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
+ EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#break
# if self.location_type != 1 and self.location_timer_count >= 60*4 : #4分钟关闭
#self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
utime.sleep_ms(500)
- self.timer_read_GPS_info.stop()
- self.gps.power_switch(0)
+
+ #self.timer_read_GPS_info.stop()
+ #self.gps.power_switch(0)
wifiScan.control(0)
+ EventMesh.publish(constants.EVENT.GPSCLOSE)
# if EventMesh.publish("get_lcd_state" ) == 0:#休眠的时候，恢复休眠
# pm.autosleep(1)
# pm.sclkEx_set(1, 1, 5)
source/modGsensor_SC7A20.c \
source/modHsensor.c \
source/modHsensor_GH3018.c \
+ source/modVideoCall.c \
+ source/modVideoCall_juphoon.c \
source/modrsa.c \
source/utils_crc32.c \
source/http_parser.c \
$(BUILD)/EventMesh.mpy \
$(BUILD)/initTP.mpy \
$(BUILD)/lcd.mpy \
- $(BUILD)/location.mpy \
$(BUILD)/mgr.mpy \
$(BUILD)/protocol.mpy \
$(BUILD)/ui.mpy \
self.time_count = 0
self.time_GNSS = 0
self.GNSS_status = 0
-
+ self.timer_c = 0
def initialization(self):
FactoryModeLocation_GNSS_label.set_text("GNSS:\n")
# FactoryModeLocation_WIFI_label.set_text("WIFI:")
EventMesh.publish(constants.EVENT.START_LOCATION_TEST) #测试模式
def timer_FactoryModeLocation_cb(self, *args, **kwargs):
- EventMesh.publish("system_sleep_rest")#防止黑屏
+ EventMesh.publish("system_sleep_rest")#防止黑屏
+ self.timer_c += 1
+ if self.timer_c >= 7:
+ get_location_flag = EventMesh.publish("get_location_flag")
+ self.timer_c = 0
+ if get_location_flag != None:
+ if(get_location_flag == 0):
+ EventMesh.publish(constants.EVENT.START_LOCATION_TEST) #测试模式
+ self.time_count = utime.mktime(utime.localtime())
def GET_LOCATION_DATA(self, event, msg):
- print("GPS:{}".format(msg[0]))
- print("WIFI:{}".format(msg[1]))
- print("CALL:{}".format(msg[2]))
+ # print("GPS:{}".format(msg[0]))
+ # print("WIFI:{}".format(msg[1]))
+ # print("CALL:{}".format(msg[2]))
EventMesh.publish("system_sleep_rest")#防止黑屏
_DATA = ""
time_tmp = utime.mktime(utime.localtime())
if len(msg[0]) > 1 : #GPS
GNSS_DATA = "GNSS:------\n"
-
+ gnss_data = msg[0][0]
+ if gnss_data :
+ GNSS_DATA = GNSS_DATA + "{},{},{}\n".format("A",gnss_data["latitude"],gnss_data["longitude"])
+
+ self.time_GNSS = time_tmp-self.time_count
+ EventMesh.txt_log("test location time:{}".format(self.time_GNSS))
+ self.time_count = utime.mktime(utime.localtime())
+ else:
+
+ GNSS_DATA = GNSS_DATA + "{},{},{}\n".format("V",0,0)
_DATA += "定位时间:{};{}秒\n".format(self.time_GNSS,time_tmp-self.time_count)
- rmc_data = msg[0][1].split("RMC")
- gsv_data = msg[0][1].split("GSV")
- if len(rmc_data) >= 2 :
- rmc_data = rmc_data[1:]
- rmc_tmp = rmc_data[0].split(",")
- if len(rmc_tmp) >= 2:
- GNSS_DATA = GNSS_DATA + "{},{},{}\n".format(rmc_tmp[2],rmc_tmp[3],rmc_tmp[5])
- if rmc_tmp[2] == 'A':
- if self.GNSS_status == 0:
- self.time_GNSS = time_tmp-self.time_count
- EventMesh.txt_log("test location time:{}".format(self.time_GNSS))
- self.GNSS_status = 1
- else:
- self.GNSS_status = 0
- self.time_GNSS = 0
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- GSV_dict= {}
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
+
+ GSV_dict = msg[0][1]
+ #print("GET_LOCATION_DATA:{}".format(GSV_dict))
+ if GSV_dict :
count = 0
try:
for j in range(200):
for key in GSV_dict :
- if(int(key) != j):
+ if(key != j):
continue
#print("GSV_dict[key]:len:{}".format(len(GSV_dict[key])))
- if len(GSV_dict[key]) >= 1 :
- GNSS_DATA+="{:<3}:[{:<3}]".format(key,GSV_dict[key])#:<3 宽度为3左对齐
+ if GSV_dict[key] >= 1 :
+ GNSS_DATA+=" {:<3}:[{:<3}] ".format(key,GSV_dict[key])#:<3 宽度为3左对齐
count+=1
if count % 2 == 0:
GNSS_DATA+="\n"
- if count > 30:
+ if count > 50:
break
except Exception as e:
usys.print_exception(e)
_DATA += "CALL:------\n{}".format(msg[2][0])
#FactoryModeLocation_CALL_label.set_text("CALL:{}".format(msg[2][0]))
print("GET_LOCATION_DATA:data:{}".format(_DATA))
- FactoryModeLocation_GNSS_label.set_text(_DATA)
+ FactoryModeLocation_GNSS_label.set_text(_DATA)
+ self.timer_c = 0
def Close(self):
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)
self.timer_FactoryModeLocation.stop()
from machine import I2C
from Gsensor import SC7A20
import pm
+import ure
try :
from Hsensor import GH3018
except Exception as e:
self.location_thread_id = 0
self.location_queue = Queue(100)
self.lpm_fd = None
- #quecgnss.init()
- #quecgnss.gnssEnable(0)
+ self.start_agps = 0
+ quecgnss.init()
+ quecgnss.gnssEnable(0)
@staticmethod
def get_date():
return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])
def post_processor_after_instantiation(self):
- _gps_cfg = {
- "UARTn": UART.UART1,
- "buadrate": 115200,
- "databits": 8,
- "parity": 0,
- "stopbits": 1,
- "flowctl": 0,
- "PowerPin": Pin.GPIO2,
- "StandbyPin": Pin.GPIO3,
- "BackupPin": None,
- "gps_mode": 0x01,
- }
- self.gps = GPS(**_gps_cfg)
- self.gps.power_switch(0)#关闭GPS
+ # _gps_cfg = {
+ # "UARTn": UART.UART1,
+ # "buadrate": 115200,
+ # "databits": 8,
+ # "parity": 0,
+ # "stopbits": 1,
+ # "flowctl": 0,
+ # "PowerPin": Pin.GPIO2,
+ # "StandbyPin": Pin.GPIO3,
+ # "BackupPin": None,
+ # "gps_mode": 0x01,
+ # }
+ # self.gps = GPS(**_gps_cfg)
+ # self.gps.power_switch(0)#关闭GPS
EventMesh.subscribe(constants.EVENT.GPSOPEN, self.gps_open)
EventMesh.subscribe(constants.EVENT.GPSCLOSE, self.gps_close)
EventMesh.subscribe(constants.EVENT.START_LOCATION, self.start_location)
return
self.location_thread_id = _thread.start_new_thread(self.location_thread, ())
self.location_flag = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
#self.gps_open(event, msg)
self.location_flag = 1
#self.gps_open(event, msg)
self.location_type = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
def close_location(self, event, msg):
self.location_flag = 0
self.location_type = 0
+ self.timer_read_GPS_info.stop()
def gps_open(self, event, msg):
#print("publish:gps_open")
#quecgnss.init()
- quecgnss.gnssEnable(1)
- self.gps.__gps_nmea_data_clean()
+ quecgnss.gnssEnable(2)
+ #self.gps.__gps_nmea_data_clean()
def gps_close(self, event, msg):
quecgnss.gnssEnable(0)
def location_timer(self, *args, **kwargs):
else :
break
-
+ def GxGGA_latitude(self, gga_data):
+ """Parse latitude from GGA"""
+ if gga_data:
+ latitude_re = ure.search(r",[0-9]+\.[0-9]+,[NS],", gga_data)
+ if latitude_re:
+ latitude = latitude_re.group(0)[1:-3]
+ return str(float(latitude[:2]) + float(latitude[2:]) / 60)
+ return ""
+ def GxGGA_longitude(self, gga_data):
+ """Parse longitude from GGA"""
+ if gga_data:
+ longitude_re = ure.search(r",[0-9]+\.[0-9]+,[EW],", gga_data)
+ if longitude_re:
+ longitude = longitude_re.group(0)[1:-3]
+ return str(float(longitude[:3]) + float(longitude[3:]) / 60)
+ return ""
+
+ def GxGGA_altitude(self, gga_data):
+ """Parse altitude from GGA"""
+ if gga_data:
+ altitude_re = ure.search(r",-*[0-9]+\.[0-9]+,M,", gga_data)
+ if altitude_re:
+ return altitude_re.group(0)[1:-3]
+ return ""
def location_thread(self):
self.wifi_data = []
self.cell_data = []
gnss_r_data = []
self.GSV_sig_ok_count = 0
+ self.GSV_sig_very_ok_count = 0
self.GGA_count = 0
self.RMC_A_count = 0
+ # if self.start_agps == 1: #开启agps
+ # self.start_agps = 0
+ # quecgnss.configSet(2,1)
if self.lpm_fd == None:
self.lpm_fd = pm.create_wakelock("test_lock", len("test_lock"))
pm.wakelock_lock(self.lpm_fd)
print("location_thread:1")
EventMesh.publish(constants.EVENT.GPSOPEN)
print("location_thread:2")
- self.timer_read_GPS_info.start(1000, 1, self.location_timer)
-
+ #self.timer_read_GPS_info.start(1000, 1, self.location_timer)
+ print("location_thread:3")
#utime.sleep_ms(1000)
self.location_timer_count = 0
#quecgnss.read(4096)#去掉第一次错误数据
#EventMesh.txt_log("START_LOCATION")
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
+ GSV_dict= {}
while self.location_flag == 1:
try :
# if self.location_check_data_timer_count >= 3:
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
- if self.location_check_data_timer_count >= 5 :#5秒查一次基站数据和wifi数据
+ if self.location_check_data_timer_count >= 1 :#3秒查一次基站数据和wifi数据
self.location_check_data_timer_count = 0
#print(self.location_timer_count)
- #GSV_dict= {}
+ GSV_dict= {}
#检查GNSS数据
if ( self.gps_data == {} or self.location_type == 1) and quecgnss.get_state() == 2:
-
- self.gps.__gps_nmea_data_clean()
- #gnss_r_data = [0,1]
- gnss_r_data = quecgnss.read(4096)
- #EventMesh.txt_log("gps Datalen:{}".format(gnss_r_data[0]))
- #print("location gnss_r_data:len{}\n{}".format(gnss_r_data[0],gnss_r_data[1].decode()))
- #print("gnss_r_data len:{}".format(gnss_r_data[0]))
- if gnss_r_data[0] > 0 : #有数据
- tmp_ok_count = 0
- gsv_data = gnss_r_data[1].split("GSV")
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
-
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- #GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- try:
- #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
- if gsv_tmp[i+3] != "" :
- if int(gsv_tmp[i+3])>=20:
- tmp_ok_count +=1
- except Exception as e:
- usys.print_exception(e)
- #print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
-
- if(tmp_ok_count > self.GSV_sig_ok_count ):
- self.GSV_sig_ok_count = tmp_ok_count
-
- # if len(match_gga_data) > 8:
- # #print(match_gga_data)
- # if(match_gga_data[7] ):
- # gga_count_tmp = int(match_gga_data[7]) #可用卫星
- # if(gga_count_tmp > self.GGA_count):
- # self.GGA_count = gga_count_tmp
- print("GGA_count:{} GSV_sig_ok_coun:{} ".format(self.GGA_count,self.GSV_sig_ok_count))
+ pass
+ tmp_ok_count = 0
+ tmp_very_ok_count = 0
+ gsv_data = quecgnss.get_gsv()
+ rmc_data = quecgnss.get_rmc()
+ gga_data = quecgnss.get_gga()
+ vtg_data = quecgnss.get_vtg()
+ print("gsv:{}".format(quecgnss.get_gsv()))
+ print("gga:{}".format(quecgnss.get_gga()))
+ print("rmc:{}".format(quecgnss.get_rmc()))
+ print("vtg:{}".format(quecgnss.get_vtg()))
+ for i in range(len(gsv_data)) :
- match_rmc_data = self.match.GxRMC(gnss_r_data[1]).split(",")
-
- #print("match_rmc_data:\n{}".format(match_rmc_data))
- if len (match_rmc_data)>3: #有rmc数据
- if match_rmc_data[2] == 'A':
-
- if self.gps.__check_gps_valid(gnss_r_data[1].decode()): #数据齐全 :
-
- #print("hhhhhh:{}\n\n".format(self.gps.__gsv_data))
- match_vtg_data = self.gps.__vtg_data.split(",")#self.match.GxVTG(gnss_r_data[1]).split(",")
- match_gga_data = self.gps.__gga_data.split(",")#self.match.GxGGA(gnss_r_data[1]).split(",")
- #match_gga_data = self.match.GxGGA(gnss_r_data[1]).split(",")
-
- EventMesh.txt_log("GGA:{}".format(match_gga_data))
- # EventMesh.txt_log("VTG:{}".format(match_vtg_data))
- # EventMesh.txt_log("RMC:{}".format(match_rmc_data))
- # EventMesh.txt_log("timer:{} ok_count:{} count:{}\n".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
- print("LOCATION_ok :time:{}!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n".format(self.location_timer_count))
+ if i % 2 == 0:
+ if i+1 >= len(gsv_data) :
+ print("gsv_data num error!!")
+ break
+ GSV_dict[gsv_data[i]] = gsv_data[i+1]
+ #print("type:gsv_data{}".format(type(gsv_data[i+1])))
+ try:
+ #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
+ if gsv_data[i+1] :
+ if (gsv_data[i+1])>=20:
+ tmp_ok_count +=1
+ if (gsv_data[i+1])>=30:
+ tmp_very_ok_count +=1
+
+ except Exception as e:
+ usys.print_exception(e)
+
+ if(tmp_ok_count > self.GSV_sig_ok_count ):
+ self.GSV_sig_ok_count = tmp_ok_count
+ if(tmp_very_ok_count > self.GSV_sig_very_ok_count ):
+ self.GSV_sig_very_ok_count = tmp_very_ok_count
+ match_rmc_data = rmc_data.split(",")
+ if len (match_rmc_data)>3: #有rmc数据
+ if match_rmc_data[2] == 'A':
+ match_gga_data = gga_data.split(",")
+ if len(match_gga_data) >4: #数据全
+ match_vtg_data = vtg_data.split(",")
gps_date = "%s,%s"%(match_rmc_data[9],match_rmc_data[1][:6])#日期
- gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
+ #gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
latitude = "0,N" #纬度
- latitude_tmp = str(gps_data_tmp[1]).split(".")
+ latitude_tmp = str(self.GxGGA_latitude(gga_data)).split(".")
if len(latitude_tmp) >= 2 and len(latitude_tmp[1])>=5:
latitude = "%s.%s"%(latitude_tmp[0],latitude_tmp[1][:6])
latitude = "%s,%s"%(latitude,match_rmc_data[4] )
longitude = "0,E"#经度
- longitude_tmp = str(gps_data_tmp[0]).split(".")
+ longitude_tmp = str(self.GxGGA_longitude(gga_data)).split(".")
if len(longitude_tmp) >= 2 and len(longitude_tmp[1])>=5:
longitude = "%s.%s"%(longitude_tmp[0],longitude_tmp[1][:6])
longitude = "%s,%s"%(longitude,match_rmc_data[6] ) #match_rmc_data[6] + str(gnss_r_data[1])
high = "0"#高度
- high = str(gps_data_tmp[2])
+ high = str(self.GxGGA_altitude(gga_data))
number = "0"#可用卫星
precision = "5.8"#精度
if len(match_gga_data)>5 :
"date": gps_date,
"precision": precision
}
- else :
- EventMesh.txt_log("gps数据不全")
- else :
- EventMesh.txt_log("gps 无数据")
-
+# ***********************************************************************************
#检查wifi数据
if self.location_type == 1: #测试模式
self.location_timer_count = 0
- if len(gnss_r_data) >= 1:
- if gnss_r_data[0] > 0:
- EventMesh.publish("PUSH_LOCATION_DATA", [gnss_r_data,self.wifi_data,self.cell_data])
+
+ EventMesh.publish("PUSH_LOCATION_DATA", [[self.gps_data,GSV_dict],self.wifi_data,self.cell_data])
if self.gps_data != {} : #发送数据
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
self.location_queue.put(constants.PROTOCOL.UD_SEND)
elif self.location_type == 0: #正常模式
if self.gps_data != {} or self.location_timer_count > 100: #or( self.wifi_data != [] and self.cell_data != []):
if self.location_queue.empty() == False:#有定位队列
- EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
- upload_time = EventMesh.publish("get_upload_data")
-
-
+ EventMesh.txt_log("LOCATION timer:{} ok:{} very_ok:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GSV_sig_very_ok_count))
+ #EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
+ if self.gps_data == {}: #定位超时，且信噪比多个大于30，下次启动agps
+ if self.GSV_sig_very_ok_count > 3:#3个超30以上
+ self.start_agps = 1
+ EventMesh.txt_log("open agps:{}".format(GSV_dict))
+ #upload_time = EventMesh.publish("get_upload_data")
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#if upload_time > 200 :
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
if self.GSV_sig_ok_count <= 1 and self.wifi_data != [] and self.cell_data != [] and self.location_timer_count > 20: #超过40秒且信号大于30的不足3个
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
- EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} count:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
+ EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#break
# if self.location_type != 1 and self.location_timer_count >= 60*4 : #4分钟关闭
#self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
utime.sleep_ms(500)
- self.timer_read_GPS_info.stop()
- self.gps.power_switch(0)
+
+ #self.timer_read_GPS_info.stop()
+ #self.gps.power_switch(0)
wifiScan.control(0)
+ EventMesh.publish(constants.EVENT.GPSCLOSE)
# if EventMesh.publish("get_lcd_state" ) == 0:#休眠的时候，恢复休眠
# pm.autosleep(1)
# pm.sclkEx_set(1, 1, 5)
#define CONFIG_JPEG 1
#define CONFIG_CAMERA_SAVEPHOTOS 1
//菊风视频通话
-//#define CONFIG_juphoon 1
\ No newline at end of file
+#define CONFIG_juphoon 1
\ No newline at end of file
#CONFIG_GH301x=y
CONFIG_SC7A20=y
#菊风视频通话
-#CONFIG_juphoon=y
+CONFIG_juphoon=y
$(BUILD)/EventMesh.mpy \
$(BUILD)/initTP.mpy \
$(BUILD)/lcd.mpy \
- $(BUILD)/location.mpy \
$(BUILD)/mgr.mpy \
$(BUILD)/protocol.mpy \
$(BUILD)/ui.mpy \
import constants
import sms
from common import Lock, Abstract, LogAdapter
-from location import GPS, GPSMatch,CellLocator
+#from location import GPS, GPSMatch,CellLocator
from misc import USB, Power, ADC
from machine import ExtInt, Pin,Timer,RTC,UART
import EventMesh
"""定时测量心率，血氧，体温"""
WEAR = EventMesh.publish(constants.EVENT.GET_WEAR)#佩戴数据
+ if WEAR == None :
+ WEAR = 0
self.get_hr_state = EventMesh.publish("get_hr_state")
+ if self.get_hr_state == None :
+ self.get_hr_state = 0
self.get_spo2_state = EventMesh.publish("get_spo2_state")
+ if self.get_spo2_state == None :
+ self.get_spo2_state = 0
get_temp_time = EventMesh.publish("get_temp_time")
get_temp_state = EventMesh.publish("get_temp_state")
+ if get_temp_state == None :
+ get_temp_state = 0
hr_time = {}
hr_time = EventMesh.publish("get_time_hr_spo2")#获取时间是否大于0
if get_temp_state != None : #突然脱腕
def __init__(self):
self.gps = None
- self.match = GPSMatch()
+ #self.match = GPSMatch()
self.timer_read_GPS_info = osTimer()
self.wifi_data = []
self.gps_data = {}
if check_hr == True :
with open("/ext/static/storage_file/history_hr.json","r") as fd:#音频文件编号
self.read_histroy_hr_data = ujson.load(fd)
-
+ if self.read_histroy_hr_data == None:
+ self.read_histroy_hr_data = []
check_temp= ql_fs.path_exists("/ext/static/storage_file/history_temp.json")
if check_temp == True :
with open("/ext/static/storage_file/history_temp.json","r") as fd:#音频文件编号
self.read_histroy_temp_data = ujson.load(fd)
-
+ if self.read_histroy_temp_data == None:
+ self.read_histroy_temp_data = []
check_spo2= ql_fs.path_exists("/ext/static/storage_file/history_spo2.json")
if check_spo2 == True :
with open("/ext/static/storage_file/history_spo2.json","r") as fd:#音频文件编号
self.read_histroy_spo2_data = ujson.load(fd)
+ if self.read_histroy_spo2_data == None:
+ self.read_histroy_spo2_data = []
self.temp_value = 0
# self.read_histroy_hr_data=[{"timeSec":16789890,"value":90},{"timeSec":16789888,"value":78},{"timeSec":16789688,"value":68},{"timeSec":16789898,"value":58},\
#print(self.read_histroy_temp_data)
def get_history_hr_value(self, event, msg): #近7次心率历史数据统计显示
- return self.read_histroy_hr_data
+ if self.read_histroy_hr_data:
+ return self.read_histroy_hr_data
+ else :
+ return []
def set_history_hr_value(self, event, msg):
pass
self.set_hr = msg
def get_hr_state(self, event, msg):
- return self.set_hr
+ if self.set_hr:
+ return self.set_hr
+ else:
+ return 0
def set_spo2_state(self, event, msg):
self.set_spo2 = msg
def get_spo2_state(self, event, msg):
- return self.set_spo2
+ if self.set_spo2:
+ return self.set_spo2
+ else:
+ return 0
#体温
class getTempTimeManager(Abstract):
EventMesh.publish("set_storage_config",["set_temp_time",self.set_time])
def get_temp_time(self, event, msg):
- return self.set_time
+ if self.set_time:
+ return self.set_time
+ else :
+ return 0
def set_temp_state(self, event, msg):
self.get_temp = msg
- def get_temp_state(self, event, msg):
- return self.get_temp
+ def get_temp_state(self, event, msg):
+ if self.get_temp:
+ return self.get_temp
+ else :
+ return 0
class getBrightnessManager(Abstract):#获取亮度级别
def __init__(self):
def add_filter(flt):
event_store.add_filter(flt)
+import utime
+import uos
+Txt_Log = 0
+def txt_log(data):
+ if Txt_Log != 0 :
+ print(data)
+ try:
+ f_stat = uos.stat("usr/log.txt")
+ if f_stat[6] >50*1024:
+ uos.remove("usr/log.txt")
+ except Exception as e:
+ usys.print_exception(e)
+ with open("/ext/log.txt","a",encoding="utf-8") as fd:
+ d_time = utime.localtime()
+ data_tmp = "%02d-%02d %02d:%02d:%02d :"%(d_time[1],d_time[2],d_time[3],d_time[4],d_time[5])
+ fd.write(data_tmp+data+"\n")
def callback_wrapper(callback):#按键回调
def wrapped_callback(*args, **kwargs):
return wrapped_callback
-import utime
-Txt_Log = 1
-def txt_log(data):
- pass
- # if Txt_Log != 0 :
- # with open("/usr/log.txt","a",encoding="utf-8") as fd:
- # d_time = utime.localtime()
- # data_tmp = "%02d-%02d %02d:%02d:%02d :"%(d_time[1],d_time[2],d_time[3],d_time[4],d_time[5])
- # fd.write(data_tmp+data+"\n")
$(BUILD)/EventMesh.mpy \
$(BUILD)/initTP.mpy \
$(BUILD)/lcd.mpy \
- $(BUILD)/location.mpy \
$(BUILD)/mgr.mpy \
$(BUILD)/protocol.mpy \
$(BUILD)/ui.mpy \
import constants
import sms
from common import Lock, Abstract, LogAdapter
-from location import GPS, GPSMatch,CellLocator
+#from location import GPS, GPSMatch,CellLocator
from misc import USB, Power, ADC
from machine import ExtInt, Pin,Timer,RTC,UART
import EventMesh
from machine import I2C
from Gsensor import SC7A20
import pm
+import ure
try :
from Hsensor import GH3018
except Exception as e:
def __init__(self):
self.gps = None
- self.match = GPSMatch()
+ #self.match = GPSMatch()
self.timer_read_GPS_info = osTimer()
self.wifi_data = []
self.gps_data = {}
self.location_thread_id = 0
self.location_queue = Queue(100)
self.lpm_fd = None
- #quecgnss.init()
- #quecgnss.gnssEnable(0)
+ self.start_agps = 0
+ quecgnss.init()
+ quecgnss.gnssEnable(0)
@staticmethod
def get_date():
return "{:04d}-{:02d}-{:02d}".format(*utime.localtime()[0:3])
return "{:02d}:{:02d}:{:02d}".format(*utime.localtime()[3:6])
def post_processor_after_instantiation(self):
- _gps_cfg = {
- "UARTn": UART.UART1,
- "buadrate": 115200,
- "databits": 8,
- "parity": 0,
- "stopbits": 1,
- "flowctl": 0,
- "PowerPin": Pin.GPIO2,
- "StandbyPin": Pin.GPIO3,
- "BackupPin": None,
- "gps_mode": 0x01,
- }
- self.gps = GPS(**_gps_cfg)
- self.gps.power_switch(0)#关闭GPS
+ # _gps_cfg = {
+ # "UARTn": UART.UART1,
+ # "buadrate": 115200,
+ # "databits": 8,
+ # "parity": 0,
+ # "stopbits": 1,
+ # "flowctl": 0,
+ # "PowerPin": Pin.GPIO2,
+ # "StandbyPin": Pin.GPIO3,
+ # "BackupPin": None,
+ # "gps_mode": 0x01,
+ # }
+ # self.gps = GPS(**_gps_cfg)
+ # self.gps.power_switch(0)#关闭GPS
EventMesh.subscribe(constants.EVENT.GPSOPEN, self.gps_open)
EventMesh.subscribe(constants.EVENT.GPSCLOSE, self.gps_close)
EventMesh.subscribe(constants.EVENT.START_LOCATION, self.start_location)
return
self.location_thread_id = _thread.start_new_thread(self.location_thread, ())
self.location_flag = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
#self.gps_open(event, msg)
self.location_flag = 1
#self.gps_open(event, msg)
self.location_type = 1
+ self.timer_read_GPS_info.start(1000, 1, self.location_timer)
def close_location(self, event, msg):
self.location_flag = 0
self.location_type = 0
+ self.timer_read_GPS_info.stop()
def gps_open(self, event, msg):
#print("publish:gps_open")
#quecgnss.init()
- quecgnss.gnssEnable(1)
- self.gps.__gps_nmea_data_clean()
+ quecgnss.gnssEnable(2)
+ #self.gps.__gps_nmea_data_clean()
def gps_close(self, event, msg):
quecgnss.gnssEnable(0)
def location_timer(self, *args, **kwargs):
else :
break
-
+ def GxGGA_latitude(self, gga_data):
+ """Parse latitude from GGA"""
+ if gga_data:
+ latitude_re = ure.search(r",[0-9]+\.[0-9]+,[NS],", gga_data)
+ if latitude_re:
+ latitude = latitude_re.group(0)[1:-3]
+ return str(float(latitude[:2]) + float(latitude[2:]) / 60)
+ return ""
+ def GxGGA_longitude(self, gga_data):
+ """Parse longitude from GGA"""
+ if gga_data:
+ longitude_re = ure.search(r",[0-9]+\.[0-9]+,[EW],", gga_data)
+ if longitude_re:
+ longitude = longitude_re.group(0)[1:-3]
+ return str(float(longitude[:3]) + float(longitude[3:]) / 60)
+ return ""
+
+ def GxGGA_altitude(self, gga_data):
+ """Parse altitude from GGA"""
+ if gga_data:
+ altitude_re = ure.search(r",-*[0-9]+\.[0-9]+,M,", gga_data)
+ if altitude_re:
+ return altitude_re.group(0)[1:-3]
+ return ""
def location_thread(self):
self.wifi_data = []
self.cell_data = []
gnss_r_data = []
self.GSV_sig_ok_count = 0
+ self.GSV_sig_very_ok_count = 0
self.GGA_count = 0
self.RMC_A_count = 0
+ # if self.start_agps == 1: #开启agps
+ # self.start_agps = 0
+ # quecgnss.configSet(2,1)
if self.lpm_fd == None:
self.lpm_fd = pm.create_wakelock("test_lock", len("test_lock"))
pm.wakelock_lock(self.lpm_fd)
print("location_thread:1")
EventMesh.publish(constants.EVENT.GPSOPEN)
print("location_thread:2")
- self.timer_read_GPS_info.start(1000, 1, self.location_timer)
-
+ #self.timer_read_GPS_info.start(1000, 1, self.location_timer)
+ print("location_thread:3")
#utime.sleep_ms(1000)
self.location_timer_count = 0
#quecgnss.read(4096)#去掉第一次错误数据
#EventMesh.txt_log("START_LOCATION")
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
+ GSV_dict= {}
while self.location_flag == 1:
try :
# if self.location_check_data_timer_count >= 3:
# pm.autosleep(0)#唤醒
# pm.sclkEx_set(0, 1, 5)
- if self.location_check_data_timer_count >= 5 :#5秒查一次基站数据和wifi数据
+ if self.location_check_data_timer_count >= 1 :#3秒查一次基站数据和wifi数据
self.location_check_data_timer_count = 0
#print(self.location_timer_count)
- #GSV_dict= {}
+ GSV_dict= {}
#检查GNSS数据
if ( self.gps_data == {} or self.location_type == 1) and quecgnss.get_state() == 2:
-
- self.gps.__gps_nmea_data_clean()
- #gnss_r_data = [0,1]
- gnss_r_data = quecgnss.read(4096)
- #EventMesh.txt_log("gps Datalen:{}".format(gnss_r_data[0]))
- # print("location gnss_r_data:len{}\n{}".format(gnss_r_data[0],gnss_r_data[1].decode()))
- #print("gnss_r_data len:{}".format(gnss_r_data[0]))
- if gnss_r_data[0] > 0 : #有数据
- tmp_ok_count = 0
- gsv_data = gnss_r_data[1].split("GSV")
-
- if len(gsv_data) >= 2 :
- gsv_data = gsv_data[1:]
- for i in range(len(gsv_data)) :
- gsv_data[i] = gsv_data[i].split("\r\n")[0]
- gsv_tmp = gsv_data[i].split(",")
- if len(gsv_tmp) < 7 :
- break
-
- gsv_tmp = gsv_tmp[4:]
- #print("gsv_tmp:{}".format(gsv_tmp))
- for i in range(len(gsv_tmp)) :
- if i % 4 == 0:
- #GSV_dict[gsv_tmp[i]] = gsv_tmp[i+3]
- try:
- #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
- if gsv_tmp[i+3] != "" :
- if int(gsv_tmp[i+3])>=20:
- tmp_ok_count +=1
- except Exception as e:
- usys.print_exception(e)
- #print("GSV_dict:{}:[{}]".format(gsv_tmp[i],gsv_tmp[i+3]))
- if len(gsv_tmp)-i < 4:
- break
-
- if(tmp_ok_count > self.GSV_sig_ok_count ):
- self.GSV_sig_ok_count = tmp_ok_count
-
- # if len(match_gga_data) > 8:
- # #print(match_gga_data)
- # if(match_gga_data[7] ):
- # gga_count_tmp = int(match_gga_data[7]) #可用卫星
- # if(gga_count_tmp > self.GGA_count):
- # self.GGA_count = gga_count_tmp
- print("GGA_count:{} GSV_sig_ok_coun:{} ".format(self.GGA_count,self.GSV_sig_ok_count))
+ pass
+ tmp_ok_count = 0
+ tmp_very_ok_count = 0
+ gsv_data = quecgnss.get_gsv()
+ rmc_data = quecgnss.get_rmc()
+ gga_data = quecgnss.get_gga()
+ vtg_data = quecgnss.get_vtg()
+ print("gsv:{}".format(quecgnss.get_gsv()))
+ print("gga:{}".format(quecgnss.get_gga()))
+ print("rmc:{}".format(quecgnss.get_rmc()))
+ print("vtg:{}".format(quecgnss.get_vtg()))
+ for i in range(len(gsv_data)) :
- match_rmc_data = self.match.GxRMC(gnss_r_data[1]).split(",")
-
- #print("match_rmc_data:\n{}".format(match_rmc_data))
- if len (match_rmc_data)>3: #有rmc数据
- if match_rmc_data[2] == 'A':
-
- if self.gps.__check_gps_valid(gnss_r_data[1].decode()): #数据齐全 :
-
- #print("hhhhhh:{}\n\n".format(self.gps.__gsv_data))
- match_vtg_data = self.gps.__vtg_data.split(",")#self.match.GxVTG(gnss_r_data[1]).split(",")
- match_gga_data = self.gps.__gga_data.split(",")#self.match.GxGGA(gnss_r_data[1]).split(",")
- #match_gga_data = self.match.GxGGA(gnss_r_data[1]).split(",")
-
- EventMesh.txt_log("GGA:{}".format(match_gga_data))
- # EventMesh.txt_log("VTG:{}".format(match_vtg_data))
- # EventMesh.txt_log("RMC:{}".format(match_rmc_data))
- # EventMesh.txt_log("timer:{} ok_count:{} count:{}\n".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
- print("LOCATION_ok :time:{}!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n".format(self.location_timer_count))
+ if i % 2 == 0:
+ if i+1 >= len(gsv_data) :
+ print("gsv_data num error!!")
+ break
+ GSV_dict[gsv_data[i]] = gsv_data[i+1]
+ #print("type:gsv_data{}".format(type(gsv_data[i+1])))
+ try:
+ #print("gsv_tmp[i+3]:{}".format(gsv_tmp[i+3]))
+ if gsv_data[i+1] :
+ if (gsv_data[i+1])>=20:
+ tmp_ok_count +=1
+ if (gsv_data[i+1])>=30:
+ tmp_very_ok_count +=1
+
+ except Exception as e:
+ usys.print_exception(e)
+
+ if(tmp_ok_count > self.GSV_sig_ok_count ):
+ self.GSV_sig_ok_count = tmp_ok_count
+ if(tmp_very_ok_count > self.GSV_sig_very_ok_count ):
+ self.GSV_sig_very_ok_count = tmp_very_ok_count
+ match_rmc_data = rmc_data.split(",")
+ if len (match_rmc_data)>3: #有rmc数据
+ if match_rmc_data[2] == 'A':
+ match_gga_data = gga_data.split(",")
+ if len(match_gga_data) >4: #数据全
+ match_vtg_data = vtg_data.split(",")
gps_date = "%s,%s"%(match_rmc_data[9],match_rmc_data[1][:6])#日期
- gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
+ #gps_data_tmp = self.gps.read_coordinates(gnss_r_data[1])
latitude = "0,N" #纬度
- latitude_tmp = str(gps_data_tmp[1]).split(".")
+ latitude_tmp = str(self.GxGGA_latitude(gga_data)).split(".")
if len(latitude_tmp) >= 2 and len(latitude_tmp[1])>=5:
latitude = "%s.%s"%(latitude_tmp[0],latitude_tmp[1][:6])
latitude = "%s,%s"%(latitude,match_rmc_data[4] )
longitude = "0,E"#经度
- longitude_tmp = str(gps_data_tmp[0]).split(".")
+ longitude_tmp = str(self.GxGGA_longitude(gga_data)).split(".")
if len(longitude_tmp) >= 2 and len(longitude_tmp[1])>=5:
longitude = "%s.%s"%(longitude_tmp[0],longitude_tmp[1][:6])
longitude = "%s,%s"%(longitude,match_rmc_data[6] ) #match_rmc_data[6] + str(gnss_r_data[1])
high = "0"#高度
- high = str(gps_data_tmp[2])
+ high = str(self.GxGGA_altitude(gga_data))
number = "0"#可用卫星
precision = "5.8"#精度
if len(match_gga_data)>5 :
"date": gps_date,
"precision": precision
}
- else :
- EventMesh.txt_log("gps数据不全")
- else :
- EventMesh.txt_log("gps 无数据")
-
+# ***********************************************************************************
#检查wifi数据
if self.location_type == 1: #测试模式
self.location_timer_count = 0
- if len(gnss_r_data) >= 1:
- if gnss_r_data[0] > 0:
- EventMesh.publish("PUSH_LOCATION_DATA", [gnss_r_data,self.wifi_data,self.cell_data])
+
+ EventMesh.publish("PUSH_LOCATION_DATA", [[self.gps_data,GSV_dict],self.wifi_data,self.cell_data])
if self.gps_data != {} : #发送数据
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
self.location_queue.put(constants.PROTOCOL.UD_SEND)
elif self.location_type == 0: #正常模式
if self.gps_data != {} or self.location_timer_count > 100: #or( self.wifi_data != [] and self.cell_data != []):
if self.location_queue.empty() == False:#有定位队列
- EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
- upload_time = EventMesh.publish("get_upload_data")
-
-
+ EventMesh.txt_log("LOCATION timer:{} ok:{} very_ok:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GSV_sig_very_ok_count))
+ #EventMesh.txt_log("LOCATION:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
+ if self.gps_data == {}: #定位超时，且信噪比多个大于30，下次启动agps
+ if self.GSV_sig_very_ok_count > 3:#3个超30以上
+ self.start_agps = 1
+ EventMesh.txt_log("open agps:{}".format(GSV_dict))
+ #upload_time = EventMesh.publish("get_upload_data")
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#if upload_time > 200 :
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
if self.GSV_sig_ok_count <= 1 and self.wifi_data != [] and self.cell_data != [] and self.location_timer_count > 20: #超过40秒且信号大于30的不足3个
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
- EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} count:{}".format(self.location_timer_count,self.GSV_sig_ok_count,self.GGA_count))
+ EventMesh.txt_log("GSV_sig_ok_count<3:timer:{} ok_count:{} ".format(self.location_timer_count,self.GSV_sig_ok_count))
self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
#break
# if self.location_type != 1 and self.location_timer_count >= 60*4 : #4分钟关闭
#self.Location_send([self.gps_data,self.wifi_data,self.cell_data])
EventMesh.publish(constants.EVENT.CLOSE_LOCATION)#关闭定位
utime.sleep_ms(500)
- self.timer_read_GPS_info.stop()
- self.gps.power_switch(0)
+
+ #self.timer_read_GPS_info.stop()
+ #self.gps.power_switch(0)
wifiScan.control(0)
+ EventMesh.publish(constants.EVENT.GPSCLOSE)
# if EventMesh.publish("get_lcd_state" ) == 0:#休眠的时候，恢复休眠
# pm.autosleep(1)
# pm.sclkEx_set(1, 1, 5)
projects / mirrors / ASR1603_G5.git / commitdiff