/*! Setup debugging output.
* This function initializes stderr stream to output on USART specified at baud rate specified.
* \param u Pointer to USART used for debug output
* \param baudctrlA Baud rate control register A
* \param baudctrlB Baud rate control register B
*/
void debugInit(struct USART_struct *u,
enum debugUsartBlock_e block,
uint8_t baudctrlA,
uint8_t baudctrlB) {
debugUsart = u;
// initialize USART
usartInitAsyncTx(u, baudctrlA, baudctrlB);
// select appropriate putchar function
if (block == DEBUG_USART_BLOCK) {
fdev_setup_stream(debug, putchar_block, NULL, _FDEV_SETUP_WRITE);
} else {
fdev_setup_stream(debug, putchar_noblock, NULL, _FDEV_SETUP_WRITE);
}
}
// Initialize uart and direct standard out and standard error to uart
void Debug::Initialize()
{
uart_init(UART_BAUD_SELECT(UART_BAUD_RATE, F_CPU));
fdev_setup_stream(&uartStream, UARTPutChar, NULL, _FDEV_SETUP_WRITE);
stdout = &uartStream;
stderr = &uartStream;
}
void
Serial_init()
{
fdev_setup_stream( &g_uartFile, uart_putchar, NULL, _FDEV_SETUP_WRITE );
Serial.begin( 9600, SERIAL_8N1 );
stdout = &g_uartFile;
}
int main(void)
{
init();
#if defined(USBCON)
USBDevice.attach();
#endif
#if defined(USE_STDOUT)
// fill in the UART file descriptor with pointer to writer.
fdev_setup_stream (&uartout, uart_putchar, NULL, _FDEV_SETUP_WRITE);
// The uart is the standard output device STDOUT.
stdout = &uartout ;
#endif
setup();
for (;;) {
loop();
if (serialEventRun) serialEventRun();
}
return 0;
}
void setup_debug() {
fdev_setup_stream(&_stderr,
simulavr_fputc,
simulavr_fgetc,
_FDEV_SETUP_WRITE | _FDEV_SETUP_READ);
stderr = &_stderr;
}
// -----------------------------------------------------------------
int main() {
// Initialize the lcd
lcd_init();
fdev_setup_stream(&lcd_stream, lcd_putchar, 0, _FDEV_SETUP_WRITE);
lcd_clear_and_home();
// initialize eeprom and TWI/I2C
eeprom_init();
// specify 7 bit device address of eeprom chip
#define EEPROM_DEVICE_ID 0b1010000
fprintf_P(&lcd_stream, PSTR("24LC256 ADDR: %02X"), EEPROM_DEVICE_ID);
// specify eeprom memory address for data storage
#define EEPROM_DATA_ADDRESS 0x0000
// create local copy of eeprom data
EEPROM_DATA e_data;
// read eeprom contents at location 0000
e_data = read_eeprom(0);
// show what we read from the eeprom -
// note: the very first read on a new eeprom
// will show uninitalized data
show_eeprom_data(&e_data);
// process data
if(e_data.need_initalization){
// set all data item values if first time
e_data.need_initalization = false;
strcpy_P(e_data.author, PSTR("Noter"));
e_data.read_count = 1;
e_data.brightness = 0x33;
e_data.version = 1.01;
} else {
// check contents against the values written when initializing
if((e_data.version != 1.01)||
(strcmp_P(e_data.author, PSTR("Noter")) !=0)||
(e_data.brightness != 0x33)){
lcd_line_four();
fprintf_P(&lcd_stream, PSTR("DATA ERROR - "));
while(true); // and freeze
} else {
// increment read_count
e_data.read_count += 1;
}
}
// write data to eeprom memory at location 0000
write_eeprom(0, &e_data);
// and show the read count
lcd_line_two();
fprintf_P(&lcd_stream, PSTR("READ COUNT = %d"), e_data.read_count);
// done
while(true);
}
void comms_setup()
{
// set up stdio write redirect to comms_putchar
fdev_setup_stream(&comms_putchar_file, &comms_putchar, NULL, _FDEV_SETUP_WRITE);
stdout = &comms_putchar_file;
// set up comms stream
comms_stream_setup(&payload_stream, payload_tx_fifo_buffer, PAYLOAD_TX_FIFO_LENGTH, payload_rx_fifo_buffer, PAYLOAD_RX_FIFO_LENGTH, payload_command_bytes, PAYLOAD_COMMAND_BYTES_MAX_LENGTH);
}
int16_t Print::printf(const __FlashStringHelper *format, ...)
{
FILE f;
va_list ap;
fdev_setup_stream(&f, printf_putchar, NULL, _FDEV_SETUP_WRITE);
fdev_set_udata(&f, this);
va_start(ap, format);
return vfprintf_P(&f, (const char *)format, ap);
}
/**
* sets up the necessary pointers
*
* \warning Must be called before all printf statements!
*
* \param baud Baudrate for the communication (see Serial.begin())
*/
extern "C" void uartInit(long baud) {
// Start the UART
Serial.begin(baud);
// fill in the UART file descriptor with pointer to writer.
fdev_setup_stream(&uartout, uart_putchar, NULL, _FDEV_SETUP_WRITE);
// The uart is the standard output device STDOUT.
stdout = &uartout;
}
void hal_printf_init() {
// create a FILE structure to reference our UART output function
static FILE uartout;
memset(&uartout, 0, sizeof(uartout));
// fill in the UART file descriptor with pointer to writer.
fdev_setup_stream (&uartout, uart_putchar, NULL, _FDEV_SETUP_WRITE);
// The uart is the standard output device STDOUT.
stdout = &uartout ;
}
void init_stdout()
{
/* Create a persistent FILE object. */
static FILE myStdout;
/* By default stdout, the pointer to the FILE object to use, is null, i.e. no standard
out is available. We let it point to our persistent FILE object. */
stdout = &myStdout;
/* Initialize our FILE object ans associate it (and thus stdout) with the charater
write function, which will write the character into Serial. */
fdev_setup_stream (&myStdout, serial_putchar, NULL, _FDEV_SETUP_WRITE);
} /* End of init_stdout */
template<> OS_PROCESS void TDebugProc::exec()
{
const timeout_t sleep_time = 200;
const uint8_t report_period = 1000 / sleep_time;
const uint32_t baud = 115200UL;
const uint32_t divider = (F_CPU + 8 * baud) / (16 * baud) - 1;
UCSR0B = 0;
UCSR0A = 0;
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
UBRR0H = divider >> 8;
UBRR0L = divider;
UCSR0B = (1 << RXEN0) | (1 << TXEN0);
FILE uart_file;
fdev_setup_stream( &uart_file, uart_putc, NULL, _FDEV_SETUP_WRITE);
stdout = &uart_file;
// Reset VT100 properties, clear screen and go home, print sample header
printf_P(PSTR("\x1B" "c" "\x1B[2J" "\tscmRTOS: 4-Debug sample\n" "Prio "));
for(uint8_t i = 0; i < OS::PROCESS_COUNT; i++) {
printf_P(PSTR("%7s"), get_prio_name(i));
}
for (;;) {
uint8_t report_div = report_period;
do {
sleep(sleep_time);
} while(--report_div);
profiler.process_data();
// Go to 3'd line, clear to end of screen and print statistics
printf_P(PSTR("\x1B[3;1H" "\x1B[J" "Stack"));
for(uint8_t i = 0; i < OS::PROCESS_COUNT; i++) {
unsigned stack = OS::get_proc(i)->stack_slack() * sizeof(stack_item_t);
printf_P(PSTR("%7u"), stack);
}
printf_P(PSTR("\nCPU %%"));
for(uint8_t i = 0; i < OS::PROCESS_COUNT; i++) {
unsigned cpu = profiler.get_result(i);
printf_P(PSTR("%4u.%02u"), cpu/100, cpu%100);
}
}
} // TProc4::exec()
void init(void) {
clock_prescale_set(clock_div_2); // we run at 3.3v
fdev_setup_stream(&mystdout, uart_putchar, NULL, _FDEV_SETUP_WRITE);
stdout = &mystdout;
usb_init();
MRF_RESET_CONFIG;
MRF_CS_CONFIG;
SPI_MasterInit();
// interrupt pin from mrf
EIMSK |= (1<<INT0);
while (!usb_configured()) {
}
// Advised to wait a bit longer by pjrc.com
// as not all drivers will be ready even after host is up
_delay_ms(500);
}
/* === functions =========================================================== */
int buffer_stream_init( buffer_stream_t *pbs,
void (*incb)(buffer_t *pbuf),
void (*outcb)(buffer_t *pbuf))
{
FILE *f;
f = &(pbs->bstream);
pbs->pbufin = NULL;
pbs->pbufout = NULL;
pbs->incb = incb;
pbs->outcb = outcb;
fdev_setup_stream ( f,
buffer_stream_putchar,
buffer_stream_getchar,
_FDEV_SETUP_RW);
fdev_set_udata(f, pbs);
return 0;
}
void serial_stdout_init (long speed) {
/* Set baud rate */
uint16_t factor = (F_CPU / 16 + speed / 2) / speed – 1;
UBRR0H = factor >> 8;
UBRR0L = factor;
/* Set format (8N1) */
UCSR0C = 3 << UCSZ00;
/* Enable transmitter */
UCSR0B = _BV(TXEN0);
/* Set up stdout to write to the serial port */
/* stdout = fdevopen (serial_write, NULL); replaced with the following care of DH */
fdev_setup_stream(&sio_stdout, serial_write, NULL,_FDEV_SETUP_WRITE);
stdout = &sio_stdout ;
}
void *
ttyopen(struct devsw *devptr)
{
struct tty *iptr = &tty[devptr->dvminor];
FILE *streamPtr;
if ( (streamPtr = (FILE *)calloc(1,sizeof(FILE)) ) == (FILE *)NULL )
return 0;
fdev_setup_stream(streamPtr, stdPut, stdGet, _FDEV_SETUP_RW);
fdev_set_udata(streamPtr, (void *)iptr); /* Set user defined and accessible pointer */
stdout = streamPtr;
// if (strcmp(name, "stdout") == 0)
// stdout = streamPtr; /* stdout is a macro */
// else if (strcmp(name, "stdin") == 0)
// stdin = streamPtr;
// else if (strcmp(name, "stderr") == 0)
// stderr = streamPtr;
return (void *)streamPtr;
}
void Lcd::init(void)
{
font = 0;
fdev_setup_stream(&lcdf, (int (*)(char, FILE*)) &lcd.lcdPut, NULL, _FDEV_SETUP_WRITE);
spiMasterInit();
CLR_SCE;
CLR_RST;
_delay_ms(100);
SET_RST;
SET_SCE;
command(0x21); // Switch to extended instruction set.
command(0xbf); // Set VOP.
command(0x04); // Set temperature coefficient.
command(0x14); // Set bias.
command(0x20); // Switch to basic instruction set.
command(0x0c); // Set normal display mode.
clear();
sync();
}
void term_redirect_putchar(terminal_t* term) {
term_redirected = term;
fdev_setup_stream(stdout, term_putchar_wrapper, NULL, _FDEV_SETUP_WRITE);
//stdout = &mystdout;
}
void web::ProcessWebClients()
{
// listen for incoming clients
EthernetClient client = m_server->available();
if (client)
{
bool bReset = false;
#ifdef ARDUINO
FILE stream_file;
FILE * pFile = &stream_file;
setup_sendbuf();
fdev_setup_stream(pFile, stream_putchar, NULL, _FDEV_SETUP_WRITE);
stream_file.udata = &client;
#else
FILE * pFile = fdopen(client.GetSocket(), "w");
#endif
freeMemory();
trace(F("Got a client\n"));
//ShowSockStatus();
KVPairs key_value_pairs;
char sPage[35];
if (!ParseHTTPHeader(client, &key_value_pairs, sPage, sizeof(sPage)))
{
trace(F("ERROR!\n"));
ServeError(pFile);
}
else
{
trace(F("Page:%s\n"), sPage);
//ShowSockStatus();
if (strcmp(sPage, "bin/setSched") == 0)
{
if (SetSchedule(key_value_pairs))
{
if (GetRunSchedules())
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/setZones") == 0)
{
if (SetZones(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/delSched") == 0)
{
if (DeleteSchedule(key_value_pairs))
{
if (GetRunSchedules())
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/setQSched") == 0)
{
if (SetQSched(key_value_pairs))
{
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/settings") == 0)
{
if (SetSettings(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/manual") == 0)
{
if (ManualZone(key_value_pairs))
{
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/run") == 0)
{
if (RunSchedules(key_value_pairs))
{
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else
ServeError(pFile);
}
else if (strcmp(sPage, "bin/factory") == 0)
{
ResetEEPROM();
ReloadEvents();
ServeHeader(pFile, 200, "OK", false);
}
else if (strcmp(sPage, "bin/reset") == 0)
{
ServeHeader(pFile, 200, "OK", false);
bReset = true;
}
else if (strcmp(sPage, "json/schedules") == 0)
{
JSONSchedules(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/zones") == 0)
{
JSONZones(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/settings") == 0)
{
JSONSettings(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/state") == 0)
{
JSONState(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/schedule") == 0)
{
JSONSchedule(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/wcheck") == 0)
{
JSONwCheck(key_value_pairs, pFile);
}
#ifdef LOGGING
else if (strcmp(sPage, "json/logs") == 0)
{
JSONLogs(key_value_pairs, pFile);
}
else if (strcmp(sPage, "json/tlogs") == 0)
{
JSONtLogs(key_value_pairs, pFile);
}
#endif
else if (strcmp(sPage, "ShowSched") == 0)
{
freeMemory();
ServeSchedPage(pFile);
}
else if (strcmp(sPage, "ShowZones") == 0)
{
freeMemory();
ServeZonesPage(pFile);
}
else if (strcmp(sPage, "ShowEvent") == 0)
{
ServeEventPage(pFile);
}
else if (strcmp(sPage, "ReloadEvent") == 0)
{
ReloadEvents(true);
ServeEventPage(pFile);
}
else
{
if (strlen(sPage) == 0)
strcpy(sPage, "index.htm");
// prepend path
memmove(sPage + 5, sPage, sizeof(sPage) - 5);
memcpy(sPage, "/web/", 5);
sPage[sizeof(sPage)-1] = 0;
trace(F("Serving Page: %s\n"), sPage);
SdFile theFile;
if (!theFile.open(sPage, O_READ))
Serve404(pFile);
else
{
if (theFile.isFile())
ServeFile(pFile, sPage, theFile, client);
else
Serve404(pFile);
theFile.close();
}
}
}
#ifdef ARDUINO
flush_sendbuf(client);
// give the web browser time to receive the data
delay(1);
#else
fflush(pFile);
fclose(pFile);
#endif
// close the connection:
client.stop();
if (bReset)
sysreset();
}
}
FILE *uart0FOpen(uint32_t baud) {
uart0Open(baud);
fdev_setup_stream(&ttyUART0, uart0PutCharStd, uart0GetCharStd, _FDEV_SETUP_RW);
return &ttyUART0;
}
/* ------------------------------------------------------------------------- */
bool usart_init(uint8_t device_num, baud_rate_t baudrate, usart_parity_t parity, uint8_t xbuf_size, uint8_t rbuf_size) {
bool rtcode = false;
usart_t *pusart;
uint16_t ubbr;
uint8_t u2xn;
assert ((parity==PARITY_NONE) || (parity==PARITY_EVEN) || (parity==PARITY_ODD));
assert ((baudrate==BAUD_115200) || (baudrate==BAUD_57600) || (baudrate==BAUD_38400) || (baudrate==BAUD_19200) || (baudrate==BAUD_9600));
assert (device_num <= USARTS_NUM - 1);
switch (baudrate) {
case BAUD_9600: // intentional fall through
case BAUD_19200: // intentional fall through
case BAUD_38400:
u2xn = 0;
ubbr = (uint16_t) ((F_CPU * 10)/(baudrate * 16));
if ((ubbr % 10) >= 5) ubbr += 10; // rounding
ubbr = (ubbr/10) - 1;
rtcode = true;
break;
case BAUD_57600:
#if F_CPU==8000000
u2xn = 0x02;
ubbr = 16;
rtcode = true;
#elif F_CPU==16000000
u2xn = 0x02;
ubbr = 34;
rtcode = true;
#endif
break;
case BAUD_115200:
#if F_CPU==16000000
u2xn = 0x02;
ubbr = 16;
rtcode = true;
#endif
break;
}
if (rtcode == true) {
uart_xmt_interrupt_disable(device_num);
uart_rcv_interrupt_disable(device_num);
pusart = &usarts[device_num];
pusart->device_num = device_num;
pusart->baudrate = baudrate;
pusart->pxbuf = &(pusart->xmt_buf);
pusart->prbuf = &(pusart->rcv_buf);
circbuf_create(pusart->pxbuf,xbuf_size); // add space in circular buffer
circbuf_create(pusart->prbuf,rbuf_size);
pusart->stream = &(pusart->file);
pusart->read_blocking = true;
pusart->read_echo = false;
fdev_setup_stream(pusart->stream, uart_putchar, uart_getchar, _FDEV_SETUP_RW);
// need an entry for each device for macro expansion
switch (device_num) {
#if DEV_CLASS_1 || DEV_CLASS_2
case 0:
SET_UCSRA(0, u2xn);
SET_UCSRB(0, (1<<RXEN0) | (1<<TXEN0));
SET_UCSRC(0, (1<<UCSZ00) | (1<<UCSZ01) | parity); // 8 bit, 1 stop bit
SET_UBRRH(0, (ubbr >> 8)); // baud rate upper byte
SET_UBRRL(0, (ubbr)); // baud rate lower byte
break;
#endif
#if DEV_CLASS_1
case 1:
SET_UCSRA(1, u2xn);
SET_UCSRB(1, (1<<RXEN1) | (1<<TXEN1));
SET_UCSRC(1, (1<<UCSZ10) | (1<<UCSZ11) | parity); // 8 bit, 1 stop bit
SET_UBRRH(1, (ubbr >> 8)); // baud rate upper byte
SET_UBRRL(1, (ubbr)); // baud rate lower byte
break;
case 2:
SET_UCSRA(2, u2xn);
SET_UCSRB(2, (1<<RXEN2) | (1<<TXEN2));
SET_UCSRC(2, (1<<UCSZ20) | (1<<UCSZ21) | parity); // 8 bit, 1 stop bit
SET_UBRRH(2, (ubbr >> 8)); // baud rate upper byte
SET_UBRRL(2, (ubbr)); // baud rate lower byte
break;
case 3:
SET_UCSRA(3, u2xn);
SET_UCSRB(3, (1<<RXEN3) | (1<<TXEN3));
SET_UCSRC(3, (1<<UCSZ30) | (1<<UCSZ31) | parity); // 8 bit, 1 stop bit
SET_UBRRH(3, (ubbr >> 8)); // baud rate upper byte
SET_UBRRL(3, (ubbr)); // baud rate lower byte
break;
#endif
}
uart_xmt_interrupt_enable(device_num);
uart_rcv_interrupt_enable(device_num);
}
