static void _cbDialog(WM_MESSAGE * pMsg)
{
WM_HWIN hItem;
int NCode;
int Id;
char * buffer = rt_malloc(64);
static GRAPH_DATA_Handle _ahData[4];
rt_uint8_t major, minor;
rt_uint32_t total, used, max_used;
switch (pMsg->MsgId)
{
case WM_TIMER:
cpu_usage_get(&major, &minor);
rt_memory_info(&total, &used, &max_used);
sprintf(buffer, "CPU :%d.%2d%%", major, minor);
TEXT_SetText(WM_GetDialogItem(pMsg->hWin, ID_TEXT_0), buffer);
PROGBAR_SetValue(WM_GetDialogItem(pMsg->hWin, ID_PROGBAR_0), major);
sprintf(buffer, "Used mem:%d%%", used*100/total);
TEXT_SetText(WM_GetDialogItem(pMsg->hWin, ID_TEXT_1), buffer);
PROGBAR_SetValue(WM_GetDialogItem(pMsg->hWin, ID_PROGBAR_1), used*100/total);
GRAPH_DATA_YT_AddValue(_ahData[0], major);
GRAPH_DATA_YT_AddValue(_ahData[1], used*100/total);
rt_device_t dev;
enet_phy_data phy_data;
dev = rt_device_find("e0");
if(dev)
{
dev->control(dev, NIOCTL_GET_PHY_DATA, &phy_data);
GRAPH_DATA_YT_AddValue(_ahData[2], phy_data.tx_fcnt);
GRAPH_DATA_YT_AddValue(_ahData[3], phy_data.rx_fcnt);
}
WM_RestartTimer(pMsg->Data.v, 20);
break;
case WM_INIT_DIALOG:
WM_CreateTimer(WM_GetClientWindow(pMsg->hWin), 0, 300, 0);
hItem = WM_GetDialogItem(pMsg->hWin, ID_PROGBAR_0);
PROGBAR_SetBarColor(hItem, 1, GUI_GREEN);
PROGBAR_SetBarColor(hItem, 0, GUI_RED);
hItem = WM_GetDialogItem(pMsg->hWin, ID_PROGBAR_1);
PROGBAR_SetBarColor(hItem, 1, GUI_GREEN);
PROGBAR_SetBarColor(hItem, 0, GUI_RED);
// GRAPH
_ahData[0] = GRAPH_DATA_YT_Create(GUI_DARKGREEN, 500, 0, 0);
_ahData[1] = GRAPH_DATA_YT_Create(GUI_BLUE, 500, 0, 0);
_ahData[2] = GRAPH_DATA_YT_Create(GUI_YELLOW, 500, 0, 0);
_ahData[3] = GRAPH_DATA_YT_Create(GUI_BROWN, 500, 0, 0);
WM_HWIN hGRAPH[4];
int i;
hGRAPH[0] = WM_GetDialogItem(pMsg->hWin, ID_GRAPH_0);
hGRAPH[1] = WM_GetDialogItem(pMsg->hWin, ID_GRAPH_1);
hGRAPH[2] = WM_GetDialogItem(pMsg->hWin, ID_GRAPH_2);
hGRAPH[3] = WM_GetDialogItem(pMsg->hWin, ID_GRAPH_3);
for(i=0;i<GUI_COUNTOF(hGRAPH);i++)
{
GRAPH_SetBorder(hGRAPH[i], 1, 1, 1, 1);
GRAPH_SetGridVis(hGRAPH[i], 1);
GRAPH_SetGridDistX(hGRAPH[i], 10);
GRAPH_SetGridDistY(hGRAPH[i], 10);
GRAPH_AttachData(hGRAPH[i], _ahData[i]);
}
break;
default:
WM_DefaultProc(pMsg);
break;
}
rt_free(buffer);
}
/*
* Device Information View
* Device: Win32 or Cortex-M3 etc
* Memory:
* Thread:
* IP Address:
* Gateway:
* DNS:
*/
static rt_bool_t view_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
switch (event->type)
{
case RTGUI_EVENT_PAINT:
{
struct rtgui_dc* dc;
struct rtgui_rect rect;
char* line;
rt_uint32_t total, used, max_used;
line = rtgui_malloc(256);
if (line == RT_NULL) return RT_FALSE;
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL)
{
rtgui_free(line);
return RT_FALSE;
}
rtgui_widget_get_rect(widget, &rect);
/* fill background */
rtgui_dc_fill_rect(dc, &rect);
rect.y2 = rect.y1 + 18;
{
rt_uint32_t dev_index, rev_index;
dev_index = DBGMCU_GetDEVID();
dev_index = (dev_index - 0x410)/2;
rev_index = DBGMCU_GetREVID();
switch (rev_index)
{
case 0x1000:
case 0x0000:
rev_index = 0; /* Revision A */
break;
case 0x1001:
case 0x2001:
rev_index = 3; /* Revision Z */
break;
case 0x2000:
rev_index = 1; /* Revision B */
break;
case 0x2002:
rev_index = 2; /* Revision Y */
break;
default:
rev_index = 4; /* Unknown */
break;
};
/* check device index */
if (dev_index > 4) dev_index = 3;
/* draw each information */
sprintf(line, "设备: %s %s",
stm32_devname[dev_index],
stm32_revname[rev_index]);
rtgui_dc_draw_text(dc, line, &rect); rect.y1 += 16; rect.y2 += 16;
}
rt_memory_info(&total, &used, &max_used);
sprintf(line, "内存: 当前使用 %d 字节", used);
rtgui_dc_draw_text(dc, line, &rect); rect.y1 += 16; rect.y2 += 16;
{
rt_uint16_t rect_width;
rtgui_color_t saved;
rtgui_rect_t mem_rect = rect;
rtgui_rect_inflate(&mem_rect, -2);
rtgui_dc_draw_rect(dc, &mem_rect);
rtgui_rect_inflate(&mem_rect, -1);
rect_width = rtgui_rect_width(mem_rect);
saved = RTGUI_WIDGET_BACKGROUND(widget);
RTGUI_WIDGET_BACKGROUND(widget) = light_grey;
mem_rect.x2 = mem_rect.x1 + (max_used * rect_width / total);
rtgui_dc_fill_rect(dc, &mem_rect);
RTGUI_WIDGET_BACKGROUND(widget) = blue;
mem_rect.x2 = mem_rect.x1 + (used * rect_width / total);
rtgui_dc_fill_rect(dc, &mem_rect);
/* restore color */
RTGUI_WIDGET_BACKGROUND(widget) = saved;
}
rect.y1 += 18; rect.y2 += 18;
sprintf(line, "线程数: %d", get_thread_cnt());
rtgui_dc_draw_text(dc, line, &rect); rect.y1 += 16; rect.y2 += 16;
#ifdef RT_USING_LWIP
{
struct ip_addr ip_addr;
struct _ip_addr
{
rt_uint8_t addr0, addr1, addr2, addr3;
} *addr;
addr = (struct _ip_addr*)&netif_default->ip_addr.addr;
sprintf(line, "IP地址 : %d.%d.%d.%d", addr->addr0, addr->addr1, addr->addr2, addr->addr3);
rtgui_dc_draw_text(dc, line, &rect); rect.y1 += 16; rect.y2 += 16;
addr = (struct _ip_addr*)&netif_default->gw.addr;
sprintf(line, "网关地址: %d.%d.%d.%d", addr->addr0, addr->addr1, addr->addr2, addr->addr3);
rtgui_dc_draw_text(dc, line, &rect); rect.y1 += 16; rect.y2 += 16;
addr = (struct _ip_addr*)&netif_default->netmask.addr;
sprintf(line, "网络掩码: %d.%d.%d.%d", addr->addr0, addr->addr1, addr->addr2, addr->addr3);
rtgui_dc_draw_text(dc, line, &rect); rect.y1 += 16; rect.y2 += 16;
#if LWIP_DNS
ip_addr = dns_getserver(0);
addr = (struct _ip_addr*)&ip_addr;
sprintf(line, "DNS地址 : %d.%d.%d.%d", addr->addr0, addr->addr1, addr->addr2, addr->addr3);
rtgui_dc_draw_text(dc, line, &rect); rect.y1 += 16; rect.y2 += 16;
#endif
}
#endif
rtgui_dc_end_drawing(dc);
rtgui_free(line);
return RT_FALSE;
}
case RTGUI_EVENT_KBD:
{
struct rtgui_event_kbd* ekbd;
ekbd = (struct rtgui_event_kbd*)event;
if (ekbd->type == RTGUI_KEYDOWN && ekbd->key == RTGUIK_RETURN)
{
rtgui_workbench_t* workbench;
workbench = RTGUI_WORKBENCH(RTGUI_WIDGET(device_view)->parent);
rtgui_workbench_remove_view(workbench, device_view);
rtgui_view_destroy(device_view);
device_view = RT_NULL;
}
}
return RT_FALSE;
}
/* use parent event handler */
return rtgui_view_event_handler(widget, event);
}
/* FIXME(Heyong): add for print the system infos when sys abort */
static void _rtt_statistics()
{
rt_uint32_t total;
rt_uint32_t used;
rt_uint32_t max_used;
struct rt_thread *thread;
struct rt_list_node *node;
rt_uint8_t *ptr;
rt_base_t level;
struct rt_object_information *information;
information = rt_object_get_information(RT_Object_Class_Thread);
RT_ASSERT(information != RT_NULL);
struct rt_list_node *list = &(information->object_list);
level = rt_hw_interrupt_disable();
for (node = list->next; node != list; node = node->next)
{
thread = rt_list_entry(node, struct rt_thread, list);
//if(thread) thread->total_tick = 0;
}
rt_hw_interrupt_enable(level);
rt_memory_info(&total,&used,&max_used);
rt_kprintf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
rt_kprintf("\n memory info size \n");
rt_kprintf("------------------------- ------\n");
rt_kprintf("total memory: (%dKB)\n", total/1024);
rt_kprintf("used memory : (%dKB)\n", used/1024);
rt_kprintf("maximum allocated memory: (%dKB)\n\n", max_used/1024);
rt_kprintf(" thread pri status sp stack addr stack size max used \n");
rt_kprintf("-------------------------------- --- ------- ---------- ---------- ---------- ---------- \n");
for (node = list->next; node != list; node = node->next)
{
thread = rt_list_entry(node, struct rt_thread, list);
#if 0
rt_kprintf("%-32.*s 0x%02x", RT_NAME_MAX, thread->name, thread->current_priority);
#else
int priority = thread->current_priority;
rt_kprintf("%-32.*s %03d", RT_NAME_MAX, thread->name, priority);
#endif
if (thread->stat == RT_THREAD_READY) rt_kprintf(" ready ");
else if (thread->stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend");
else if (thread->stat == RT_THREAD_INIT) rt_kprintf(" init ");
else if (thread->stat == RT_THREAD_CLOSE) rt_kprintf(" close ");
ptr = (rt_uint8_t*)thread->stack_addr;
while (*ptr == '#')ptr++;
rt_kprintf(" 0x%08x 0x%08x 0x%08x 0x%08x \n",
thread->stack_size + ((rt_uint32_t)thread->stack_addr - (rt_uint32_t)thread->sp),
thread->stack_addr,
thread->stack_size,
thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t)thread->stack_addr)
);
}
rt_kprintf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
}
