main8.c

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

        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        osWait(100);
    }
}




void Task170(void) {
    uword_t err;

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



void Task171(void) {
    uword_t err;

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



void Task172(void) {
    uword_t err;

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



void Task173(void) {
    uword_t err;

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



void Task174(void) {
    uword_t err;

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



void Task175(void) {
    uword_t err;

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



void Task176(void) {
    uword_t err;

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



void Task177(void) {
    uword_t err, err1;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task177   is running!\n");
            Print("Task177 wants to retrieve data from pipe5!\n");
            pipeRev(p5, &err1);
            if(err1 == PIPE_ID_NOT_MATCH) {
                Print("Task113 was refused to visit pipe5!\n\n");
            }
            semPost(TMP_SEM_ID, NULL);
        }
        osWait(100);
    }
}



void Task178(void) {
    uword_t err;

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



void Task179(void) {
    uword_t err;

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



void Task180(void) {
    uword_t err, err1, i;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print(".....................\n");
            Print("Task180 is running!\n");
            for(i = 0; i < 30; i++) {
                pipeSend(p6, msg[i], &err1);
            }
            Print("Sending message to pipe6 is over!\n");
            Print(".....................\n\n");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        osWait(100);
    }
}



void Task191(void) {
    uword_t err, err1;

    while(1) {
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print("Task191   is running!\n");
            Print("Task191 wants to retrieve data from pipe6!\n");
            pipeRev(p6, &err1);
            if(err1 == PIPE_ID_NOT_MATCH) {
                Print("Task191 was refused to visit pipe6!\n\n");
            }
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        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");
            semPost(TMP_SEM_ID, NULL);
        }
        osWait(0);
    }
}



void Task197(void) {
    uword_t err;

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



void Task198(void) {
    uword_t err;

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



void Task199(void) {
    uword_t err;

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



void Task200(void) {
    uword_t err, err1, i;
    char_t *str;

    while(1) {
        str = (char_t*)kmalloc(51);
        semGain(TMP_SEM_ID, NULL, &err);
        if(err == SEM_OK) {
            Print(".....................\n");
            Print("Task200 is running!\n");
            Print("Now retrieve date from pipe6\n");
            for(i = 0; i < 30; i++) {
                if((str = (char_t*)pipeRev(p6, &err1)) != NULL) {
                    Print("the %d message is:\n", i);
                    Print("%s\n\n", str);
                }
            }
            Print(".....................\n\n");
            semPost(TMP_SEM_ID, NULL);
        }
        kfree(str);
        osWait(50);
    }
}


/////////////////////////////////////////////

void Main(void) {
    uword_t err;

    p1 = pipeInit(100, 120, 20);
    p2 = pipeInit(130, 150, 20);
    p3 = pipeInit(160, 180, 20);
    p4 = pipeInit(200, 1120, 20);
    p5 = pipeInit(1140, 1160, 20);
    p6 = pipeInit(1180, 2000, 20);

    semInit(TMP_SEM_ID, 1, &err);

#if 1
    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);
#endif

#if 1
    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);
    osIni