diff --git a/APP_Framework/Applications/app_test/test_hash/test_hash.c b/APP_Framework/Applications/app_test/test_hash/test_hash.c
index c45fb19dc..071cc59df 100644
--- a/APP_Framework/Applications/app_test/test_hash/test_hash.c
+++ b/APP_Framework/Applications/app_test/test_hash/test_hash.c
@@ -30,40 +30,40 @@ void TestHash(void)
     HashTable table;
     
     printf("Init Hash Table\n");
-    Init(&table);
+    HashTableInit(&table);
 
     printf("Test Hash Table\n");
     printf("Insert 1, 10\n");
-    Insert(&table, 1, 10);
+    HashTableInsert(&table, 1, 10);
     printf("Insert 2, 20\n");
-    Insert(&table, 2, 20);
+    HashTableInsert(&table, 2, 20);
     printf("Insert 3, 30\n");
-    Insert(&table, 3, 30);
+    HashTableInsert(&table, 3, 30);
     printf("Insert 101, 40\n");
-    Insert(&table, 101, 40);
+    HashTableInsert(&table, 101, 40);
     printf("Insert 102, 50\n");
-    Insert(&table, 102, 50);
+    HashTableInsert(&table, 102, 50);
     printf("Insert 103, 60\n");
-    Insert(&table, 103, 60);
+    HashTableInsert(&table, 103, 60);
     printf("Insert 104, 70\n");
-    Insert(&table, 104, 70);
+    HashTableInsert(&table, 104, 70);
 
-    printf("Search 1, result: %d\n", Search(&table, 1));
-    printf("Search 2, result: %d\n", Search(&table, 2));
-    printf("Search 3, result: %d\n", Search(&table, 3));
-    printf("Search 4, result: %d\n", Search(&table, 4));
-    printf("Search 101, result: %d\n", Search(&table, 101));
-    printf("Search 102, result: %d\n", Search(&table, 102));
-    printf("Search 103, result: %d\n", Search(&table, 103));
-    printf("Search 104, result: %d\n", Search(&table, 104));
+    printf("Search 1, result: %d\n", HashTableSearch(&table, 1));
+    printf("Search 2, result: %d\n", HashTableSearch(&table, 2));
+    printf("Search 3, result: %d\n", HashTableSearch(&table, 3));
+    printf("Search 4, result: %d\n", HashTableSearch(&table, 4));
+    printf("Search 101, result: %d\n", HashTableSearch(&table, 101));
+    printf("Search 102, result: %d\n", HashTableSearch(&table, 102));
+    printf("Search 103, result: %d\n", HashTableSearch(&table, 103));
+    printf("Search 104, result: %d\n", HashTableSearch(&table, 104));
 
     printf("Delete 1\n");
-    Delete(&table, 1);
+    HashTableDelete(&table, 1);
 
-    printf("Search 1, result: %d\n", Search(&table, 1));
+    printf("Search 1, result: %d\n", HashTableSearch(&table, 1));
 
     printf("Clear Table\n");
-    Clear(&table);
+    HashTableClear(&table);
 
     return;
 }
diff --git a/APP_Framework/Applications/app_test/test_hash/test_hash.h b/APP_Framework/Applications/app_test/test_hash/test_hash.h
index 9ecb0db5b..0703d250c 100644
--- a/APP_Framework/Applications/app_test/test_hash/test_hash.h
+++ b/APP_Framework/Applications/app_test/test_hash/test_hash.h
@@ -25,44 +25,46 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define TABLE_SIZE 101
+#define HASH_TABLE_SIZE 101
 
-typedef struct Node{
+typedef struct HashTableNode HashTableNode;
+
+struct HashTableNode{
     int key;
     int value;
-    struct Node *next;
-} Node;
+    HashTableNode *next;
+};
 
 typedef struct HashTable{
-    Node *table[TABLE_SIZE];
+    HashTableNode *table[HASH_TABLE_SIZE];
 } HashTable;
 
-unsigned int Hash(int key)
+static unsigned int Hash(int key)
 {
-    return key % TABLE_SIZE;
+    return key % HASH_TABLE_SIZE;
 }
 
-Node* CreateNode(int key, int value)
+static HashTableNode* CreateNode(int key, int value)
 {
-    Node *new_node = (Node*)malloc(sizeof(Node));
+    HashTableNode* new_node = (HashTableNode*)malloc(sizeof(HashTableNode));
     new_node->key = key;
     new_node->value = value;
     new_node->next = NULL;
     return new_node;
 }
 
-void Init(HashTable *hash_table)
+void HashTableInit(HashTable *hash_table)
 {
     int i;
-    for(i = 0; i < TABLE_SIZE; i++)
+    for(i = 0; i < HASH_TABLE_SIZE; i++)
         hash_table->table[i] = NULL;
 }
 
-void Insert(HashTable *hash_table, int key, int value)
+void HashTableInsert(HashTable *hash_table, int key, int value)
 {
     unsigned int hash_value = Hash(key);
 
-    Node *node = hash_table->table[hash_value];
+    HashTableNode* node = hash_table->table[hash_value];
     while(node != NULL && node->key != key)
         node = node->next;
     if(node != NULL){
@@ -70,15 +72,15 @@ void Insert(HashTable *hash_table, int key, int value)
         return;
     }
 
-    Node *new_node = CreateNode(key, value);
+    HashTableNode* new_node = CreateNode(key, value);
     new_node->next = hash_table->table[hash_value];
     hash_table->table[hash_value] = new_node;
 }
 
-int Search(HashTable *hash_table, int key)
+int HashTableSearch(HashTable *hash_table, int key)
 {
     unsigned int hash_value = Hash(key);
-    Node *node = hash_table->table[hash_value];
+    HashTableNode* node = hash_table->table[hash_value];
     while(node != NULL && node->key != key)
         node = node->next;
     if(node == NULL)
@@ -87,11 +89,11 @@ int Search(HashTable *hash_table, int key)
         return node->value;
 }
 
-void Delete(HashTable *hash_table, int key)
+void HashTableDelete(HashTable *hash_table, int key)
 {
     unsigned int hash_value = Hash(key);
-    Node *node = hash_table->table[hash_value];
-    Node *prev_node = NULL;
+    HashTableNode* node = hash_table->table[hash_value];
+    HashTableNode* prev_node = NULL;
     while(node != NULL && node->key != key){
         prev_node = node;
         node = node->next;
@@ -105,13 +107,13 @@ void Delete(HashTable *hash_table, int key)
     free(node);
 }
 
-void Clear(HashTable *hash_table)
+void HashTableClear(HashTable *hash_table)
 {
     int i;
-    for(i = 0; i < TABLE_SIZE; i++){
-        Node *node = hash_table->table[i];
+    for(i = 0; i < HASH_TABLE_SIZE; i++){
+        HashTableNode* node = hash_table->table[i];
         while(node != NULL){
-            Node *temp = node;
+            HashTableNode* temp = node;
             node = node->next;
             free(temp);
         }
@@ -119,12 +121,12 @@ void Clear(HashTable *hash_table)
     }
 }
 
-void PrintTable(HashTable *hash_table)
+void HashTablePrint(HashTable *hash_table)
 {
     int i;
-    for(i = 0; i < TABLE_SIZE; i++){
+    for(i = 0; i < HASH_TABLE_SIZE; i++){
         printf("Print %d\n", i);
-        Node *node = hash_table->table[i];
+        HashTableNode* node = hash_table->table[i];
         while(node != NULL){
             printf("key: %d, value: %d\n", node->key, node->value);
             node = node->next;
diff --git a/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.c b/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.c
index fd3229e85..4e47f538f 100644
--- a/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.c
+++ b/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.c
@@ -27,7 +27,7 @@
 
 void TestRBTree(void)
 {   
-    struct Node *root = NULL;
+    RBTreeNode* root = NULL;
     printf("创建红黑树并且插入以下结点\n");
     printf("key: 7, value: 7\n");
     printf("key: 3, value: 3\n");
@@ -49,21 +49,21 @@ void TestRBTree(void)
     int values[] = {7, 3, 18, 10, 22, 8, 11, 26, 2, 6, 13, 20, 27, 1, 12, 14, 25};
 
     for (int i = 0; i < sizeof(values) / sizeof(values[0]); i++)
-        insertNode(&root, values[i], values[i]);
+        RBTreeInsert(&root, values[i], values[i]);
 
     printf("插入创建完毕后中序遍历红黑树结果：\n");
-    inorderTraversal(root);
+    RBTreeInorderTraversal(root);
     printf("\n");
 
     printf("查找key值为 10 的结点\n");
-    struct Node *searchResult = searchNode(root, 10);
+    RBTreeNode* searchResult = RBTreeSearch(root, 10);
     if (searchResult != NULL)
         printf("找到了key值为 %d 的结点, value值为 %d \n", searchResult->key, searchResult->value);
     else
         printf("未找到key值为 %d 的结点\n", 10);
 
     printf("查找key值为 100 的结点\n");
-    searchResult = searchNode(root, 100);
+    searchResult = RBTreeSearch(root, 100);
     if (searchResult != NULL)
         printf("找到了key值为 %d 的结点, value值为 %d \n", searchResult->key, searchResult->value);
     else
@@ -71,18 +71,18 @@ void TestRBTree(void)
 
     printf("删除结点 10 和 22\n");
     int deleteData = 10;
-    deleteNode(&root, 10);
-    deleteNode(&root, 22);
+    RBTreeDelete(&root, 10);
+    RBTreeDelete(&root, 22);
 
     printf("查找key值为 10 的结点\n");
-    searchResult = searchNode(root, 10);
+    searchResult = RBTreeSearch(root, 10);
     if (searchResult != NULL)
         printf("找到了key值为 %d 的结点, value值为 %d \n", searchResult->key, searchResult->value);
     else
         printf("未找到key值为 %d 的结点\n", 10);
     
     printf("查找key值为 22 的结点\n");
-    searchResult = searchNode(root, 22);
+    searchResult = RBTreeSearch(root, 22);
     if (searchResult != NULL)
         printf("找到了key值为 %d 的结点, value值为 %d \n", searchResult->key, searchResult->value);
     else
@@ -90,10 +90,10 @@ void TestRBTree(void)
     
     
     printf("删除结点 %d 后的中序遍历结果：\n", deleteData);
-    inorderTraversal(root);
+    RBTreeInorderTraversal(root);
     printf("\n");
     printf("清空红黑树并且释放内存\n");
-    clear(root);
+    RBTreeClear(root);
 }
 
 PRIV_SHELL_CMD_FUNCTION(TestRBTree, a red black tree test sample, PRIV_SHELL_CMD_MAIN_ATTR);
diff --git a/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.h b/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.h
index e6e78424c..82dd4e045 100644
--- a/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.h
+++ b/APP_Framework/Applications/app_test/test_rbtree/test_rbtree.h
@@ -26,19 +26,20 @@
 #include <string.h>
 
 // define color of red-black tree
-enum Color {RED, BLACK};
+enum RBTreeColor {RED, BLACK};
 
+typedef struct RBTreeNode RBTreeNode;
 // define a node of red-black tree
-struct Node {
+struct RBTreeNode{
     int key;
     int value;
-    enum Color color;
-    struct Node *left, *right, *parent;
+    enum RBTreeColor color;
+    RBTreeNode *left, *right, *parent;
 };
 
 // create a new nodes
-struct Node *createNode(int key, int value) {
-    struct Node *newNode = (struct Node*)malloc(sizeof(struct Node));
+static RBTreeNode *createNode(int key, int value) {
+    RBTreeNode *newNode = (RBTreeNode*)malloc(sizeof(RBTreeNode));
     newNode->key = key;
     newNode->value = value;
     newNode->color = RED;
@@ -47,8 +48,8 @@ struct Node *createNode(int key, int value) {
 }
 
 // red-black tree left rotation
-void leftRotate(struct Node **root, struct Node *x) {
-    struct Node *y = x->right;
+static void leftRotate(RBTreeNode **root, RBTreeNode *x) {
+    RBTreeNode *y = x->right;
     x->right = y->left;
     if (y->left != NULL)
         y->left->parent = x;
@@ -64,8 +65,8 @@ void leftRotate(struct Node **root, struct Node *x) {
 }
 
 // red-black tree right rotation
-void rightRotate(struct Node **root, struct Node *y) {
-    struct Node *x = y->left;
+static void rightRotate(RBTreeNode **root, RBTreeNode *y) {
+    RBTreeNode *x = y->left;
     y->left = x->right;
     if (x->right != NULL)
         x->right->parent = y;
@@ -81,16 +82,16 @@ void rightRotate(struct Node **root, struct Node *y) {
 }
 
 // red-black tree fix-up
-void fixViolation(struct Node **root, struct Node *newNode) {
-    struct Node *parent = NULL;
-    struct Node *grandparent = NULL;
+static void fixViolation(RBTreeNode **root, RBTreeNode *newNode) {
+    RBTreeNode *parent = NULL;
+    RBTreeNode *grandparent = NULL;
 
     while ((newNode != *root) && (newNode->color != BLACK) && (newNode->parent->color == RED)) {
         parent = newNode->parent;
         grandparent = newNode->parent->parent;
 
         if (parent == grandparent->left) {
-            struct Node *uncle = grandparent->right;
+            RBTreeNode *uncle = grandparent->right;
 
             if (uncle != NULL && uncle->color == RED) {
                 grandparent->color = RED;
@@ -105,13 +106,13 @@ void fixViolation(struct Node **root, struct Node *newNode) {
                 }
 
                 rightRotate(root, grandparent);
-                int temp = parent->color;
+                enum RBTreeColor temp = parent->color;
                 parent->color = grandparent->color;
                 grandparent->color = temp;
                 newNode = parent;
             }
         } else {
-            struct Node *uncle = grandparent->left;
+            RBTreeNode *uncle = grandparent->left;
 
             if ((uncle != NULL) && (uncle->color == RED)) {
                 grandparent->color = RED;
@@ -126,7 +127,7 @@ void fixViolation(struct Node **root, struct Node *newNode) {
                 }
 
                 leftRotate(root, grandparent);
-                int temp = parent->color;
+                enum RBTreeColor temp = parent->color;
                 parent->color = grandparent->color;
                 grandparent->color = temp;
                 newNode = parent;
@@ -138,10 +139,10 @@ void fixViolation(struct Node **root, struct Node *newNode) {
 }
 
 // insert a node into red-black tree
-void insertNode(struct Node **root, int key, int value) {
-    struct Node *newNode = createNode(key, value);
-    struct Node *current = *root;
-    struct Node *parent = NULL;
+void RBTreeInsert(RBTreeNode **root, int key, int value) {
+    RBTreeNode* newNode = createNode(key, value);
+    RBTreeNode* current = *root;
+    RBTreeNode* parent = NULL;
 
     while (current != NULL) {
         parent = current;
@@ -163,18 +164,18 @@ void insertNode(struct Node **root, int key, int value) {
 }
 
 // search a node in red-black tree
-struct Node *searchNode(struct Node *root, int key) {
+RBTreeNode* RBTreeSearch(RBTreeNode* root, int key) {
     if (root == NULL || root->key == key)
         return root;
 
     if (root->key < key)
-        return searchNode(root->right, key);
+        return RBTreeSearch(root->right, key);
 
-    return searchNode(root->left, key);
+    return RBTreeSearch(root->left, key);
 }
 
 // find the minimum node in red-black tree
-struct Node *minimumNode(struct Node *node) {
+static RBTreeNode* minimumNode(RBTreeNode* node) {
     while (node->left != NULL)
         node = node->left;
 
@@ -182,7 +183,7 @@ struct Node *minimumNode(struct Node *node) {
 }
 
 // replace a node with another node
-void transplant(struct Node **root, struct Node *u, struct Node *v) {
+static void transplant(RBTreeNode** root, RBTreeNode* u, RBTreeNode* v) {
     if (u->parent == NULL)
         *root = v;
     else if (u == u->parent->left)
@@ -195,8 +196,8 @@ void transplant(struct Node **root, struct Node *u, struct Node *v) {
 }
 
 // fix the delete violation in red-black tree
-void fixDeleteViolation(struct Node **root, struct Node *node, struct Node *parent) {
-    struct Node *sibling = NULL;
+static void fixDeleteViolation(RBTreeNode** root, RBTreeNode* node, RBTreeNode* parent) {
+    RBTreeNode* sibling = NULL;
 
     while ((node != *root) && ((node == NULL) || (node->color == BLACK))) {
         if (node == parent->left) {
@@ -268,14 +269,14 @@ void fixDeleteViolation(struct Node **root, struct Node *node, struct Node *pare
 
 
 // delete a node from red-black tree
-void deleteNode(struct Node **root, int key) {
-    struct Node *nodeToDelete = searchNode(*root, key);
+void RBTreeDelete(RBTreeNode** root, int key) {
+    RBTreeNode* nodeToDelete = RBTreeSearch(*root, key);
     if (nodeToDelete == NULL)
         return;
 
-    struct Node *child = NULL;
-    struct Node *parent = NULL;
-    enum Color originalColor = nodeToDelete->color;
+    RBTreeNode* child = NULL;
+    RBTreeNode* parent = NULL;
+    enum RBTreeColor originalColor = nodeToDelete->color;
 
     if (nodeToDelete->left == NULL) {
         child = nodeToDelete->right;
@@ -286,7 +287,7 @@ void deleteNode(struct Node **root, int key) {
         parent = nodeToDelete->parent;
         transplant(root, nodeToDelete, nodeToDelete->left);
     } else {
-        struct Node *successor = minimumNode(nodeToDelete->right);
+        RBTreeNode* successor = minimumNode(nodeToDelete->right);
         originalColor = successor->color;
         child = successor->right;
         parent = successor->parent;
@@ -311,19 +312,19 @@ void deleteNode(struct Node **root, int key) {
 }
 
 // inorder traversal
-void inorderTraversal(struct Node *root) {
+void RBTreeInorderTraversal(RBTreeNode* root) {
     if (root != NULL) {
-        inorderTraversal(root->left);
+        RBTreeInorderTraversal(root->left);
         printf("%d ", root->key);
-        inorderTraversal(root->right);
+        RBTreeInorderTraversal(root->right);
     }
 }
 
 //clear the tree
-void clear(struct Node *root) {
+void RBTreeClear(RBTreeNode* root) {
     if (root != NULL) {
-        clear(root->left);
-        clear(root->right);
+        RBTreeClear(root->left);
+        RBTreeClear(root->right);
         free(root);
     }
 }
diff --git a/Ubiquitous/XiZi_IIoT/board/k210-emulator/config.mk b/Ubiquitous/XiZi_IIoT/board/k210-emulator/config.mk
index f792841a3..d33cf2db8 100644
--- a/Ubiquitous/XiZi_IIoT/board/k210-emulator/config.mk
+++ b/Ubiquitous/XiZi_IIoT/board/k210-emulator/config.mk
@@ -7,7 +7,7 @@ export APPLFLAGS := -mcmodel=medany -march=rv64imac -mabi=lp64 -nostartfiles -Wl
 
 export CXXFLAGS := -mcmodel=medany -march=rv64imac -mabi=lp64 -fno-common -ffunction-sections -fdata-sections -fstrict-volatile-bitfields -O0 -Wa,-g -ggdb -Werror
 
-export CROSS_COMPILE ?=/opt/xpack-riscv-none-embed-gcc-8.3.0-1.2/bin/riscv-none-embed-
+export CROSS_COMPILE ?=/opt/gnu-mcu-eclipse/riscv-none-gcc/8.2.0-2.1-20190425-1021/bin/riscv-none-embed-
 
 export DEFINES := -DHAVE_CCONFIG_H -DHAVE_SIGINFO