main7.c

Bycore是一个嵌入式操作系统内核。Bycore包括内存管理、任务管理、中断管理、任务互斥、同步与通信管理等功能。Bycore全部由C语言完成

    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task164  is running!\n");
        }
        osWait(50);
    }
}


void Task165(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task165  is running!\n");
        }
        osWait(100);
    }
}


void Task166(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task166  is running!\n");
        }
        osWait(20);
    }
}


void Task167(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task167  is running!\n");
        }
        osWait(100);
    }
}


void Task168(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task168  is running!\n");
        }
        osWait(10);
    }
}


void Task169(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task169  is running!\n");
        }
        osWait(100);
    }
}

//use SendStr function
void Task170(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task70  is running!\n");
        }
        osWait(15);
    }
}


void Task171(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task171  is running!\n");
        }
        osWait(12);
    }
}


void Task172(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task172  is running!\n");
        }
        osWait(100);
    }
}


void Task173(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task173  is running!\n");
        }
        osWait(11);
    }
}


void Task174(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task174  is running!\n");
        }
        osWait(100);
    }
}


void Task175(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task175  is running!\n");
        }
        osWait(100);
    }
}


void Task176(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task176  is running!\n");
        }
        osWait(100);
    }
}


void Task177(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task177  is running!\n");
        }
        osWait(100);
    }
}


void Task178(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task178  is running!\n");
        }
        osWait(100);
    }
}


void Task179(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            SendStr("Task179  is running!\n");
        }
        osWait(100);
    }
}


void Task180(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task180  is running!\n");
        }
        osWait(100);
    }
}


void Task181(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task181  is running!\n");
        }
        osWait(100);
    }
}


void Task182(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task182  is running!\n");
        }
        osWait(100);
    }
}


void Task183(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task183  is running!\n");
        }
        osWait(100);
    }
}


void Task184(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task184  is running!\n");
        }
        osWait(100);
    }
}


void Task185(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task185  is running!\n");
        }
        osWait(100);
    }
}


void Task186(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task186  is running!\n");
        }
        osWait(100);
    }
}


void Task187(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task187  is running!\n");
        }
        osWait(100);
    }
}


void Task188(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task188  is running!\n");
        }
        osWait(100);
    }
}


void Task189(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task189  is running!\n");
        }
        osWait(100);
    }
}


void Task190(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task190  is running!\n");
        }
        osWait(100);
    }
}


void Task191(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task191  is running!\n");
        }
        osWait(100);
    }
}


void Task192(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task192  is running!\n");
        }
        osWait(100);
    }
}


void Task193(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task193  is running!\n");
        }
        osWait(100);
    }
}


void Task194(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task194  is running!\n");
        }
        osWait( - 1);
    }
}


void Task195(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task195  is running!\n");
        }
        osWait(100);
    }
}


void Task196(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task196  is running!\n");
        }
        osWait(10);
    }
}


void Task197(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task197  is running!\n");
        }
        osWait(10);
    }
}


void Task198(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task198  is running!\n");
        }
        osWait(10);
    }
}


void Task199(void) {
    uword_t err;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task199  is running!\n");
        }
        osWait(~0);
    }
}


void Task200(void) {
    list_t *plist, *p;
    tcb_t *ptcb;

    osWait(50);
    while(1) {
        semDel(TMP_SEM_ID, NULL);
        Print(".....................................\n");
        p = osGetSleepHead();
        plist = p->next;

        do {
            if(plist != p) {
                ptcb = mac_find_entry(plist, tcb_t, link);
                Print("task is %d\n", ptcb->id);
                plist = plist->next;
            } else {
                plist = plist->next;
            }
        } while(plist != p->next);
        Print(".....................................\n\n");
        osWait(5000);
    }
}


void Main(void) {
    uword_t err;

    psem = semInit(TMP_SEM_ID, 1, &err);

    osInitTask(Task0, 100, 0, 5, STACK_SIZE);
    osInitTask(Task1, 101, 1, 5, STACK_SIZE);
    osInitTask(Task2, 102, 2, 5, STACK_SIZE);
    osInitTask(Task3, 103, 3, 5, STACK_SIZE);
    osInitTask(Task4, 104, 4, 5, STACK_SIZE);
    osInitTask(Task5, 105, 5, 5, STACK_SIZE);
    osInitTask(Task6, 106, 6, 5, STACK_SIZE);
    osInitTask(Task7, 107, 7, 5, STACK_SIZE);
    osInitTask(Task8, 108, 8, 5, STACK_SIZE);
    osInitTask(Task9, 109, 9, 5, STACK_SIZE);
    osInitTask(Task10, 110, 10, 5, STACK_SIZE);
    osInitTask(Task11, 111, 11, 5, STACK_SIZE);
    osInitTask(Task12, 112, 12, 5, STACK_SIZE);
    osInitTask(Task13, 113, 13, 5, STACK_SIZE);
    osInitTask(Task14, 114, 14, 5, STACK_SIZE);
    osInitTask(Task15, 115, 15, 5, STACK_SIZE);
    osInitTask(Task16, 116, 16, 5, STACK_SIZE);
    osInitTask(Task17, 117, 17, 5, STACK_SIZE);
    osInitTask(Task18, 118, 18, 5, STACK_SIZE);
    osInitTask(Task19, 119, 19, 5, STACK_SIZE);
    osInitTask(Task20, 120, 20, 5, STACK_SIZE);
    osInitTask(Task21, 121, 21, 5, STACK_SIZE);
    osInitTask(Task22, 122, 22, 5, STACK_SIZE);
    osInitTask(Task23, 123, 23, 5, STACK_SIZE);
    osInitTask(Task24, 124, 24, 5, STACK_SIZE);
    osInitTask(Task25, 125, 25, 5, STACK_SIZE);
    osInitTask(Task26, 126, 26, 5, STACK_SIZE);
    osInitTask(Task27, 127, 27, 5, STACK_SIZE);
    osInitTask(Task28, 128, 28, 5, STACK_SIZE);
    osInitTask(Task29, 129, 29, 5, STACK_SIZE);
    osInitTask(Task30, 130, 30, 5, STACK_SIZE);
    osInitTask(Task31, 131, 31, 5, STACK_SIZE);
    osInitTask(Task32, 132, 32, 5, STACK_SIZE);
    osInitTask(Task33, 133, 33, 5, STACK_SIZE);
    osInitTask(Task34, 134, 34, 5, STACK_SIZE);
    osInitTask(Task35, 135, 35, 5, STACK_SIZE);
    osInitTask(Task36, 136, 36, 5, STACK_SIZE);
    osInitTask(Task37, 137, 37, 5, STACK_SIZE);
    osInitTask(Task38, 138, 38, 5, STACK_SIZE);
    osInitTask(Task39, 139, 39, 5, STACK_SIZE);
    osInitTask(Task40, 140, 40, 5, STACK_SIZE);
    osInitTask(Task41, 141, 41, 5, STACK_SIZE);
    osInitTask(Task42, 142, 42, 5, STACK_SIZE);
    osInitTask(Task43, 143, 43, 5, STACK_SIZE);
    osInitTask(Task44, 144, 44, 5, STACK_SIZE);
    osInitTask(Task45, 145, 45, 5, STACK_SIZE);
    osInitTask(Task46, 146, 46, 5, STACK_SIZE);
    osInitTask(Task47, 147, 47, 5, STACK_SIZE);
    osInitTask(Task48, 148, 48, 5, STACK_SIZE);
    osInitTask(Task49, 149, 49, 5, STACK_SIZE);
    osInitTask(Task50, 150, 50, 5, STACK_SIZE);
    osInitTask(Task51, 151, 51, 5, STACK_SIZE);
    osInitTask(Task52, 152, 52, 5, STACK_SIZE);
    osInitTask(Task53, 153, 53, 5, STACK_SIZE);
    osInitTask(Task54, 154, 54, 5, STACK_SIZE);
    osInitTask(Task55, 155, 55, 5, STACK_SIZE);
    osInitTask(Task56, 156, 56, 5, STACK_SIZE);
    osInitTask(Task57, 157, 57, 5, STACK_SIZE);
    osInitTask(Task58, 158, 58, 5, STACK_SIZE);
    osInitTask(Task59, 159, 59, 5, STACK_SIZE);
    osInitTask(Task60, 160, 60, 5, STACK_SIZE);
    osInitTask(Task61, 161, 61, 5, STACK_SIZE);
    osInitTask(Task62, 162, 62, 5, STACK_SIZE);
    osInitTask(Task63, 163, 63, 5, STACK_SIZE);
    osInitTask(Task64, 164, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task65, 165, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task66, 166, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task67, 167, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task68, 168, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task69, 169, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task70, 170, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task71, 171, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task72, 172, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task73, 173, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task74, 174, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task75, 175, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task76, 176, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task77, 177, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task78, 178, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task79, 179, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task80, 180, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task81, 181, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task82, 182, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task83, 183, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task84, 184, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task85, 185, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task86, 186, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task87, 187, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task88, 188, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task89, 189, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task90, 190, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task91, 191, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task92, 192, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task93, 193, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task94, 194, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task95, 195, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task96, 196, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task97, 197, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task98, 198, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task99, 199, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task100, 200, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task101, 1101, 1, 5, STACK_SIZE);
    osInitTask(Task102, 1102, 2, 5, STACK_SIZE);
    osInitTask(Task103, 1103, 3, 5, STACK_SIZE);
    osInitTask(Task104, 1104, 4, 5, STACK_SIZE);
    osInitTask(Task105, 1105, 5, 5, STACK_SIZE);
    osInitTask(Task106, 1106, 6, 5, STACK_SIZE);
    osInitTask(Task107, 1107, 7, 5, STACK_SIZE);
    osInitTask(Task108, 1108, 8, 5, STACK_SIZE);
    osInitTask(Task109, 1109, 9, 5, STACK_SIZE);
    osInitTask(Task110, 1110, 10, 5, STACK_SIZE);
    osInitTask(Task111, 1111, 11, 5, STACK_SIZE);
    osInitTask(Task112, 1112, 12, 5, STACK_SIZE);
    osInitTask(Task113, 1113, 13, 5, STACK_SIZE);
    osInitTask(Task114, 1114, 14, 5, STACK_SIZE);
    osInitTask(Task115, 1115, 15, 5, STACK_SIZE);
    osInitTask(Task116, 1116, 16, 5, STACK_SIZE);
    osInitTask(Task117, 1117, 17, 5, STACK_SIZE);
    osInitTask(Task118, 1118, 18, 5, STACK_SIZE);
    osInitTask(Task119, 1119, 19, 5, STACK_SIZE);
    osInitTask(Task120, 1120, 20, 5, STACK_SIZE);
    osInitTask(Task121, 1121, 21, 5, STACK_SIZE);
    osInitTask(Task122, 1122, 22, 5, STACK_SIZE);
    osInitTask(Task123, 1123, 23, 5, STACK_SIZE);
    osInitTask(Task124, 1124, 24, 5, STACK_SIZE);
    osInitTask(Task125, 1125, 25, 5, STACK_SIZE);
    osInitTask(Task126, 1126, 26, 5, STACK_SIZE);
    osInitTask(Task127, 1127, 27, 5, STACK_SIZE);
    osInitTask(Task128, 1128, 28, 5, STACK_SIZE);
    osInitTask(Task129, 1129, 29, 5, STACK_SIZE);
    osInitTask(Task130, 1130, 30, 5, STACK_SIZE);
    osInitTask(Task131, 1131, 31, 5, STACK_SIZE);
    osInitTask(Task132, 1132, 32, 5, STACK_SIZE);
    osInitTask(Task133, 1133, 33, 5, STACK_SIZE);
    osInitTask(Task134, 1134, 34, 5, STACK_SIZE);
    osInitTask(Task135, 1135, 35, 5, STACK_SIZE);
    osInitTask(Task136, 1136, 36, 5, STACK_SIZE);
    osInitTask(Task137, 1137, 37, 5, STACK_SIZE);
    osInitTask(Task138, 1138, 38, 5, STACK_SIZE);
    osInitTask(Task139, 1139, 39, 5, STACK_SIZE);
    osInitTask(Task140, 1140, 40, 5, STACK_SIZE);
    osInitTask(Task141, 1141, 41, 5, STACK_SIZE);
    osInitTask(Task142, 1142, 42, 5, STACK_SIZE);
    osInitTask(Task143, 1143, 43, 5, STACK_SIZE);
    osInitTask(Task144, 1144, 44, 5, STACK_SIZE);
    osInitTask(Task145, 1145, 45, 5, STACK_SIZE);
    osInitTask(Task146, 1146, 46, 5, STACK_SIZE);
    osInitTask(Task147, 1147, 47, 5, STACK_SIZE);
    osInitTask(Task148, 1148, 48, 5, STACK_SIZE);
    osInitTask(Task149, 1149, 49, 5, STACK_SIZE);
    osInitTask(Task150, 1150, 50, 5, STACK_SIZE);
    osInitTask(Task151, 1151, 51, 5, STACK_SIZE);
    osInitTask(Task152, 1152, 52, 5, STACK_SIZE);
    osInitTask(Task153, 1153, 53, 5, STACK_SIZE);
    osInitTask(Task154, 1154, 54, 5, STACK_SIZE);
    osInitTask(Task155, 1155, 55, 5, STACK_SIZE);
    osInitTask(Task156, 1156, 56, 5, STACK_SIZE);
    osInitTask(Task157, 1157, 57, 5, STACK_SIZE);
    osInitTask(Task158, 1158, 58, 5, STACK_SIZE);
    osInitTask(Task159, 1159, 59, 5, STACK_SIZE);
    osInitTask(Task160, 1160, 60, 5, STACK_SIZE);
    osInitTask(Task161, 1161, 61, 5, STACK_SIZE);
    osInitTask(Task162, 1162, 62, 5, STACK_SIZE);
    osInitTask(Task163, 1163, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task164, 1164, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task165, 1165, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task166, 1166, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task167, 1167, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task168, 1168, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task169, 1169, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task170, 1170, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task171, 1171, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task172, 1172, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task173, 1173, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task174, 1174, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task175, 1175, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task176, 1176, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task177, 1177, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task178, 1178, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task179, 1179, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task180, 1180, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task181, 1181, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task182, 1182, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task183, 1183, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task184, 1184, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task185, 1185, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task186, 1186, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task187, 1187, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task188, 1188, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task189, 1189, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task190, 1190, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task191, 1191, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task192, 1192, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task193, 1193, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task194, 1194, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task195, 1195, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task196, 1196, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task197, 1197, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task198, 1198, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task199, 1199, SAME_PRIO, 5, STACK_SIZE);
    osInitTask(Task200, 1200, 0, 5, STACK_SIZE);
}