main12.c

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

		    write(fd, "task82 is running\n", 18);
		    close(fd);
        }
        osWait(28);
	}
}

void task83(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task83 is running\n", 18);
		    close(fd);
        }
        osWait(38);
	}
}

void task84(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task84 is running\n", 18);
		    close(fd);
        }
        osWait(48);
	}
}

void task85(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task85 is running\n", 18);
		    close(fd);
        }
        osWait(58);
	}
}

void task86(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task86 is running\n", 18);
		    close(fd);
        }
        osWait(22);
	}
}

void task87(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task87 is running\n", 18);
		    close(fd);
        }
        osWait(26);
	}
}

void task88(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task88 is running\n", 18);
		    close(fd);
        }
        osWait(56);
	}
}

void task89(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task89 is running\n", 18);
		    close(fd);
        }
        osWait(56);
	}
}

void task90(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task90 is running\n", 18);
		    close(fd);
        }
        osWait(19);
	}
}

void task91(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task91 is running\n", 18);
		    close(fd);
        }
        osWait(56);
	}
}

void task92(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task92 is running\n", 18);
		    close(fd);
        }
        osWait(56);
	}
}

void task93(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task93 is running\n", 18);
		    close(fd);
        }
        osWait(39);
	}
}

void task94(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task94 is running\n", 18);
		    close(fd);
        }
        osWait(56);
	}
}

void task95(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task95 is running\n", 18);
		    close(fd);
        }
        osWait(56);
	}
}

void task96(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task96 is running\n", 18);
		    close(fd);
        }
        osWait(55);
	}
}

void task97(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task97 is running\n", 18);
		    close(fd);
        }
        osWait(48);
	}
}

void task98(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task98 is running\n", 18);
		    close(fd);
        }
        osWait(88);
	}
}

void task99(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task99 is running\n", 18);
		    close(fd);
        }
        osWait(56);
	}
}

void task100(void) {
	word_t fd;

	while(1) {
		if((fd = open("uart0")) != -1) {
		    write(fd, "task100 is running\n", 19);
		    close(fd);
        }
        osWait(56);
	}
}

void task101(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task101 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(23);
        kfree(buf);
	}
}

void task102(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task102 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(56);
        kfree(buf);
	}
}

void task103(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task103 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(80);
        kfree(buf);
	}
}

void task104(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task104 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(15);
        kfree(buf);
	}
}

void task105(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task105 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(66);
        kfree(buf);
	}
}

void task106(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task106 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(54);
        kfree(buf);
	}
}

void task107(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task107 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(13);
        kfree(buf);
	}
}

void task108(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task108 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(78);
        kfree(buf);
	}
}

void task109(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task109 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(12);
        kfree(buf);
	}
}
void task110(void) {
	word_t fd, cnt;
    char_t *buf;

	while(1) {
        buf = (char_t*)kmalloc(64);
		if((fd = open("uart0")) != -1) {
            cnt = read(fd, buf, 64);
            if(cnt != 0)
            {
                write(fd, buf, cnt);
                write(fd, "^_^, ^_^, ^_^, ^_^, ^_^, ^_^\n", 29);
                write(fd, "task110 is running\n\n", 22);
            }
            close(fd);
        }
        osWait(36);
        kfree(buf);
	}
}

void Main(void) {

	osInitTask(task1, 101, 1, 5, STACK_SIZE);
    osInitTask(task2, 102, 1, 5, STACK_SIZE);
    osInitTask(task3, 103, 2, 5, STACK_SIZE);
    osInitTask(task4, 104, 3, 5, STACK_SIZE);
    osInitTask(task5, 105, 4, 5, STACK_SIZE);
    osInitTask(task6, 106, 5, 5, STACK_SIZE);
    osInitTask(task7, 107, 6, 5, STACK_SIZE);
    osInitTask(task8, 108, 7, 5, STACK_SIZE);
    osInitTask(task9, 109, 8, 5, STACK_SIZE);
    osInitTask(task10, 110, 9, 5, STACK_SIZE);
#if 1
    osInitTask(task11, 111, 10, 5, STACK_SIZE);
    osInitTask(task12, 112, 11, 5, STACK_SIZE);
    osInitTask(task13, 113, 12, 5, STACK_SIZE);
    osInitTask(task14, 114, 13, 5, STACK_SIZE);
    osInitTask(task15, 115, 14, 5, STACK_SIZE);
    osInitTask(task16, 116, 15, 5, STACK_SIZE);
    osInitTask(task17, 117, 16, 5, STACK_SIZE);
    osInitTask(task18, 118, 17, 5, STACK_SIZE);
    osInitTask(task19, 119, 18, 5, STACK_SIZE);
    osInitTask(task20, 120, 19, 5, STACK_SIZE);
	osInitTask(task21, 121, 20, 5, STACK_SIZE);
    osInitTask(task22, 122, 21, 5, STACK_SIZE);
    osInitTask(task23, 123, 22, 5, STACK_SIZE);
    osInitTask(task24, 124, 23, 5, STACK_SIZE);
    osInitTask(task25, 125, 24, 5, STACK_SIZE);
    osInitTask(task26, 126, 25, 5, STACK_SIZE);
    osInitTask(task27, 127, 26, 5, STACK_SIZE);
    osInitTask(task28, 128, 27, 5, STACK_SIZE);
    osInitTask(task29, 129, 28, 5, STACK_SIZE);
    osInitTask(task30, 130, 29, 5, STACK_SIZE);
	osInitTask(task31, 131, 30, 5, STACK_SIZE);
    osInitTask(task32, 132, 31, 5, STACK_SIZE);
    osInitTask(task33, 133, 32, 5, STACK_SIZE);
    osInitTask(task34, 134, 33, 5, STACK_SIZE);
    osInitTask(task35, 135, 34, 5, STACK_SIZE);
    osInitTask(task36, 136, 35, 5, STACK_SIZE);
    osInitTask(task37, 137, 36, 5, STACK_SIZE);
    osInitTask(task38, 138, 37, 5, STACK_SIZE);
    osInitTask(task39, 139, 38, 5, STACK_SIZE);
    osInitTask(task40, 140, 39, 5, STACK_SIZE);
	osInitTask(task41, 141, 40, 5, STACK_SIZE);
    osInitTask(task42, 142, 41, 5, STACK_SIZE);
    osInitTask(task43, 143, 42, 5, STACK_SIZE);
    osInitTask(task44, 144, 43, 5, STACK_SIZE);
    osInitTask(task45, 145, 44, 5, STACK_SIZE);
    osInitTask(task46, 146, 45, 5, STACK_SIZE);
    osInitTask(task47, 147, 46, 5, STACK_SIZE);
    osInitTask(task48, 148, 47, 5, STACK_SIZE);
    osInitTask(task49, 149, 48, 5, STACK_SIZE);
    osInitTask(task50, 150, 49, 5, STACK_SIZE);
	osInitTask(task51, 151, 50, 5, STACK_SIZE);
    osInitTask(task52, 152, 51, 5, STACK_SIZE);
    osInitTask(task53, 153, 52, 5, STACK_SIZE);
    osInitTask(task54, 154, 53, 5, STACK_SIZE);
    osInitTask(task55, 155, 54, 5, STACK_SIZE);
    osInitTask(task56, 156, 55, 5, STACK_SIZE);
    osInitTask(task57, 157, 56, 5, STACK_SIZE);
    osInitTask(task58, 158, 57, 5, STACK_SIZE);
    osInitTask(task59, 159, 58, 5, STACK_SIZE);
    osInitTask(task60, 160, 59, 5, STACK_SIZE);
	osInitTask(task61, 161, 60, 5, STACK_SIZE);
    osInitTask(task62, 162, 61, 5, STACK_SIZE);
    osInitTask(task63, 163, 62, 5, STACK_SIZE);
    osInitTask(task64, 164, 63, 5, STACK_SIZE);
    osInitTask(task65, 165, 1, 5, STACK_SIZE);
    osInitTask(task66, 166, 1, 5, STACK_SIZE);
    osInitTask(task67, 167, 2, 5, STACK_SIZE);
    osInitTask(task68, 168, 3, 5, STACK_SIZE);
    osInitTask(task69, 169, 4, 5, STACK_SIZE);
    osInitTask(task70, 170, 5, 5, STACK_SIZE);
	osInitTask(task71, 171, 6, 5, STACK_SIZE);
    osInitTask(task72, 172, 7, 5, STACK_SIZE);
    osInitTask(task73, 173, 8, 5, STACK_SIZE);
    osInitTask(task74, 174, 9, 5, STACK_SIZE);
    osInitTask(task75, 175, 10, 5, STACK_SIZE);
    osInitTask(task76, 176, 11, 5, STACK_SIZE);
    osInitTask(task77, 177, 12, 5, STACK_SIZE);
    osInitTask(task78, 178, 13, 5, STACK_SIZE);
    osInitTask(task79, 179, 14, 5, STACK_SIZE);
    osInitTask(task80, 180, 15, 5, STACK_SIZE);
	osInitTask(task81, 181, 16, 5, STACK_SIZE);
    osInitTask(task82, 182, 17, 5, STACK_SIZE);
    osInitTask(task83, 183, 18, 5, STACK_SIZE);
    osInitTask(task84, 184, 19, 5, STACK_SIZE);
    osInitTask(task85, 185, 20, 5, STACK_SIZE);
    osInitTask(task86, 186, 21, 5, STACK_SIZE);
    osInitTask(task87, 187, 22, 5, STACK_SIZE);
    osInitTask(task88, 188, 23, 5, STACK_SIZE);
    osInitTask(task89, 189, 24, 5, STACK_SIZE);
    osInitTask(task90, 190, 25, 5, STACK_SIZE);
	osInitTask(task91, 191, 26, 5, STACK_SIZE);
    osInitTask(task92, 192, 27, 5, STACK_SIZE);
    osInitTask(task93, 193, 28, 5, STACK_SIZE);
    osInitTask(task94, 194, 29, 5, STACK_SIZE);
    osInitTask(task95, 195, 30, 5, STACK_SIZE);
    osInitTask(task96, 196, 31, 5, STACK_SIZE);
    osInitTask(task97, 197, 32, 5, STACK_SIZE);
    osInitTask(task98, 198, 33, 5, STACK_SIZE);
    osInitTask(task99, 199, 34, 5, STACK_SIZE);
    osInitTask(task100, 200,35, 5, STACK_SIZE);

    osInitTask(task101, 201, 36, 5, STACK_SIZE);
    osInitTask(task102, 202, 36, 5, STACK_SIZE);
    osInitTask(task103, 203, 36, 5, STACK_SIZE);
    osInitTask(task104, 204, 36, 5, STACK_SIZE);
    osInitTask(task105, 205, 36, 5, STACK_SIZE);
    osInitTask(task106, 206, 36, 5, STACK_SIZE);
    osInitTask(task107, 207, 36, 5, STACK_SIZE);
    osInitTask(task108, 208, 36, 5, STACK_SIZE);
    osInitTask(task109, 209, 36, 5, STACK_SIZE);
    osInitTask(task110, 210, 36, 5, STACK_SIZE);
#endif
}