/**
* Writes the given character to stdout.
* The character is casted to unsigned char.
*
* @param character The character for writing
* @return The character written as unsigned char cast to int
*
*/
int32_t putchar(int32_t character)
{
uint8_t output_char = (uint8_t)character;
#ifdef FRAMEBUFFER_H
if(!std_output)
uartPutc(output_char);
else
consoleWriteChar(output_char);
#else
uartPutc(output_char);
#endif
return (int32_t)output_char;
}
static bool appDataInd(NWK_DataInd_t *ind){
for (uint8_t i = 0; i < ind->size; i++){
uartPutc((char)ind->data[i]);
}
return true;
}
/**
* Read into a buffer from the UART.
* @param devptr UART device table entry
* @param buf buffer to read bytes into
* @param len size of the buffer
* @return count of bytes read
*/
devcall uartRead(device *devptr, void *buf, uint len)
{
int i;
uchar * buffer = buf;
for(i = 0; i < len; i++){
buffer[i] = getc(SERIAL1);
}
return OK;
#if 0
irqmask im;
int count = 0;
char c;
struct uart *uartptr;
uchar *buffer = buf;
uartptr = &uarttab[devptr->minor];
im = disable();
/* If in non-blocking mode, ensure there is */
/* enough input for the entire read request */
if ((uartptr->iflags & UART_IFLAG_NOBLOCK)
&& (semcount(uartptr->isema) < len))
{
restore(im);
return SYSERR;
}
/* Put each character into the buffer from the input buffer */
while (count < len)
{
/* If in non-blocking mode, ensure there is another byte of input */
if ((uartptr->iflags & UART_IFLAG_NOBLOCK)
&& (semcount(uartptr->isema) < 1))
{
break;
}
/* Wait for input and read character from the */
/* input buffer; Preserve the circular buffer */
wait(uartptr->isema);
c = uartptr->in[uartptr->istart];
*buffer++ = c;
uartptr->icount--;
uartptr->istart = (uartptr->istart + 1) % UART_IBLEN;
count++;
/* If echo is enabled, echo the character */
if (uartptr->iflags & UART_IFLAG_ECHO)
{
uartPutc(uartptr->dev, c);
}
}
restore(im);
return count;
#endif // if 0
}
/**
* Writes the given string to stdout.
*
* @param output_string The string for writing
* @return A non-negative number on success
*
*/
int32_t puts(const char* output_string)
{
int32_t string_length = 0;
while(output_string && *output_string)
{
#ifdef FRAMEBUFFER_H
if(!std_output)
uartPutc(*output_string++);
else
consoleWriteChar(*output_string++);
#else
uartPutc(*output_string++);
#endif
++string_length;
}
return string_length;
}
void uartSend(char* data, int len)
{
if (!isInit)
return;
while(len--)
{
uartPutc(*data++);
}
}
void uartPuts(char* string)
{
if (!isInit)
return;
while(*string)
{
uartPutc(*string++);
}
}
/**
* @ingroup uartgeneric
*
* Reads data from a UART.
*
* @param devptr
* Pointer to the device table entry for a UART.
* @param buf
* Pointer to a buffer into which to place the read data.
* @param len
* Maximum number of bytes of data to read.
*
* @return
* On success, returns the number of bytes read, which normally is @p len,
* but may be less than @p len if the UART has been set to non-blocking
* mode. Returns SYSERR on other error (currently, only if uartInit() has
* not yet been called).
*/
devcall uartRead(device *devptr, void *buf, uint len)
{
irqmask im;
struct uart *uartptr;
uint count;
uchar c;
/* Disable interrupts and get a pointer to the UART structure. */
im = disable();
uartptr = &uarttab[devptr->minor];
/* Make sure uartInit() has run. */
if (NULL == uartptr->csr)
{
restore(im);
return SYSERR;
}
/* Attempt to read each byte requested. */
for (count = 0; count < len; count++)
{
/* If the UART is in non-blocking mode, ensure there is a byte available
* in the input buffer from the lower half (interrupt handler). If not,
* return early with a short count. */
if ((uartptr->iflags & UART_IFLAG_NOBLOCK) && uartptr->icount == 0)
{
break;
} else if (uartptr->iflags & UART_IFLAG_BLOCK){
c = uartHwGetc(uartptr->csr);
((uchar*)buf)[count] = c;
// uartPutc(uartptr->dev, c);
continue;
}
/* Wait for there to be at least one byte in the input buffer from the
* lower half (interrupt handler), then remove it. */
wait(uartptr->isema);
c = uartptr->in[uartptr->istart];
((uchar*)buf)[count] = c;
uartptr->icount--;
uartptr->istart = (uartptr->istart + 1) % UART_IBLEN;
/* If the UART is in echo mode, echo the byte back to the UART. */
if (uartptr->iflags & UART_IFLAG_ECHO)
{
uartPutc(uartptr->dev, c);
}
}
/* Restore interrupts and return the number of bytes read. */
restore(im);
return count;
}
static void uartPuts (char *s) {
while (*s) {
uartPutc(*s);
s++;
}
}
static void uartPuts(char *msg)
{
uchar len = strlen(msg);
while(len--)
uartPutc(*msg++);
}
