Subversion Repositories s6soc

////////////////////////////////////////////////////////////////////////////////
//
// Filename: 	doorbell2.c
//
// Project:	CMod S6 System on a Chip, ZipCPU demonstration project
//
// Purpose:	A modification to the original doorbell.c program that played
//		a doorbell sound every ten seconds.  Listening to that test is
//	... getting old.
//
//	Let's let this one do the following:
//		1. Display the time on the display (it will be impossible to
//			change the time, sadly, but we can at least display it.)
//		2. On button press ...
//			- Play the doorbell sound
//			- Display "Doorbell!\n" on the Display, clearing the
//				time
//			- Send "Doorbell\n"  to the UART, and then keeping the
//				UART silent for 30 seconds.
//		4. Send the time to the UART as well, but only once a minute.
//			(and that if the Doorbell hasn't been rung in the last
//			30 seconds ...)
//
// Creator:	Dan Gisselquist, Ph.D.
//		Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program.  (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:	GPL, v3, as defined and found on www.gnu.org,
//		http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
#include "asmstartup.h"
#include "board.h"
#include "rtcsim.h"
#include "display.h"
#include "string.h"
#include "txfns.h"
 
#include "samples.c"
 
void	zip_halt(void);
 
void	build_dpymsg(char *msg, unsigned clkval);
void	build_uartmsg(char *msg, unsigned clkval);
void	showval(int val);
 
#define	CLEAR_WATCHDOG	_sys->io_watchdog = 0
#define	TOUCH_WATCHDOG	_sys->io_watchdog = 500000
 
void entry(void) {
	register volatile IOSPACE *const sys = _sys;
	char	dpymsg[64], *dpyptr;
	char	uartmsg[160], *uartptr;
	int	newmsgtime = 0, leastmsgtime = -1, lstmsgtime = 0;
 
	CLEAR_WATCHDOG;
 
	txstr("\r\nREBOOT!\r\n");
	txstr("Scope Control = "); txval(_scope->s_ctrl);
	if (_scope->s_ctrl & WBSCOPE_STOPPED) {
		int	ln = WBSCOPE_LENGTH(_scope->s_ctrl);
		for(int i=0; i<ln; i++)
			txval(_scope->s_data);
		txval((int)_sys->io_buserr);
		txstr("\r\n\r\nEndScope\r\n");
	} else {
		txstr("\r\n");
		_scope->s_ctrl = 20;
	}
 
	dpymsg[0] = 0;
	dpyptr = dpymsg;
 
	uartmsg[0] = 0;
	build_uartmsg(uartmsg, 0);
	uartptr = uartmsg;
 
	sys->io_watchdog = 0;
	sys->io_pic = INT_CLEARPIC; // Acknowledge and turn off all interrupts
 
	sys->io_spio = 0x0f4;
	newmsgtime = sys->io_timer;
	leastmsgtime = -1;
	lstmsgtime = newmsgtime;
	while(1) {
		int	seconds, pic;
		const short	*sptr;
 
		// LED's off ... nothing to report
		sys->io_spio = 0x0f0;
 
		// Turn the audio off (initially)
		sys->io_pwm_audio = 0x0018000;
 
		// Set for one ticks per second, 80M clocks per tick
		sys->io_timer = TM_ONE_SECOND | TM_REPEAT;
 
		// We start by waiting for a doorbell
		while(((pic=sys->io_pic) & INT_BUTTON)==0) {
			TOUCH_WATCHDOG;
 
			if (pic & INT_TIMER) {// top of second
				sys->io_pic = INT_TIMER;
				rtcclock = rtcnext(rtcclock);
 
				// Turn all LED off (again)
				sys->io_spio = 0x0f0;
				if (*dpyptr == '\0') {
					// Build a message for the display
					build_dpymsg(dpymsg, rtcclock);
					dpyptr = dpymsg;
				}if(((rtcclock & 0x0ff)==0)&&(*uartptr=='\0')){
					build_uartmsg(uartmsg, rtcclock);
					uartptr = uartmsg;
 
					// Turn one LED on--top of minute
					sys->io_spio = 0x0f1;
					newmsgtime = sys->io_timer;
					lstmsgtime = -1;
					leastmsgtime = -1;
				}
			}
 
			if (*uartptr) {
				if (pic & INT_UARTTX) {
					sys->io_uart = *uartptr++;
					sys->io_spio = 0x22;
					sys->io_pic = INT_UARTTX;
 
					if (lstmsgtime != -1) {
						int tmp;
						tmp = (lstmsgtime-sys->io_timer);
						if ((leastmsgtime<0)||(tmp<leastmsgtime))
							leastmsgtime = tmp;
					} lstmsgtime = sys->io_timer;
				}
			} else {
				sys->io_spio = 0x20;
			}
			if (*dpyptr) {
				// This will take a long time.  It should be an
				// interruptable task ... but, sigh, we're not
				// there yet.
				dispchar(*dpyptr++);
				sys->io_spio = 0x44;
			} else {
				sys->io_spio = 0x40;
			} // sys->io_pic = (pic & (INT_TIMER|INT_UARTTX));
		}
 
		TOUCH_WATCHDOG;
		// DOORBELL!!!!!!
		// Set the Display message
		strcpy(dpymsg, "a[jDoorbell!");
		dpymsg[0] = 0x1b;
		dpyptr = dpymsg;
		// And the UART message / 18 characters
		uartptr = uartmsg;
		strcat(uartptr, "\r\nDoorbell!\r\n\r\n");
		uartptr = uartmsg;
 
 
		seconds = 0;
		sys->io_spio = 0x0ff; // All LED's on: we got one!
		sptr = sound_data;
		sys->io_pwm_audio = 0x0310000; // Turn on the audio
		while(sptr < &sound_data[NSAMPLE_WORDS]) {
			do {
				TOUCH_WATCHDOG;
				pic = sys->io_pic;
				if (pic & INT_TIMER) {
					sys->io_pic = INT_TIMER;
					seconds++;
					rtcclock = rtcnext(rtcclock);
				} if ((pic & INT_UARTTX)&&(*uartptr)) {
					sys->io_uart = *uartptr++;
					sys->io_pic = INT_UARTTX;
					sys->io_spio = 0x22;
				} else if (!*uartptr)
					sys->io_spio = 0x20;
				if (*dpyptr) {
				// This will take a long time.  It should be an
				// interruptable task ... but, sigh, we're not
				// there yet.
					dispchar(*dpyptr++);
					sys->io_spio = 0x45;
				} else
					sys->io_spio = 0x40;
			} while((pic & INT_AUDIO)==0);
			sys->io_pwm_audio = (*sptr++) & 0x0ffff;
			// Now, turn off the audio interrupt since it doesn't
			// reset itself ...
			sys->io_pic = INT_AUDIO;
		} sys->io_pic = INT_BUTTON;
		sys->io_spio = 0x10;
 
		TOUCH_WATCHDOG;
		// Now we wait for the end of our 30 second window
		sys->io_spio = 0x0f8;
		sys->io_pwm_audio = 0x018000; // Turn off the Audio device
		while(seconds < 30) {
			TOUCH_WATCHDOG;
			pic = sys->io_pic;
			if (pic & INT_TIMER) {
				sys->io_pic = INT_TIMER;
				seconds++;
				rtcclock = rtcnext(rtcclock);
			} if (pic & INT_BUTTON) {
				sys->io_pic = INT_BUTTON;
				seconds = 0;
			}
		} sys->io_pic = INT_BUTTON;
		TOUCH_WATCHDOG;
	}
}
 
void	build_dpymsg(char *msg, unsigned clk) {
	msg[0] = 0x1b;
	strcpy(++msg, "[jClock : ");
	msg += strlen(msg);
 
	if ((clk>>20)&0x0f)
		*msg++ |= (((clk>>20)&0x0f)+'0');
	else
		*msg++ |= ' ';
	*msg++ = (((clk>>16)&0x0f)+'0');
	*msg++ = ':';
	*msg++ = (((clk>>12)&0x0f)+'0');
	*msg++ = (((clk>> 8)&0x0f)+'0');
	*msg++ = ':';
	*msg++ = (((clk>> 4)&0x0f)+'0');
	*msg++ = (((clk    )&0x0f)+'0');
	*msg++ = 0;
}
 
void	build_uartmsg(char *msg, unsigned clk) {
	strcpy(msg, "Time: ");
	msg += strlen(msg);
	*msg++ = ((clk>>20)&0x03)+'0'; // Hrs
	*msg++ = ((clk>>16)&0x0f)+'0';
	*msg++ = ':';
	*msg++ = ((clk>>12)&0x0f)+'0'; // Mins
	*msg++ = ((clk>> 8)&0x0f)+'0';
	*msg++ = '\r';			// 11
	*msg++ = '\n';			// 12
	*msg++ = '\0';
	*msg++ = '\0';
}
 
void	showval(int val) {
	// Clear and home
	dispchar(0x1b);
	dispchar('[');
	dispchar('j');
	for(int i=28; i>=0; i-=4) {
		int ch = ((val>>i)&0x0f)+'0';
		if (ch > '9')
			ch = ch - '0'+'A'-10;
		dispchar(ch);
	}
}