void receiver() {
char data = '\0';
while(1) {
AwaitEvent(EVENT_COM2_RX, &data, sizeof(char));
AwaitEvent(EVENT_COM2_TX, &data, sizeof(char));
}
}
ScrollView::~ScrollView() {
#ifndef GRAPHICS_DISABLED
svmap_mu->Lock();
if (svmap[window_id_] != nullptr) {
svmap_mu->Unlock();
// So the event handling thread can quit.
SendMsg("destroy()");
SVEvent* sve = AwaitEvent(SVET_DESTROY);
delete sve;
svmap_mu->Lock();
svmap[window_id_] = nullptr;
svmap_mu->Unlock();
// The event handler thread for this window *must* receive the
// destroy event and set its pointer to this to nullptr before we allow
// the destructor to exit.
while (!event_handler_ended_)
Update();
} else {
svmap_mu->Unlock();
}
delete mutex_;
delete semaphore_;
delete points_;
for (int i = 0; i < SVET_COUNT; i++) {
delete event_table_[i];
}
#endif // GRAPHICS_DISABLED
}
void uart1_receiver_notifier() {
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_NOTIFIER: enters" );
int server_tid = WhoIs("uart1_receiver");
UART_request request;
int receive_buffer = 0;
FOREVER {
//Wait until there is data in UART1
//bwprintf( COM2, "F\n" );
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_NOTIFIER: waiting for data" );
AwaitEvent( UART1_RECEIVE_READY, (int) &receive_buffer );
bwdebug( DBG_SYS, UART1_RECEIVER_DEBUG_AREA, "UART1_RECEIVER_NOTIFIER: data received" );
//bwprintf( COM2, "G\n" );
//Configure the request
request.type = UART1_RECEIVE_NOTIFIER_REQUEST;
request.ch = receive_buffer;
//Send data to the server (uart1_receiver_server)
Send(server_tid, (char *) &request, sizeof(request), (char *) 0, 0);
}
}
// Shows a modal Yes/No Dialog which will return 'y' or 'n'
int ScrollView::ShowYesNoDialog(const char* msg) {
SendMsg("showYesNoDialog(\"%s\")", msg);
SVEvent* ev;
// Wait till an input event (all others are thrown away)
ev = AwaitEvent(SVET_INPUT);
int a = ev->parameter[0];
delete ev;
return a;
}
void sender() {
char data[11] = "0123456789";
int i = 0;
while(++i) {
Delay(100);
AwaitEvent(EVENT_COM2_TX, &(data[i % 10]), sizeof(char));
}
}
void clockTick() {
unsigned int time = 0;
int tid = MyTid();
while(1) {
AwaitEvent(EVENT_TIME_ELAP, NULL, 0);
time++;
bwprintf(COM2, "%d: %ds\n", tid, time);
}
}
// Shows a modal Input Dialog which can return any kind of String
char* ScrollView::ShowInputDialog(const char* msg) {
SendMsg("showInputDialog(\"%s\")", msg);
SVEvent* ev;
// wait till an input event (all others are thrown away)
ev = AwaitEvent(SVET_INPUT);
char* p = new char[strlen(ev->parameter) + 1];
strcpy(p, ev->parameter);
delete ev;
return p;
}
void notifier() {
char cs_name[] = CS_REG_NAME;
int cs_tid = WhoIs(cs_name);
assert(cs_tid >= 0, "Notifier cannot find clock server's tid");
char send[1] = "";
while (1) {
AwaitEvent(EVENT_TIME_ELAP, NULL, 0);
Send(cs_tid, send, 1, NULL, 0);
}
}
void clockNotifier()
{
// Initialize variabels
int pid = MyParentTid();
ClockReq req;
req.type = NOTIFICATION;
req.data = 0xdeadbeaf;
for (;;)
{
AwaitEvent(TIMER_EVENT);
Send(pid, &req, sizeof(req), 0, 0);
}
}
ScrollView::~ScrollView() {
if (svmap[window_id_] != NULL) {
// So the event handling thread can quit.
SendMsg("destroy()");
SVEvent* sve = AwaitEvent(SVET_DESTROY);
delete sve;
}
delete mutex_;
delete semaphore_;
delete points_;
svmap.erase(window_id_);
}
static void timernotifier_task() {
int parent = MyParentsTid();
// Enable timer device
VMEM(TIMER1_BASE + CRTL_OFFSET) &= ~ENABLE_MASK; // stop timer
VMEM(TIMER1_BASE + LDR_OFFSET) = 5080; // Corresponds to clock frequency, 10 ticks
VMEM(TIMER1_BASE + CRTL_OFFSET) |= MODE_MASK; // pre-load mode
VMEM(TIMER1_BASE + CRTL_OFFSET) |= CLKSEL_MASK; // 508Khz clock
VMEM(TIMER1_BASE + CRTL_OFFSET) |= ENABLE_MASK; // start
// Enables timer interrupt.
VMEM(VIC1 + INT_ENABLE) = 1 << TC1OI;
for (;;) {
AwaitEvent(TC1OI);
Send(parent, (char*)NULL, 0, (char*)NULL, 0);
}
}
/*
* Notifier task for the serial server -- Awaits the UART1TRANS event
*/
void notifier_uart1tx()
{
int r, tid;
char data = 't';
char dummy;
tid = WhoIs("com1");
FOREVER {
AwaitEvent(UART1TRANS);
*(uint*)(UART1_BASE+UART_INTR_OFFSET) = 0xFFFFFFFF; // clear interrupt
// DPRINTOK ("UART1 TRANSMISSION INTERRUPT.\n");
if ((*(int*)(UART1_BASE+UART_FLAG_OFFSET) & CTS_MASK) && (*(int*)(UART1_BASE+UART_FLAG_OFFSET) & TXFE_MASK)) {
*(uint*)(VIC2BASE+INTENCL_OFFSET) = UART1_MASK;
r = Send (tid, &data,1, &dummy, 1);
if (r) { *(uint*)(VIC2BASE+INTEN_OFFSET) = UART1_MASK;} // if uart1 server asked us to we turn back on interrupts
}
}
}
void display_notifier(void){
int parentTid = MyParentTid(); // since it was the clockserver that created this task
// construct the tick message hat we will send when we receive a tick
MsgClockServer tickMsg;
tickMsg.type = MSG_TICK;
tickMsg.data = 0x0;
int tickcount = 0;
FOREVER {
AwaitEvent(EVENT_TICK, NULL, 0); // enable timer interrupts and wait for a tick event
// a tick has occured, so send a tick message to the clock server; expect no reply data
tickcount++;
if(tickcount >= 10){
tickcount = 0;
Send(parentTid, (char *)&tickMsg, CLOCKSERVER_BUF_LEN, NULL, 0);
}
}
}
ScrollView::~ScrollView() {
svmap_mu->Lock();
if (svmap[window_id_] != NULL) {
svmap_mu->Unlock();
// So the event handling thread can quit.
SendMsg("destroy()");
SVEvent* sve = AwaitEvent(SVET_DESTROY);
delete sve;
svmap_mu->Lock();
svmap[window_id_] = NULL;
svmap_mu->Unlock();
// The event handler thread for this window *must* receive the
// destroy event and set its pointer to this to NULL before we allow
// the destructor to exit.
while (!event_handler_ended_)
Update();
} else {
svmap_mu->Unlock();
}
delete mutex_;
delete semaphore_;
delete points_;
}
static void tioNotifier(void) {
int serverTid = MyParentTid();
/* set baud: 2400 bps */
*((volatile unsigned int *) (UART1_BASE + UART_LCRM_OFFSET)) = 0x0;
*((volatile unsigned int *) (UART1_BASE + UART_LCRL_OFFSET)) = 0xbf;
/* disable the fifo */
volatile unsigned int *high =
(volatile unsigned int *) (UART1_BASE + UART_LCRH_OFFSET);
*high &= ~FEN_MASK;
/* initialize the tx buffer */
g_tio_tx_buffer.head = g_tio_tx_buffer.tail = 0;
g_tio_tx_buffer.buffer[0] = 0x60;
g_tio_tx_buffer.buffer[1] = 0x61;
g_tio_tx_buffer.buffer[2] = 0x60;
g_tio_tx_buffer.buffer[3] = 0xc0;
g_tio_tx_buffer.tail = 4;
/* UART registers */
volatile unsigned short *data =
(volatile unsigned short *) (UART1_BASE + UART_DATA_OFFSET);
volatile unsigned short *flags =
(volatile unsigned short *) (UART1_BASE + UART_FLAG_OFFSET);
while(!(*flags & RXFE_MASK)){
(void) *data;
}
bool txfe = false, cts = true, clear_cts = true;
while (1) {
if (g_tio_quit) {
break;
}
/* transmit data if possible */
if (txfe && clear_cts && cts && !(*flags & TXFF_MASK) &&
!(*flags & TXBUSY_MASK) && (*flags & CTS_MASK) &&
g_tio_tx_buffer.head != g_tio_tx_buffer.tail) {
*data = g_tio_tx_buffer.buffer[g_tio_tx_buffer.head];
g_tio_tx_buffer.head =
(g_tio_tx_buffer.head + 1) % TIO_TX_BUFFER_LEN;
txfe = false;
cts = false;
clear_cts = false;
}
/* Always enable receive and modem status interrupts.
* Don't need receive timeout because we aren't using FIFO.
*/
unsigned short int_flags = UARTEN_MASK | RIEN_MASK | MSIEN_MASK;
if (!txfe) {
/* Only enable transmit interrupt when we have something to send or
* we're waiting to know when the transmit buffer is empty.
*
* Use the same software interrupt trick on transmit as mio.
*/
int_flags |= TIEN_MASK;
}
*((volatile unsigned short *) (UART1_BASE + UART_CTLR_OFFSET)) =
int_flags;
AwaitEvent(INT_UART1);
unsigned short intr =
*((volatile unsigned short *) (UART1_BASE + UART_INTR_OFFSET));
if (intr & RIS_MASK) {
/* receive interrupt */
struct String str;
sinit(&str);
char c = *data;
ssettag(&str, CMD_NOTIFIER_RX);
sputc(&str, c);
Send(
serverTid,
(char *) &str, sizeof (struct String),
(char *) 0, 0
);
}
if (intr & TIS_MASK) {
/* transmit interrupt */
txfe = true;
}
if (intr & MIS_MASK) {
/* modem status interrupt */
if (*flags & CTS_MASK) {
cts = true;
} else {
clear_cts = true;
}
*((volatile unsigned short *) (UART1_BASE + UART_INTR_OFFSET)) = 1;
}
/* Software interrupt. Just clear it so we can re-evaluate the
* transmit buffer state. */
*((volatile unsigned int *)
(SOFTINT_BASE + VIC_SOFTWARE_INT_CLEAR)) = SOFTINT_POS;
}
Exit();
}
void uart1_sender_notifier() {
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: enters" );
int* uart_flags = (int *)( UART1_BASE + UART_FLAG_OFFSET );
int* uart_data = (int *)( UART1_BASE + UART_DATA_OFFSET );
int* modem_ctrl = (int *)( UART1_BASE + UART_MDMCTL_OFFSET);
int* modem_status = (int *)( UART1_BASE + UART_MDMSTS_OFFSET);
int uart_flags_temp = 0;
int modem_ctrl_temp = 0;
int modem_status_temp = 0;
int sender_tid;
UART_request request;
//State machine variables
//CTS states:
// 0 - CTS is set to '1' before the character is sent
// 1 - CTS is set to '0' after the character is sent
// 2 - CTS is set to '1' after the character is sent
int cts_state = 0;
//Transmit states:
// 0 - Transmit is set to '0' right after the character is sent
// 1 - Transmit is set to '1' after the character is sent
int txfe_state = 0;
//Utility variables
int first_request = 1;
int first_iter = 1;
FOREVER {
//Get request with character from the uart1_sender_server
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Waiting for request..." );
Receive(&sender_tid, (char *) &request, sizeof(request));
//Reply, to unblock the uart1_sender_server
Reply(sender_tid, (char *) 0, 0);
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Received send request." );
//Reinitialize modem
//RTSn pin is set to low
//DTRn pin is set to low
modem_ctrl_temp = *modem_ctrl;
*modem_ctrl = modem_ctrl_temp | 3;
//Initialize the state machine
cts_state = 0;
txfe_state = 0;
first_iter = 1;
FOREVER {
//*uart_data = 'b';
//Wait until UART1 is ready to receive a character
if(txfe_state == 0 || first_iter) {
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Waiting for INIT event." );
AwaitEvent(UART1_INIT_SEND, 0);
}
else {
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Waiting for SEND READY event." );
AwaitEvent(UART1_SEND_READY, 0);
}
//*uart_data = 'd';
first_iter = 0;
//txfe_state = 1;
//*uart_data = 'e';
modem_status_temp = *modem_status;
uart_flags_temp = *uart_flags;
//Changing state of the state machine////////////////////
// bwprintf( COM2, "STATE00: CTS: %d TXFE: %d\n", cts_state, txfe_state );
//IF CTS value has changed
//AND CTS value is now set to '1'
//THEN CTS has been reasserted
if( ((modem_status_temp & DCTS_MASK) || first_request)
&& (uart_flags_temp & CTS_MASK)) {
cts_state = 2;
// bwprintf( COM2, "STATE03: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF CTS value is set to '0'
//THEN CTS has been deasserted
if( cts_state == 0 && !(uart_flags_temp & CTS_MASK) ) {
cts_state = 1;
// bwprintf( COM2, "STATE02: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF CTS has been deasserted
//AND CTS value is now set to '1'
//THEN CTS has been reasserted
if( cts_state == 1 && (uart_flags_temp & CTS_MASK) ) {
cts_state = 2;
// bwprintf( COM2, "STATE04: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF transmit is set to '1'
if( (uart_flags_temp & TXFE_MASK) ) {
txfe_state = 1;
// bwprintf( COM2, "STATE01: CTS: %d TXFE: %d\n", cts_state, txfe_state );
}
//IF CTS has been reasserted
//AND Transmit has been reasserted
//THEN Send the character to UART1
if( cts_state == 2 && txfe_state == 1 ) {
*uart_data = (char) request.ch;
first_request = 0;
bwdebug( DBG_SYS, UART1_SENDER_DEBUG_AREA, "UART1_SENDER_NOTIFIER: Sending data" );
break;
}
}
}
}
static void mioNotifier(void) {
int serverTid = MyParentTid();
/* set baud: 115.2 kbps */
*((volatile unsigned int *) (UART2_BASE + UART_LCRM_OFFSET)) = 0x0;
*((volatile unsigned int *) (UART2_BASE + UART_LCRL_OFFSET)) = 0x3;
/* enable the fifo */
volatile unsigned int *high =
(volatile unsigned int *) (UART2_BASE + UART_LCRH_OFFSET);
*high |= FEN_MASK;
/* initialize the tx buffer */
g_mio_tx_buffer.head = g_mio_tx_buffer.tail = 0;
while (true) {
if (g_mio_quit) {
break;
}
/* always enable receive interrupts. FIXME: what about modem status? */
unsigned short int_flags = UARTEN_MASK | RIEN_MASK | RTIEN_MASK;
/* DANGER WILL ROBINSON: THIS CAN BREAK HORRIBLY!
*
* To prevent useless interrupts when we have nothing to send, we only
* enable the transmit interrupt when necessary. However, if transmit
* interrupts are disabled and we queue on some output, the output will
* not be flushed until the next UART interrupt (possibly the user
* typing something in).
*
* Since buffering output till the user types something is clearly
* broken, we get around this by having the server raise the UART
* interrupt in software (after loading data into g_mio_tx_buffer). This
* will eventually bring us to the top of our loop, where we'll
* re-evaluate our state and enable the transmit interrupt.
*/
if (g_mio_tx_buffer.head != g_mio_tx_buffer.tail) {
/* only enable transmit interrupt if we have stuff to send */
int_flags |= TIEN_MASK;
}
*((volatile unsigned short *) (UART2_BASE + UART_CTLR_OFFSET)) =
int_flags;
/* Wait for something to happen */
AwaitEvent(INT_UART2);
unsigned short intr =
*((volatile unsigned short *) (UART2_BASE + UART_INTR_OFFSET));
volatile unsigned short *data =
(volatile unsigned short *) (UART2_BASE + UART_DATA_OFFSET);
volatile unsigned short *flags =
(volatile unsigned short *) (UART2_BASE + UART_FLAG_OFFSET);
if (intr & (RIS_MASK | RTIS_MASK)) {
/* receive interrupt */
struct String str;
sinit(&str);
ssettag(&str, CMD_NOTIFIER_RX);
while (!(*flags & RXFE_MASK)) {
sputc(&str, *data);
}
Send(
serverTid,
(char *) &str, sizeof (struct String),
(char *) 0, 0
);
}
/* FIXME: we don't care about CTS for monitor? */
if (intr & TIS_MASK) {
/* transmit interrupt */
while (g_mio_tx_buffer.head != g_mio_tx_buffer.tail &&
!(*flags & TXFF_MASK)) {
*data = g_mio_tx_buffer.buffer[g_mio_tx_buffer.head];
g_mio_tx_buffer.head =
(g_mio_tx_buffer.head + 1) % MIO_TX_BUFFER_LEN;
}
}
/* Software interrupt. Just clear it so we can re-evaluate the
* transmit buffer state. */
*((volatile unsigned int *)
(SOFTINT_BASE + VIC_SOFTWARE_INT_CLEAR)) = SOFTINT_POS;
}
Exit();
}
void TestMap()
{
XSizeHints *hints;
XWindowAttributes attr;
Window w;
/* Create the window. */
w = XCreateSimpleWindow(display, rootWindow, 100, 100, 200, 100, 0, 0, 0);
XSelectInput(display, w, StructureNotifyMask | PropertyNotify);
/* Map the window and wait for it. */
XMapWindow(display, w);
Assert(AwaitEvent(MapNotify));
/* Unmap the window and wait for it. */
XUnmapWindow(display, w);
Assert(AwaitEvent(UnmapNotify));
/* Map the window and wait for it (again). */
XMapWindow(display, w);
Assert(AwaitEvent(MapNotify));
/* Minimize and wait. */
Minimize(w);
Assert(AwaitEvent(UnmapNotify));
/* Restore and wait. */
Unminimize(w);
Assert(AwaitEvent(MapNotify));
/* Maximize and wait. */
Maximize(w, 1, 1);
Assert(AwaitEvent(ConfigureNotify));
/* Unmaximize and wait. */
Unmaximize(w, 0, 1);
Assert(AwaitEvent(ConfigureNotify));
/* Unmaximize and wait. */
Unmaximize(w, 1, 0);
Assert(AwaitEvent(ConfigureNotify));
/* Change the size hints. */
hints = XAllocSizeHints();
hints->flags = PMinSize;
hints->min_width = 300;
hints->min_height = 200;
XSetWMNormalHints(display, w, hints);
XFree(hints);
XSync(display, False);
sleep(1);
IgnoreEvents();
XGetWindowAttributes(display, w, &attr);
Assert(attr.width == 300);
Assert(attr.height == 200);
/* Shade and wait. */
Shade(w);
Assert(AwaitEvent(UnmapNotify));
/* Maximize and wait. */
Maximize(w, 0, 1);
Assert(AwaitEvent(MapNotify));
/* Shade and wait. */
Shade(w);
Assert(AwaitEvent(UnmapNotify));
/* Unshade and wait. */
Unshade(w);
Assert(AwaitEvent(MapNotify));
/* Destroy the window. */
XDestroyWindow(display, w);
}
