コード例 #1
0
ファイル: test_proc.c プロジェクト: nullcat/se350-project
/* 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();
    }
}
コード例 #2
0
 caf::behavior main_phase() {
   send(this, tick_atom::value);
   return {
     [=](const std::vector<uint16_t>& data, uint32_t id) {
       concat_data(data, id);
     },
     [=](tick_atom) {
       delayed_send(this, tick_rate_, tick_atom::value);
       if (cache_.empty()) {
         std::cout << "[WARNING] Cache empty..." << std::endl;
         return;
       }
       send(sink_, image_width_, cache_.front());
       cache_.pop();
       send_job();
     },
     [=](resize_atom, uint32_t w, uint32_t h) {
       resize(w,h);
     },
     [=](limit_atom, normal_atom, uint32_t workers) {
       become(make_behavior());
       send(this, calc_weights_atom::value, size_t{workers});
     },
     caf::others() >> [=] {
       std::cout << to_string(current_message()) << std::endl;
     }
   };
 }
コード例 #3
0
ファイル: test_p2.c プロジェクト: jerryzxliu/se350lab
//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(); 
	}	
}
コード例 #4
0
void local_actor::delayed_send_tuple(message_priority prio, const channel& dest,
                                     const duration& rel_time, message msg) {
  message_id mid;
  if (prio == message_priority::high) {
    mid = mid.with_high_priority();
  }
  auto sched_cd = detail::singletons::get_scheduling_coordinator();
  sched_cd->delayed_send(rel_time, address(), dest, mid, std::move(msg));
}
コード例 #5
0
ファイル: real_user_proc.c プロジェクト: kimyousee/SE350_RTX
void wall_clock_display(int time) {
	MSG_BUF *msg;
	msg = (MSG_BUF *) request_memory_block();
	msg->mtype = UPDATE_TIME;
	delayed_send(PID_CLOCK, msg, ONE_SECOND);
	
	msg = (MSG_BUF *) request_memory_block();
	msg->mtype = CRT_DISPLAY;
	timeToChar(time, msg->mtext);
	
	send_message(PID_CRT, msg);
}
コード例 #6
0
ファイル: delay_tests.c プロジェクト: brridder/ECE354-RTOS
void test1()
{
    void* message_1;
    void* message_2;
    void* message_3;
    void* message_4;
    void* message_5;
    void* message_6;

    printf_0(GID"_test: START\r\n"GID"_test: total 6 tests\r\n");

    message_1 = g_test_fixture.request_memory_block();
    delayed_send(2, message_1, 2);

    message_2 = g_test_fixture.request_memory_block();
    delayed_send(2, message_2, 100);

    message_3 = g_test_fixture.request_memory_block();
    delayed_send(2, message_3, 1000);

    message_4 = g_test_fixture.request_memory_block();
    delayed_send(2, message_4, 2000);

    message_5 = g_test_fixture.request_memory_block();
    delayed_send(2, message_5, 500);

    message_6 = g_test_fixture.request_memory_block();
    delayed_send(2, message_6, 1);

    while (1) {
        g_test_fixture.release_processor();
    }
}
コード例 #7
0
/**
 * @brief: a process that prints 2x5 lowercase letters
 */
void proc1(void)
{
	int i = 0;
	int j;
	int counter = 0;
	int ret_val = 100;
	char *c;
	void *mem;
	MSG_BUF *msg;
	MSG_BUF *msg2;
	
	while ( 1 ) {
		
		if (i == 5) {
			msg = (MSG_BUF *)request_memory_block();
			strcpy(msg->mtext, "%Z");
			msg->mtype = DEFAULT;
			msg2 = (MSG_BUF *)request_memory_block();
			strcpy(msg2->mtext, "%C 9 2");
			msg2->mtype = DEFAULT;
			send_message(PID_A, msg);
			delayed_send(PID_SET_PRIO, msg2, ONE_SECOND*25);
		}
		
		if ( i != 0 && i%5 == 0 ) {
			uart0_put_string("\n\r");
			counter++;
			if ( counter == 4 ) {
				//ret_val = set_process_priority(PID_P2, HIGH);
				break;
			} else {
				ret_val = release_processor();
			}
#ifdef DEBUG_0
			printf("proc1: ret_val = %d \n", ret_val);
#endif /* DEBUG_0 */
		}
		
		uart0_put_char('a' + i%10);
		i++;
	}
	c = "proc1 end of testing\n\r";
	uart0_put_string(c);
	while ( 1 ) {
		release_processor();
	}
}
コード例 #8
0
ファイル: usr_proc.c プロジェクト: JMtorii/SE-350-Lab
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();
	}
}
コード例 #9
0
ファイル: test_procs_p2.c プロジェクト: hjarmstrong/se350-1
//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();
    }
}
コード例 #10
0
message_id local_actor::timed_sync_send_tuple_impl(message_priority mp,
                                                   const actor& dest,
                                                   const duration& rtime,
                                                   message&& what) {
  if (!dest) {
    throw std::invalid_argument(
      "cannot send synchronous message "
      "to invalid_actor");
  }
  auto nri = new_request_id();
  if (mp == message_priority::high) {
    nri = nri.with_high_priority();
  }
  dest->enqueue(address(), nri, std::move(what), host());
  auto rri = nri.response_id();
  auto sched_cd = detail::singletons::get_scheduling_coordinator();
  sched_cd->delayed_send(rtime, address(), this, rri,
                         make_message(sync_timeout_msg{}));
  return rri;
}
コード例 #11
0
ファイル: test_procs_p2.c プロジェクト: hjarmstrong/se350-1
//Test 2 (delayed send does not block), and
//Test 3 (delayed recieve occurs after correct amount of time)
void proc3(void) {
    int pid = 3;
    msgbuf *msg;
    int start_time;
    int end_time;
    
    //create message
    msg = request_memory_block();
    msg->mtype = DEFAULT;
    msg->mtext[0] = MSG_TEXT_1;
    
    //check time
    start_time = get_time();
    
    //send with delay
    delayed_send(pid, msg, DELAY);
    
    test_status[1] = TEST_SUCCESS;//TEST 2: Send does not block 
    //(if it did, we wouldn't reach this line because this process is sending the message to itself)
    
    receive_message(&pid);//don't need to store, because we have the original. Just checking the timing.
    
    //check time
    end_time = get_time();
    //mark test 3 passed if it is late enough, otherwise make it failed
    if (end_time >= start_time + DELAY){
        test_status[2] = TEST_SUCCESS;//TEST 3: delayed message recieved after the appropriate delay
    } else {
        test_status[2] = TEST_FAILURE;//message recieved too soon
    }
    
    //release message memory
    release_memory_block(msg);

    //Done testing
    set_process_priority(pid, LOWEST);

    while (1) {
        release_processor();
    }
}
コード例 #12
0
ファイル: cppa.hpp プロジェクト: nctusdk/libcppa
inline void delayed_reply(const std::chrono::duration<Rep, Period>& rel_time,
                          Args&&... what) {
    delayed_send(self->last_sender(), rel_time, std::forward<Args>(what)...);
}
コード例 #13
0
ファイル: k_sys_proc.c プロジェクト: Scourae/SE350-RTX
void wall_clock_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 = WALL_CLOCK_PID;
	msg->destination_pid = KCD_PID;
	set_message(msg, "%WR" + '\0', 4*sizeof(char));
	send_message(KCD_PID, msg);		
		
	msg = (ENVELOPE *)request_memory_block();
	msg->sender_pid = WALL_CLOCK_PID;
	msg->destination_pid = KCD_PID;
	msg->message_type = MSG_COMMAND_REGISTRATION;
	set_message(msg, "%WS" + '\0', 4*sizeof(char));
	send_message(KCD_PID, msg);	
	
	msg = (ENVELOPE *)request_memory_block();
	msg->sender_pid = WALL_CLOCK_PID;
	msg->destination_pid = KCD_PID;
	msg->message_type = MSG_COMMAND_REGISTRATION;
	set_message(msg, "%WT" + '\0', 4*sizeof(char));
	send_message(KCD_PID, msg);	

	while(1){

		ENVELOPE * rec_msg= (ENVELOPE*) receive_message(NULL);
		char * char_message = (char *) rec_msg->message;
		if(rec_msg->message_type == MSG_WALL_CLOCK && 
			rec_msg->sender_pid == WALL_CLOCK_PID && show_wclock ==1) {
			int curr_time = 0;
			int s1, s2, m1, m2, h1, h2;
			
			ENVELOPE * delay_msg = (ENVELOPE*) request_memory_block();
				
			ENVELOPE * w_clock = (ENVELOPE*) request_memory_block();
			w_clock->sender_pid = WALL_CLOCK_PID;
			w_clock->destination_pid = CRT_PID;
			w_clock->message_type = MSG_CRT_DISPLAY;

			curr_time = g_timer_count - elapsed + base;
			w_secs= (curr_time /1000)%60;
					s2=w_secs%10;
				s1=w_secs/10;
			w_mins = (curr_time/(60000))%60;
				m2=w_mins%10;
				m1=w_mins/10;
			w_hours= (curr_time/(3600000))%24;
				h2=w_hours%10;
			h1=w_hours/10;
			w_clock->message = w_clock + HEADER_OFFSET;
			sprintf(w_clock->message, "%d%d:%d%d:%d%d\n\r", h1,h2,m1,m2,s1,s2); 

			send_message(CRT_PID, w_clock);
				
	
				delay_msg->message_type=MSG_WALL_CLOCK;			
				delay_msg->sender_pid=WALL_CLOCK_PID;
				delay_msg->destination_pid=WALL_CLOCK_PID;
				delay_msg->message=NULL;
				delayed_send(WALL_CLOCK_PID, delay_msg, 1000);
		}
		else {
			if (char_message[2]== 'R') {
				ENVELOPE *msg =(ENVELOPE *) request_memory_block();
				msg->message_type=MSG_WALL_CLOCK;			
				msg->sender_pid=WALL_CLOCK_PID;
				msg->destination_pid=WALL_CLOCK_PID;
				msg->message=NULL;

				w_secs=0;
				w_mins=0;
				w_hours=0;

				base = 0;
				elapsed = g_timer_count;
				if (show_wclock == 0){
					show_wclock = 1;
					send_message(WALL_CLOCK_PID, msg);
				}
			}
			if (char_message[2]== 'S') {
				if ((char_message[4] >= '0')&&(char_message[4] <= '9')&&(char_message[5] >= '0')&&(char_message[5] <= '9')&&(char_message[6] == ':')
					&&(char_message[7] >= '0')&&(char_message[7] <= '9')&&(char_message[8] >= '0')&&(char_message[8] <= '9')&&(char_message[9] == ':')
					&&(char_message[10] >= '0')&&(char_message[10] <= '9')&&(char_message[11] >= '0')&&(char_message[11] <= '9')
					&&((char_message[12] == ' ')||(char_message[12] == '\0')))
				{
				
					int h1,h2,m1,m2,s1,s2;			 
					ENVELOPE *msg =(ENVELOPE *) request_memory_block();
					msg->message_type=MSG_WALL_CLOCK;			
					msg->sender_pid=WALL_CLOCK_PID;
					msg->destination_pid=WALL_CLOCK_PID;
					msg->message=NULL;
					
					h1=char_message[4] - '0';
					h2=char_message[5] - '0';

					w_hours=h1*10 + h2;

					m1=char_message[7] - '0';
					m2=char_message[8] - '0';

					w_mins=m1*10 + m2;

					s1=char_message[10] - '0';
					s2=char_message[11] - '0';

					w_secs= s1*10 + s2;

					elapsed = g_timer_count;
					base = ((w_hours * 3600) + (w_mins * 60) + w_secs) * 1000;
					if (show_wclock == 0){
						show_wclock = 1;
						send_message(WALL_CLOCK_PID, msg);
					}
				}
			}
			else if (char_message[2]== 'T') {
				show_wclock=0;
			}
		}
		release_memory_block(rec_msg);
	}//end while
}
コード例 #14
0
void stress_c() {
	#ifdef _STRESS_DEBUG
	rtx_dbug_outs("Initializing: Stress Test C\r\n");
	#endif
	
	msgq_head = NULL;
	msgq_tail = NULL;
	
	struct num_message * msg_rx;
	struct num_message * msg_wake;
	struct MessageEnvelope * proc_c;
	struct num_message * hibernate;
		
	while(1) {
		#ifdef _STRESS_DEBUG
		rtx_dbug_outs("Enter: Stress Test C\r\n");
		#endif
		
		if(msgq_head == NULL) {
			// receive message
			msg_rx = (num_message *)receive_message(NULL);

			#ifdef _STRESS_DEBUG
			rtx_dbug_outs("Stress Test C received a message\r\n");
			#endif
		} else {
			// dequeue first message from local message queue
			msg_rx = msgq_head->env;
			msgq_head = msgq_head->next;

			if(msgq_head == NULL) {
				msgq_tail = NULL;
			}
			
			#ifdef _STRESS_DEBUG
			rtx_dbug_outs("Stress Test C dequeued a message\r\n");
			#endif
		}
		
		UINT32 type = msg_rx->type;
		UINT32 msg_data = msg_rx->msg;
		release_memory_block((void *)msg_rx);
		
		if(type == TYPE_COUNT_REPORT) {
			#ifdef _STRESS_DEBUG
			rtx_dbug_outs_int("Stress Test C got message ", msg_rx->msg);
			#endif
			
			if(msg_data%20 == 0) {
				proc_c = (MessageEnvelope *)request_memory_block();
				str_copy((BYTE *) "Process C\r\n", (BYTE *)proc_c->msg);
				send_message(CRT_PID, proc_c);

				#ifdef _STRESS_DEBUG
				rtx_dbug_outs("Stress Test C sent a message to CRT\r\n");
				#endif

				// hibernate for 10 seconds
				hibernate = (num_message *)request_memory_block();
				hibernate->type = TYPE_WAKEUP10;
				delayed_send(STRESS_C_PID, hibernate, 10000);
				
				while(1) {
					msg_wake = (num_message *)receive_message(NULL);
					if(msg_wake->type == TYPE_WAKEUP10) {
						break;
					} else {
						// enqueue the message into local queue
						enqueue_local_msg(msg_wake);
					}
				}
			}
		}
		
		release_memory_block((void *)hibernate);
		release_processor();
	}
}
コード例 #15
0
ファイル: k_sys_proc.c プロジェクト: secXsQuared/SE350
void clock_process()
{
    int sender, parsed_length, d1, d2;
		char* parsed_msg, *pointer;
    MSG_BUF *crtMessage;
    MSG_BUF *each_msg, *msg_buf = (MSG_BUF*)request_memory_block();
    msg_buf->mtype = MSG_CLOCK_NOTIFICATION;
		reg_msg.mtype = MSG_KCD_REG;
		strcpy(reg_msg.mtext,"%W");
		send_message(PID_KCD, &reg_msg);
    delayed_send(PID_CLOCK ,msg_buf,1000);
    while(1)
    {
        each_msg = receive_message(&sender);

        switch (each_msg->mtype)
        {
            case MSG_CLOCK_NOTIFICATION:
            {
                second++;
                if(second % 60 == 0 && second > 0)
                {
                    minute += second / 60;
									second = second % 60;
                    if(minute % 60 == 0 && minute > 0)
                    {
											 hour += minute / 60;
                        minute = minute % 60;      
										}              
								}
                if(display == 1)
                {
                    crtMessage = (MSG_BUF*)request_memory_block();
										crtMessage->mtype= MSG_CRT_DISPLAY;
										pointer = (char*)crtMessage->mtext;
										if(hour < 10)
										{
												k_sprintf(pointer, "0%d:", hour);
										}
										else
										{
												k_sprintf(pointer, "%d:", hour);
										}
										pointer = _next_null_pos(pointer);
																				if(minute < 10)
										{
												k_sprintf(pointer, "0%d:", minute);
										}
										else
										{
												k_sprintf(pointer, "%d:", minute);
										}
										pointer = _next_null_pos(pointer);
										
										
										if(second < 10)
										{
												k_sprintf(pointer, "0%d\n", second);
										}
										else
										{
												k_sprintf(pointer, "%d\n", second);
										}
                    send_message(PID_CRT, crtMessage);
										release_memory_block(crtMessage);
                }
                delayed_send(PID_CLOCK ,msg_buf,1000);
                break;
            }
            case MSG_DEFAULT:
            {
								parsed_msg = (char*)each_msg->mtext;
								parsed_length = str_len(parsed_msg);
								if(parsed_length < 3)
									break;
								if(parsed_msg[2] == 'S')
								{
									hour = 0;
									minute = 0;
									second = 0;
									display = 1;
								}
								else if(parsed_msg[2] == 'R' && parsed_length == 12 && parsed_msg[3] == ' ' && parsed_msg[6] == ':' && parsed_msg[9] == ':')
								{
									d1 = charToInt(parsed_msg[4]);
									if(d1 < 0)
										break;
									d2 = charToInt(parsed_msg[5]);
									if(d2 < 0)
										break;
									
									hour = d1*10 + d2;
									
									d1 = charToInt(parsed_msg[7]);
									if(d1 < 0)
										break;
									d2 = charToInt(parsed_msg[8]);
									if(d2 < 0)
										break;
									minute = d1*10 + d2;
									
									
									d1 = charToInt(parsed_msg[10]);
									if(d1 < 0)
										break;
									d2 = charToInt(parsed_msg[11]);
									if(d2 < 0)
										break;
									second = d1*10 + d2;
									display = 1;
								}
								else if(parsed_msg[2] == 'T')
								{
									display = 0;
								}
                break;
            }
            default:
                break;
        }
    }
}
コード例 #16
0
void wall_clock()
{

  { // Register the command.
    Mail* envelop = (Mail*)request_memory_block();
    RegisteredCommand* rc = (RegisteredCommand*)(((char*)envelop)+64);
    RegisteredCommand_construct(rc,'W', WALL_CLOCK_PID, WALL_CLOCK_CHANGE_MSG_TYPE);
    envelop->m_messageType = COMMAND_REGISTRATION_MSG_TYPE;

    send_message(KEYBOARD_DECODER_PROCESS_PID, envelop);
	//rtx_dbug_outs((CHAR *)"<=========register command complete");
  }

  Mail* secMail = (Mail*)request_memory_block();
  Mail* crtMessage = (Mail*)request_memory_block();
  secMail->m_messageType = WALL_CLOCK_NEXT_SECOND_MSG_TYPE;
  delayed_send(WALL_CLOCK_PID, secMail, 1000);
  //rtx_dbug_outs((CHAR *)"<=========delay send complete");

  // Start the wall clock.
  int currentTime = -1;
  while (TRUE)
  {
    int senderId;
	  
    secMail = (Mail*)receive_message(&senderId);
	
	    //rtx_dbug_outs((CHAR *)"received message! \r\n");
	
    char* msg = ((char*)secMail)+64;

    if (secMail->m_messageType == WALL_CLOCK_CHANGE_MSG_TYPE)
    {
	  // Parse the message.
      char type = msg[2];

      if (type == 'T')
      {
        currentTime = -1;
      }
      else if (type == 'S')
      {
        // Set wall clock
        // %WS HH:MM:SS
        currentTime = parse_to_sec(msg);
		
	    //rtx_dbug_outs((CHAR *)"clock set");
		//rtx_dbug_out_number(currentTime);
      }
	  
	  release_memory_block(secMail);
	  continue;
    }
    else if (secMail->m_messageType == WALL_CLOCK_NEXT_SECOND_MSG_TYPE)
    {
	  //rtx_dbug_outs((CHAR *)"clock add second\r\n");
      if (currentTime != -1){
        currentTime += 1;
		//rtx_dbug_outs((CHAR *)"clock add second\r\n");
		if (currentTime == 24*60*60){
		  currentTime = 0;
		}
      }
    }
	else {
		//rtx_dbug_outs((CHAR *)"BAD BAD\r\n");
	}

    char* data = ((char*)crtMessage)+64;
    if (currentTime != -1){
      parse_to_display(&currentTime, data);
      data[10] = '\0';
    }
    else {
	  data[0] = '\0';
    }
	delayed_send(WALL_CLOCK_PID, secMail, 1000);

    crtMessage->m_messageType = CRT_OUTPUT_MSG_TYPE;
    send_message(CRT_DISPLAY_PID, crtMessage);
	crtMessage = (Mail*)request_memory_block();
  }
}