void A(void) {
int num;
int sender_pid;
while (1) {
msg* p = (msg*)request_memory_block();
uart1_put_string("Waiting for KCD\r\n");
p = (msg*)(receive_message(&sender_pid));
if (p->mtext[0] == '%' && p->mtext[1] == 'Z') {
uart1_put_string("Received %Z from KCD\r\n");
release_memory_block(p);
break;
} else {
release_memory_block(p);
}
}
num = 0;
while (1) {
char b[8];
msg* p = (msg*)request_memory_block();
itoa(num, b);
p->mtype = 3;
p->mtext = b;
send_message(6,p);
uart1_put_string(b);
uart1_put_string("Sent Message from A to B\r\n");
num++;
release_processor();
}
// note that Process A does not de-allocate
// any received envelopes in the second loop
}
//this tests removing arbitrary blocks from used mem queue
void mem_test6() {
rtx_dbug_outs("Starting Memory Test 6\r\n");
//request half of the blocks
void * testArray[16];
//print_availible_mem_queue();
//print_used_mem_queue();
int i;
for (i = 0; i < 16; i++) {
testArray[i] = request_memory_block();
}
rtx_dbug_outs("Blocks requested\r\n");
//remove some from the middle
release_memory_block(testArray[4]);
release_memory_block(testArray[10]);
//print_availible_mem_queue();
//print_used_mem_queue();
//release all memory blocks
for (i = 0; i < 16; i++) {
if (i != 4 && i != 10) {
release_memory_block(testArray[i]);
}
}
rtx_dbug_outs("Finished Memory Test 6\r\n");
}
void proc2(void) {
if (get_process_priority(1) != LOW
|| get_process_priority(2) != MEDIUM
|| get_process_priority(3) != LOWEST
|| get_process_priority(4) != LOWEST
|| get_process_priority(5) != LOWEST
|| get_process_priority(6) != HIGH) {
prev_success = 0;
}
prev_pid = 2;
// TC 3b: allocate all memory blocks, free one, return
release_memory_block(mem[--index]); //jumps back to proc_6
// TC 3c: with 2 procs at highest priority, block both procs, then release memory in another proc to return to proc_6
prev_pid = 2;
release_memory_block(mem[--index]); //jumps to proc_3
// TC 3d: Block everything and preempt to null process after starvation
if (prev_pid != 1) {
prev_success = 0;
}
// 1: MEDIUM, blocked
// 2: LOW, will be blocked
// 3: HIGH, blocked
// 4, 5: LOWEST
// 6: HIGH, blocked
prev_pid = 2;
mem[index++] = request_memory_block();
}
//TC 1: Delayed message sending & no preemption
void proc1(void) {
MSG_BUF* envelope = NULL;
char* msg = "SE 350";
uart1_put_string("\n\r");
uart1_put_string("G003_test: START\n\r");
uart1_put_string("G003_test: total ");
uart1_put_char(total + 48);
uart1_put_string(" tests\n\r");
prev_pid = 1;
envelope = (MSG_BUF*)request_memory_block();
strcpy(envelope->mtext, msg);
delayed_send(1, envelope, 5000);
envelope = (MSG_BUF*)receive_message(NULL);
if (strcmp(envelope->mtext, msg) == 0) {
prev_success = 1;
} else {
prev_success = 0;
}
release_memory_block(envelope);
if (prev_success) {
uart1_put_string("G003_test: test ");
uart1_put_char(1 + 48);
uart1_put_string(" OK\n\r");
pass = pass + 1;
} else {
uart1_put_string("G003_test: test ");
uart1_put_char(1 + 48);
uart1_put_string(" FAIL\n\r");
}
//TC 2: Blocked on receive & preemption
envelope = (MSG_BUF*)receive_message(NULL);
prev_success = 1; // Checks if you ever get here.
release_memory_block(envelope);
if (prev_success) {
uart1_put_string("G003_test: test ");
uart1_put_char(2 + 48);
uart1_put_string(" OK\n\r");
pass = pass + 1;
} else {
uart1_put_string("G003_test: test ");
uart1_put_char(2 + 48);
uart1_put_string(" FAIL\n\r");
}
while (1) {
release_processor();
}
}
//Second part to the test (Test 4)
void mem_test5() {
rtx_dbug_outs("Starting Memory Test 5\r\n");
//request 31 blocks of mem (Mem should now fill up)
void * testArray[32];
//request 31 memory blocks
int i;
for (i = 0; i < 31; i++) {
testArray[i] = request_memory_block();
}
//print_availible_mem_queue();
//print_used_mem_queue();
rtx_dbug_outs("Requested 31 blocks. Requesting one more\r\n");
//this should get blocked
testArray[31] = request_memory_block();
//PROC 4 SHOULD HAPPEN BEFORE THIS AND SHOULD RELEASE IT'S MEMORY
rtx_dbug_outs_int("Got Block! Address is: \r\n", (int)testArray[31]);
//release all memory blocks
for (i = 0; i < 32; i++) {
release_memory_block(testArray[i]);
}
//print_availible_mem_queue();
//print_used_mem_queue();
rtx_dbug_outs("Finished Memory Test 5\r\n");
}
/**
* Tries to free invalid memory location
*/
void test_proc_p1_3() {
int i = 0;
int ret;
int proc = 2;
void* memory = 0;
while (1) {
//printf("Process 3\r\n");
memory = (void*) 0xDEADC0DE;
ret = release_memory_block(memory);
if (ret == 0) {
test_results[g_test_procs[proc].pid] = 0;
}
if (i == 0) {
if (test_results[proc] == 1) {
printf("G005_test: test 3 OK\r\n");
} else {
printf("G005_test: test 3 FAIL\r\n");
}
}
i = 1;
ret = release_processor();
}
}
int message_api_tests_passed(){
void * p = request_memory_block();
int i = 0;
int testCases = 100;
for(i = 0; i < testCases; i++){
set_sender_PID(p, i);
assert(get_sender_PID(p) == i,"message api function is broken");
set_destination_PID(p, i);
assert(get_destination_PID(p) == i,"message api function is broken");
set_message_type(p, i);
assert(get_message_type(p) == i,"message api function is broken");
assert(get_message_data(p) != 0,"message api function is broken");
assert(get_message_data(p) != 0,"message api function is broken");
//set_message_data(p,p, 10);
}
release_memory_block(p);
return 1;
}
void uart() {
struct io_message * msg = NULL;
while(1) {
#ifdef _IO_DEBUG
rtx_dbug_outs((CHAR *) "Enter: uart - waiting for message\r\n");
#endif
msg = (io_message *)receive_message(NULL);
#ifdef _IO_DEBUG
rtx_dbug_outs((CHAR *) "Enter: uart - received message\r\n");
#endif
char_out = msg->msg[0];
release_memory_block((void *)msg);
// irene said this is OK
while( !(SERIAL1_UCSR & 4) ) { }
// write data to port
SERIAL1_WD = char_out;
#ifdef _IO_DEBUG
rtx_dbug_outs((CHAR *) "Writing data: ");
rtx_dbug_out_char(char_out);
rtx_dbug_outs((CHAR *) "\r\n");
#endif
}
}
//Proc 1 of a two processor test
//These tests will check to see if a block due to memory is handled right
void mem_test4() {
rtx_dbug_outs("Starting Memory Test 4\r\n");
rtx_dbug_outs("Requesting one block\r\n");
//print_availible_mem_queue();
//print_used_mem_queue();
//request 1 memory block
void * oneBlock = request_memory_block();
rtx_dbug_outs_int("Block recieved. Block address: \r\n", (int)oneBlock);
rtx_dbug_outs("Releasing proccessor in Memory Test 4\r\n");
//release the processor (to the other test)
release_processor();
rtx_dbug_outs("Restarting Memory Test 4\r\n");
//print_availible_mem_queue();
//print_used_mem_queue();
//release the memory block
release_memory_block(oneBlock);
rtx_dbug_outs("Memory Block Got Released\r\n");
rtx_dbug_outs("Finished Memory Test 4\r\n");
}
void process_priority_proc(void) {
msg_buf* message;
message = (msg_buf*)request_memory_block();
message->mtype = KCD_REG;
copy_string("%C", message->mtext);
send_message(PID_KCD, message);
while (1){
int neg_1 = -1;
int mtext_len;
msg_buf* message = (msg_buf*) receive_message(&neg_1);
if (message == NULL) {
continue;
}
mtext_len = str_len(message->mtext);
if (message->mtext[1] == 'C' && (mtext_len == 8 || mtext_len == 7)) {
int p_id;
int p_priority;
if (mtext_len == 7) {
// %C X Y
p_id = message->mtext[3] - '0';
p_priority = message->mtext[5] - '0';
} else {
// %C XX Y
p_id = (message->mtext[3] - '0') * 10;
p_id = message->mtext[4] - '0';
p_priority = message->mtext[6] - '0';
}
if (set_process_priority(p_id, p_priority) == RTX_ERR) {
msg_buf* err_msg = (msg_buf*)request_memory_block();
Node* msg_node = (Node*)request_memory_block();
err_msg->mtype = CRT_DISPLAY;
copy_string("Invalid Command for set process priority\n\r", err_msg->mtext);
//sends error to CRT
msg_node->sender_id = PID_SET_PRIO;
msg_node->receiving_id = PID_CRT;
msg_node->data = err_msg;
send_message_node(msg_node);
}
} else {
msg_buf* err_msg = (msg_buf*)request_memory_block();
Node* msg_node = (Node*)request_memory_block();
err_msg->mtype = CRT_DISPLAY;
copy_string("Invalid Format for set process priority\n\r", err_msg->mtext);
//sends error to CRT
msg_node->sender_id = PID_SET_PRIO;
msg_node->receiving_id = PID_CRT;
msg_node->data = err_msg;
send_message_node(msg_node);
}
release_memory_block(message);
}
}
void set_priority_proc(void) {
/*sends message to kcd to register the command types*/
ENVELOPE *msg = (ENVELOPE *)request_memory_block();
msg->message_type = MSG_COMMAND_REGISTRATION;
msg->sender_pid = SET_PRIORITY_PID;
msg->destination_pid = KCD_PID;
set_message(msg, "%C" + '\0', 4*sizeof(char));
send_message(KCD_PID, msg);
while(1){
int priority, pid;
ENVELOPE * rec_msg = (ENVELOPE*) receive_message(NULL);
char * char_message = (char *) rec_msg->message;
if ((char_message[3] >= '1')&&(char_message[3] <= '6')&&(char_message[4] == ' ')&&(char_message[5] >= '0')&&(char_message[5] <= '3') && (char_message[6] == '\0')){
pid = char_message[3] - '0';
priority = char_message[5] - '0';
//printf("message %s", char_message);
//printf("pid %d priority %d", pid, priority);
set_process_priority(pid, priority);
}
else {
ENVELOPE * error_msg = (ENVELOPE*) request_memory_block();
error_msg->sender_pid = SET_PRIORITY_PID;
error_msg->destination_pid = CRT_PID;
error_msg->message_type = MSG_CRT_DISPLAY;
error_msg->message = error_msg + HEADER_OFFSET;
sprintf(error_msg->message, "You have entered an invalid input\n\r");
send_message(CRT_PID, error_msg);
}
release_memory_block(rec_msg);
}
}
//Test 1 reciever (message can be accurately sent/recieved)
void proc2(void) {
int pid = 2;
int sender = 1;
msgbuf *msg;
msg = receive_message(&sender);
//check message contents
if (msg->mtype == DEFAULT && msg->mtext[0] == MSG_TEXT_1){
test_status[0] = TEST_SUCCESS;//TEST 1: Message contents same as when sent
} else {
test_status[0] = TEST_FAILURE;//message contents incorrect
}
release_memory_block(msg);
//Done testing
set_process_priority(pid, LOWEST);
#ifdef _DEBUG_HOTKEYS
// Force this process to be BLOCKED_ON_RECEIVE
receive_message(NULL);
#endif // _DEBUG_HOTKEYS
while (1) {
release_processor();
}
}
/* Delayed Send Test */
void test_proc_p2_1(void) {
int result_pid = 0;
msg_buf_t* msg_envelope = NULL;
char* msg = "Hello";
msg_envelope = (msg_buf_t*)request_memory_block();
strncpy(msg_envelope->msg_data, msg, 5);
delayed_send(PID_P1, msg_envelope, CLOCK_INTERVAL);
msg_envelope = (msg_buf_t*)receive_message(NULL);
if (strcmp(msg_envelope->msg_data, msg) == 5) {
printf("G005_test: test 1 OK\r\n");
} else {
printf("G005_test: test 1 FAIL\r\n");
test_results[result_pid] = 0;
}
release_memory_block(msg_envelope);
test_ran[result_pid] = 1;
set_process_priority(g_test_procs[result_pid].pid, 3);
while (1) {
release_processor();
}
}
void kcd_proc(void)
{
ENVELOPE* msg;
int i;
while(1)
{
msg = (ENVELOPE*) receive_message(NULL);
if (msg != NULL)
{
if (msg->message_type == MSG_COMMAND_REGISTRATION)
{
for (i = 0; i < KC_MAX_COMMANDS; i++)
{
if (g_kc_reg[i].pid == -1)
{
g_kc_reg[i].pid = msg->sender_pid;
strcpy(g_kc_reg[i].command, msg->message);
break;
}
}
}
else if (msg->message_type == MSG_CONSOLE_INPUT)
{
int i = 0;
int j;
char command[KC_MAX_CHAR];
char* message_curr = msg->message;
while ((i < KC_MAX_CHAR)&&(message_curr[i] != ' ')&&(message_curr[i] != '\0'))
{
command[i] = message_curr[i];
i++;
}
command[i] = '\0';
// find end of message
while (message_curr[i] != '\0')
{
i++;
}
for (j = 0; j < KC_MAX_COMMANDS; j++)
{
if ((strcmp(command,g_kc_reg[j].command) == 0)&&(g_kc_reg[j].pid != -1))
{
ENVELOPE* kcd_msg = (ENVELOPE*) request_memory_block();
kcd_msg->sender_pid = KCD_PID;
kcd_msg->destination_pid = g_kc_reg[j].pid;
kcd_msg->nextMsg = NULL;
kcd_msg->message_type = MSG_KCD_DISPATCH;
kcd_msg->delay = 0;
set_message(kcd_msg, message_curr, i*sizeof(char));
send_message(g_kc_reg[j].pid, kcd_msg);
break;
}
}
}
}
release_memory_block(msg);
}
}
/* Sends message to user process 2 */
void test_proc_p2_3(void) {
int result_pid = 2;
msg_buf_t* msg_envelope = 0;
char* sent_msg = "OS";
char* received_msg = "SE350";
msg_envelope = (msg_buf_t*)request_memory_block();
strncpy(msg_envelope->msg_data, sent_msg, 2);
send_message(PID_P2, msg_envelope);
msg_envelope = (msg_buf_t*)receive_message(NULL);
if (strcmp(msg_envelope->msg_data, received_msg) == 5) {
printf("G005_test: test 3 OK\r\n");
} else {
printf("G005_test: test 3 FAIL\r\n");
test_results[result_pid] = 0;
}
release_memory_block(msg_envelope);
test_ran[result_pid] = 1;
set_process_priority(g_test_procs[result_pid].pid, 3);
while (1) {
release_processor();
}
}
/**
* @brief: a process that prints five numbers
* and then releases a memory block
*/
void proc2(void)
{
int i = 0;
int ret_val = 20;
void *p_mem_blk;
p_mem_blk = request_memory_block();
set_process_priority(PID_P2, MEDIUM);
while ( 1) {
if ( i != 0 && i%5 == 0 ) {
uart0_put_string("\n\r");
ret_val = release_memory_block(p_mem_blk);
#ifdef DEBUG_0
printf("proc2: ret_val=%d\n", ret_val);
#endif /* DEBUG_0 */
if ( ret_val == -1 ) {
break;
}
}
uart0_put_char('0' + i%10);
i++;
}
uart0_put_string("proc2: end of testing\n\r");
set_process_priority(PID_P2, LOWEST);
while ( 1 ) {
release_processor();
}
}
void kcd_proc(void) {
char command_registry[NUM_PROCS];
U32 it;
for(it = 0; it < NUM_PROCS; it++){
command_registry[it] = '/';
}
while (true) {
int sender_id = -1;
msg_buf* message = (msg_buf*)receive_message(&sender_id);
if (message == NULL) {
continue;
}
if(message->mtype == KCD_REG){
command_registry[sender_id] = message->mtext[1];
release_memory_block(message);
}
else if(message->mtype == DEFAULT){
if(message->mtext[0] != '%'){
release_memory_block(message);
}
else{
//valid command
int i;
for (i = 0; i < NUM_PROCS; i++){
if(message->mtext[1] == command_registry[i]){
//send msg to process with associated command
Node* msg_node = (Node*)request_memory_block();
msg_node->sender_id = PID_KCD;
msg_node->receiving_id = i;
msg_node->data = message;
send_message_node(msg_node);
}
}
if (i == NUM_PROCS){
release_memory_block(message);
}
}
} else {
release_memory_block(message);
}
}
}
//This function requests all blocks, realeases all of them (in backwards order),
//and tries to request another block (should succeed)
void mem_test3 () {
rtx_dbug_outs("Starting Memory Test 3\r\n");
void * testArray[32];
rtx_dbug_outs("Requesting all memory blocks\r\n");
//print_availible_mem_queue();
//print_used_mem_queue();
//request all memory blocks
int i;
for (i = 0; i < 32; i++) {
testArray[i] = request_memory_block();
}
rtx_dbug_outs("All memory blocks requested\r\n");
//print_availible_mem_queue();
//print_used_mem_queue();
//release all memory blocks
for (i = 31; i >= 0; i--) {
release_memory_block(testArray[i]);
}
rtx_dbug_outs("All blocks released\r\n");
//print_availible_mem_queue();
//print_used_mem_queue();
//request one more block
void * oneMore;
oneMore = request_memory_block();
rtx_dbug_outs("One more block given\r\n");
//release last one
release_memory_block(oneMore);
rtx_dbug_outs("Finished Memory Test 3\r\n");
}
/**
* @brief: Requests memory blocks and returns
*/
void memory_block_test(void)
{
int ret_val = 60;
int i = 0;
int* tmp_int;
char* tmp_string;
while(1) {
print_debug("Iterating through proc 4 with\r\n");
tmp_int = request_memory_block();
tmp_string = request_memory_block();
i++;
*tmp_int = i;
if (i > 1337) {
i = 0;
}
tmp_string[0] = 'H';
tmp_string[1] = 'E';
tmp_string[2] = 'L';
tmp_string[3] = 'L';
tmp_string[4] = 'O';
tmp_string[5] = '\0';
//printf("INT! Address: 0x%x, Value: %d\r\n",tmp_int,*tmp_int);
print_debug("CHAR[]!: ");
print_debug(tmp_string);
print_debug("\r\n");
//printf("CHAR[]! Address: 0x%x, Value: %s\r\n",&tmp_string,tmp_string);
release_memory_block(tmp_int);
release_memory_block(tmp_string);
print_debug("Proc 4 completed!\r\n");
ret_val = release_processor();
if (ret_val == -1) {
print_debug("G021_test: test 4 FAIL\r\n");
test_results[3] = 0;
} else {
print_debug("G021_test: test 4 OK\r\n");
}
}
}
void C (void) {
Q_Queue local_mailbox;
int sender_pid;
q_init(&local_mailbox);
while (1) {
msg* p;
if (local_mailbox.first == NULL) {
p = (msg*)(receive_message(&sender_pid));
}
else {
p = (msg*)q_pop(&local_mailbox);
}
if (p->mtype == 3) {
int msg_value = atoi(p->mtext);
if (msg_value%20 == 0) {
msg* MessageToSend = (msg*)request_memory_block();
msg* q = (msg*)request_memory_block();
MessageToSend->mtype = 2;
MessageToSend->mtext = "Process C";
send_message(13, MessageToSend);
q->mtype = 4;
q->mtext = "";
delayed_send(7,q,10000);
while (1) {
msg* r;
r = (msg*)(receive_message(&sender_pid)); //block and let other processes execute
if (r->mtype == 4) {
release_memory_block(r);
break;
} else {
q_push(&local_mailbox, r);
}
}
}
}
release_memory_block(p);
release_processor();
}
}
void proc2(void) {
while (1) {
lastMemBlock = request_memory_block();
printf("mem block: %X\n", lastMemBlock);
results[2] = (lastMemBlock == 0) ? 0 : 1;
release_processor();
release_memory_block(lastMemBlock);
}
}
//Test 4 (normal message is recieved before a delayed message)
void proc4(void) {
int pid = 4;
msgbuf *delayed_msg;
msgbuf *normal_msg;
msgbuf *received_msg;
//create delayed message
delayed_msg = request_memory_block();
delayed_msg->mtype = DEFAULT;
delayed_msg->mtext[0] = MSG_TEXT_1;
//create normal message
normal_msg = request_memory_block();
normal_msg->mtype = DEFAULT;
normal_msg->mtext[0] = MSG_TEXT_2;//different text from the delayed message
//send delayed message
delayed_send(pid, delayed_msg, DELAY);
//send normal message
send_message(pid, normal_msg);
//recieve message
received_msg = receive_message(&pid);
//if normal message, mark test passed
if (received_msg->mtext[0] == MSG_TEXT_2){//should get the non delayed message before the delayed message even though it was sent later.
test_status[3] = TEST_SUCCESS;//TEST 4: normal message is recieved before delayed message
} else {
test_status[3] = TEST_FAILURE;
}
//release message memory
release_memory_block(received_msg);
//recieve massage
received_msg = receive_message(&pid);//reusing variable now that the test is finished.
//release message memory
release_memory_block(received_msg);
//Done testing
set_process_priority(pid, LOWEST);
while (1) {
release_processor();
}
}
//TC 4: KCD and CRT
void proc4(void) {
MSG_BUF* msg = NULL;
msg = (MSG_BUF*)request_memory_block();
msg->mtype = KCD_REG;
msg->mtext[0] = '%';
msg->mtext[1] = 'T';
msg->mtext[2] = 'E';
msg->mtext[3] = 'S';
msg->mtext[4] = 'T';
msg->mtext[4] = '\0';
send_message(PID_KCD, msg);
msg = (MSG_BUF*)request_memory_block();
msg->mtype = CRT_DISPLAY;
strcpy(msg->mtext, "Input %TEST and press enter:\n\r");
send_message(PID_CRT, msg);
msg = receive_message(NULL);
if (strcmp(msg->mtext, "%TEST") == 0) {
prev_success = 1;
} else {
prev_success = 0;
}
release_memory_block(msg);
if (prev_success) {
uart1_put_string("G003_test: test ");
uart1_put_char(4 + 48);
uart1_put_string(" OK\n\r");
pass = pass + 1;
} else {
uart1_put_string("G003_test: test ");
uart1_put_char(4 + 48);
uart1_put_string(" FAIL\n\r");
}
uart1_put_string("G003_test: ");
uart1_put_char(pass + 48);
uart1_put_string("/");
uart1_put_char(total + 48);
uart1_put_string(" tests OK\n\r");
uart1_put_string("G003_test: ");
uart1_put_char((total - pass) + 48);
uart1_put_string("/");
uart1_put_char(total + 48);
uart1_put_string(" tests FAIL\n\r");
uart1_put_string("G003_test: END\n\r");
while (1) {
release_processor();
}
}
// highest priority
void mem_test_blocking2()
{
// block this process
void * msg = receive_message(NULL);
void * msgBack = request_memory_block();
send_message(MEM_TEST_MASTER_PID, msgBack);
release_memory_block(msg);
}
void crt(){
void * msg;
CHAR * s;
while(1){
msg = receive_message(NULL);
*s = *(read_message(msg));
uprintf(s);
release_memory_block(msg);
}
return;
}
void crt_proc(void) {
Envelope *temp = NULL;
uint32_t localWriter = 0;
uint32_t localReader = 0;
while (1) {
Envelope *nextMsg = NULL;
while (crt_hasFreeEnv(&(gProcInfo.crtData))) {
temp = crt_getFreeEnv(&(gProcInfo.crtData));
if (temp->messageType == MT_DEBUG && temp->srcPid == CRT_PID) {
// NOTE(sanjay): we DO NOT want to free this envelope, it's a
// preallocated buffer stored inside a process' PCB
--(gProcInfo.debugSem);
continue;
} else if (
temp->srcPid == CRT_PID &&
temp->messageType == MT_KEYBOARD
) {
// NOTE(sanjay): we DO NOT want to free this envelope, it's a
// preallocated buffer that echoes keyboard output
gProcInfo.currentEnv = temp;
continue;
}
release_memory_block((void*)temp);
}
nextMsg = (Envelope *)receive_message(NULL);
if (nextMsg == NULL) {
continue;
}
if (nextMsg->srcPid == CRT_PID && nextMsg->messageType == MT_CRT_WAKEUP) {
gProcInfo.uartOutputEnv = nextMsg;
} else {
crt_pushProcEnv(&(gProcInfo.crtData), nextMsg);
}
localWriter = gProcInfo.outWriter;
localReader = gProcInfo.outReader;
while (
((localWriter + 1) % OUTPUT_BUFSIZE != localReader) &&
(crt_hasOutByte(&(gProcInfo.crtData)))
) {
gProcInfo.outputBuf[localWriter] = crt_getOutByte(&(gProcInfo.crtData));
localWriter = (localWriter + 1) % OUTPUT_BUFSIZE;
}
gProcInfo.outWriter = localWriter;
gProcInfo.outLock = 1;
uart_send_char_isr(&gProcInfo);
gProcInfo.outLock = 0;
}
}
/**
* This process will request 2 memory blocks, print their value
* then release them. Finally it will output the return value;
*/
void test_proc_p1_2() {
int ret;
int i = 0;
int proc = 1;
void* memory1 = 0;
void* memory2 = 0;
while (1) {
//printf("Process 2\r\n");
memory1 = request_memory_block();
memory2 = request_memory_block();
*((int*)memory1) = 0xDEAD10CC;
*((int*)memory2) = 0xDEADC0DE;
if (*((int*)memory1) != 0xDEAD10CC) {
test_results[g_test_procs[proc].pid] = 0;
}
ret = release_memory_block(memory1);
if (ret != 0 && i == 0) {
test_results[g_test_procs[proc].pid] = 0;
}
if (*((int*)memory2) != 0xDEADC0DE) {
test_results[g_test_procs[proc].pid] = 0;
}
ret = release_memory_block(memory2);
if (ret != 0 && i == 0) {
test_results[g_test_procs[proc].pid] = 0;
}
if (i == 0) {
if (test_results[proc] == 1) {
printf("G005_test: test 2 OK\r\n");
} else {
printf("G005_test: test 2 FAIL\r\n");
}
}
i = 1;
ret = release_processor();
}
}
void uart_keyboard_proc(void) {
Envelope *message = NULL;
ProcId registry['z' - 'a' + 1] = {0};
ProcId destPid = 0;
char c = '\0';
uint8_t reject = 1;
while (1) {
message = receive_message(NULL);
if (message == NULL) {
continue;
}
if (message->srcPid != KEYBOARD_PID) {
c = toLowerAndIsLetter(message->messageData[0]);
if ('a' <= c && c <= 'z') {
registry[c - 'a'] = message->srcPid;
}
release_memory_block((void *)message);
message = NULL;
continue;
}
// If it is "from ourself", then we send a message to the registered processes.
c = message->messageData[0];
reject = 1;
if (c == '%') {
c = toLowerAndIsLetter(message->messageData[1]);
if (c != '\0') {
destPid = registry[c - 'a'];
if (destPid != 0) {
reject = 0;
}
}
}
if (reject) {
size_t i = 0;
size_t bufLen = MESSAGEDATA_SIZE_BYTES - 1;
message->messageData[i++] = FC_RED;
i += write_string(message->messageData+i, bufLen-i, "No handler found for this command.\n");
message->messageData[i++] = '\0';
message->messageType = MT_UNSET;
send_message(CRT_PID, message);
message = NULL;
} else {
// Send the message to the proc that registered with this character
send_message(destPid, message);
message = NULL;
}
}
}
void crt_proc(void)
{
while(1){
ENVELOPE* env = (ENVELOPE*) receive_message(NULL);
LPC_UART_TypeDef *pUart = (LPC_UART_TypeDef *)LPC_UART0;
if (env->message_type == MSG_CRT_DISPLAY){
send_message(UART_IPROC_PID, env);
pUart->IER |= IER_THRE;
} else {
release_memory_block(env);
}
}
}
void wall_clock_proc() {
MSG_BUF *msg;
void *mem;
int i = 0;
MSG_BUF *p_msg_env;
long time = 0; // second
char second[2], minute[2], hour[2];
int start = 0;
while (1) {
if (i==0) {
i++;
p_msg_env = (struct msgbuf *) request_memory_block();
p_msg_env->mtype = KCD_REG;
p_msg_env->mtext[0] = '%';
p_msg_env->mtext[1] = 'W';
p_msg_env->mtext[2] = '\0';
send_message(PID_KCD, (void *)p_msg_env);
}
msg = receive_message((int*)PID_CLOCK);
switch (msg->mtype) {
case UPDATE_TIME:
if (start == 1) {
time ++;
wall_clock_display(time);
}
break;
default:
switch (msg->mtext[2]) {
case 'R':
time = 0;
break;
case 'S':
time = charToTime(msg->mtext, 4);
if (start == 0) {
start = 1;
wall_clock_display(time);
}
break;
case 'T':
start = 0;
break;
default: break;
}
break;
}
release_memory_block((void*)msg);
release_processor();
}
}
