Subversion Repositories neo430

// #################################################################################################

// #  < neo430_usart.c - Internal UARt driver functions >                                          #

// # ********************************************************************************************* #

// # BSD 3-Clause License                                                                          #

// #                                                                                               #

// # Copyright (c) 2020, Stephan Nolting. All rights reserved.                                     #

// #                                                                                               #

// # Redistribution and use in source and binary forms, with or without modification, are          #

// # permitted provided that the following conditions are met:                                     #

// #                                                                                               #

// # 1. Redistributions of source code must retain the above copyright notice, this list of        #

// #    conditions and the following disclaimer.                                                   #

// #                                                                                               #

// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #

// #    conditions and the following disclaimer in the documentation and/or other materials        #

// #    provided with the distribution.                                                            #

// #                                                                                               #

// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #

// #    endorse or promote products derived from this software without specific prior written      #

// #    permission.                                                                                #

// #                                                                                               #

// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #

// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #

// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #

// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #

// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #

// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #

// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #

// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #

// # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #

// # ********************************************************************************************* #

// # The NEO430 Processor - https://github.com/stnolting/neo430                                    #

// #################################################################################################

#include "neo430.h"

#include "neo430_uart.h"

/* ------------------------------------------------------------

 * INFO Reset UART, set the Baud rate of UART transceiver

 * INFO UART_BAUD reg (8 bit) = f_main/(prsc*desired_BAUDRATE)

 * INFO PRSC (Baud register bits 10..8):

 *  0: CLK/2

 *  1: CLK/4

 *  2: CLK/8

 *  3: CLK/64

 *  4: CLK/128

 *  5: CLK/1024

 *  6: CLK/2048

 *  7: CLK/4096

 * PARAM actual baudrate to be used

 * ------------------------------------------------------------ */

void neo430_uart_setup(uint32_t baudrate){

  // raw baud rate prescaler

  uint32_t clock = CLOCKSPEED_32bit;

  uint16_t i = 0; // BAUD rate divisor

  uint8_t p = 0; // prsc = CLK/2

  while (clock >= 2*baudrate) {

    clock -= 2*baudrate;

    i++;

  }

  // find clock prsc

  while (i >= 256) {

    if ((p == 2) || (p == 4))

      i >>= 3;

    else

      i >>= 1;

    p++;

  }

  UART_CT = 0;

  UART_CT = (1<<UART_CT_EN) | ((uint16_t)p << UART_CT_PRSC0) | (i << UART_CT_BAUD0);

}

/* ------------------------------------------------------------

 * INFO Disable UART

 * ------------------------------------------------------------ */

void neo430_uart_disable(void){

  UART_CT = 0;

}

/* ------------------------------------------------------------

 * INFO Get current UARt baud rate

 * ------------------------------------------------------------ */

uint32_t neo430_uart_get_baudrate(void) {

  // Clock speed

  uint32_t clock = CLOCKSPEED_32bit;

  // prescaler

  uint16_t prsc;

  switch ((UART_CT >> 8) & 0x0007) {

    case 0:  prsc = 2; break;

    case 1:  prsc = 4; break;

    case 2:  prsc = 8; break;

    case 3:  prsc = 64; break;

    case 4:  prsc = 128; break;

    case 5:  prsc = 1024; break;

    case 6:  prsc = 2048; break;

    case 7:  prsc = 4096; break;

    default: prsc = 0; break;

  }

  uint16_t baud = UART_CT & 0x00FF;

  uint32_t baud_value = clock / (uint32_t)(prsc * baud);

  return baud_value;

}

/* ------------------------------------------------------------

 * INFO Send single char via internal UART

 * PARAM c char to send

 * ------------------------------------------------------------ */

void neo430_uart_putc(char c){

  // wait for previous transfer to finish

  while ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0);

  UART_RTX = (uint16_t)c;

}

/* ------------------------------------------------------------

 * INFO Read single char from internal UART (wait until data available)

 * INFO This function is blocking!

 * RETURN received char

 * ------------------------------------------------------------ */

char neo430_uart_getc(void){

  uint16_t d = 0;

  while (1) {

    d = UART_RTX;

    if ((d & (1<<UART_RTX_AVAIL)) != 0) { // char received?

      return (char)d;

    }

  }

}

/* ------------------------------------------------------------

 * INFO Returns value !=0 if a char has received

 * RETURN 0 if no char available

 * ------------------------------------------------------------ */

uint16_t neo430_uart_char_received(void){

  return UART_RTX & (1<<UART_RTX_AVAIL);

}

/* ------------------------------------------------------------

 * INFO Returns char from UART RX unit

 * INFO Check if char present with <uart_char_received>

 * INFO This is the base for a non-blocking read access

 * RETURN received char

 * ------------------------------------------------------------ */

char neo430_uart_char_read(void){

  return (char)UART_RTX;

}

/* ------------------------------------------------------------

 * INFO Print zero-terminated string of chars via internal UART

 * PARAM *s pointer to source string

 * ------------------------------------------------------------ */

void neo430_uart_print(char *s){

  char c = 0;

  while ((c = *s++)) {

    neo430_uart_putc(c);

  }

}

/* ------------------------------------------------------------

 * INFO Print zero-terminated string of chars via internal UART

 * Prints true line break "\r\n" for every '\n'

 * PARAM *s pointer to source string

 * ------------------------------------------------------------ */

void neo430_uart_br_print(char *s){

  char c = 0;

  while ((c = *s++)) {

    if (c == '\n') {

      neo430_uart_putc('\r');

    }

    neo430_uart_putc(c);

  }

}

/* ------------------------------------------------------------

 * INFO Get string via UART, string is automatically zero-terminated.

 * Input is acknowledged by ENTER, local echo, chars can be deleted using BACKSPACE.

 * PARAM buffer to store string to

 * PARAM size of buffer (=max string length incl. zero-termination)

 * PARAM activate local echo when =! 0

 * RETURN Length of string (without zero-termination character)

 * ------------------------------------------------------------ */

uint16_t neo430_uart_scan(char *buffer, uint16_t max_size, uint16_t echo) {

  char c = 0;

  uint16_t length = 0;

  while (1) {

    c = neo430_uart_getc();

    if (c == '\b') { // BACKSPACE

      if (length != 0) {

        if (echo) {

          neo430_uart_print("\b \b"); // delete last char in console

        }

        buffer--;

        length--;

      }

    }

    else if (c == '\r') // carriage return

      break;

    else if ((c >= ' ') && (c <= '~') && (length < (max_size-1))) {

      if (echo) {

        neo430_uart_putc(c); // echo

      }

      *buffer++ = c;

      length++;

    }

  }

  *buffer = '\0'; // terminate string

  return length;

}

/* ------------------------------------------------------------

 * INFO Print single (capital) hexadecimal value (1 digit)

 * PARAM char to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_hex_char(char c) {

  char d = c & 15;

  if (d < 10)

    d += '0';

  else

    d += 'a'-10;

  neo430_uart_putc(d);

}

/* ------------------------------------------------------------

 * INFO Print 8-bit hexadecimal value (2 digits)

 * PARAM uint8_t value to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_hex_byte(uint8_t b) {

  neo430_uart_print_hex_char((char)(b >> 4));

  neo430_uart_print_hex_char((char)(b >> 0));

}

/* ------------------------------------------------------------

 * INFO Print 16-bit hexadecimal value (4 digits)

 * PARAM uint16_t value to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_hex_word(uint16_t w) {

  union uint16_u tmp;

  tmp.uint16 = w;

  neo430_uart_print_hex_byte(tmp.uint8[1]);

  neo430_uart_print_hex_byte(tmp.uint8[0]);

}

/* ------------------------------------------------------------

 * INFO Print 32-bit hexadecimal value (8 digits)

 * PARAM uint32_t value to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_hex_dword(uint32_t dw) {

  union uint32_u tmp;

  tmp.uint32 = dw;

  neo430_uart_print_hex_byte(tmp.uint8[3]);

  neo430_uart_print_hex_byte(tmp.uint8[2]);

  neo430_uart_print_hex_byte(tmp.uint8[1]);

  neo430_uart_print_hex_byte(tmp.uint8[0]);

}

/* ------------------------------------------------------------

 * INFO Print 64-bit hexadecimal value (16 digits)

 * PARAM uint64_t value to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_hex_qword(uint64_t qw) {

  union uint64_u tmp;

  tmp.uint64 = qw;

  neo430_uart_print_hex_byte(tmp.uint8[7]);

  neo430_uart_print_hex_byte(tmp.uint8[6]);

  neo430_uart_print_hex_byte(tmp.uint8[5]);

  neo430_uart_print_hex_byte(tmp.uint8[4]);

  neo430_uart_print_hex_byte(tmp.uint8[3]);

  neo430_uart_print_hex_byte(tmp.uint8[2]);

  neo430_uart_print_hex_byte(tmp.uint8[1]);

  neo430_uart_print_hex_byte(tmp.uint8[0]);

}

/* ------------------------------------------------------------

 * INFO Print 8-bit binary value (8 digits)

 * PARAM uint8_t value to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_bin_byte(uint8_t b) {

  uint8_t i;

  for (i=0x80; i!=0; i>>=1) {

    if (b & i)

      neo430_uart_putc('1');

    else

      neo430_uart_putc('0');

  }

}

/* ------------------------------------------------------------

 * INFO Print 16-bit binary value (16 digits)

 * PARAM uint16_t value to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_bin_word(uint16_t w) {

  union uint16_u tmp;

  tmp.uint16 = w;

  neo430_uart_print_bin_byte(tmp.uint8[1]);

  neo430_uart_print_bin_byte(tmp.uint8[0]);

}

/* ------------------------------------------------------------

 * INFO Print 32-bit binary value (32 digits)

 * PARAM uint32_t value to be printed

 * ------------------------------------------------------------ */

void neo430_uart_print_bin_dword(uint32_t dw) {

  union uint32_u tmp;

  tmp.uint32 = dw;

  neo430_uart_print_bin_byte(tmp.uint8[3]);

  neo430_uart_print_bin_byte(tmp.uint8[2]);

  neo430_uart_print_bin_byte(tmp.uint8[1]);

  neo430_uart_print_bin_byte(tmp.uint8[0]);

}

/* ------------------------------------------------------------

 * INFO Print 32-bit number as decimal number (10 digits)

 * INFO Slow custom version of itoa

 * PARAM 32-bit value to be printed as decimal number

 * PARAM show #leading_zeros leading zeros

 * PARAM pointer to array (11 elements!!!) to store conversion result string

 * ------------------------------------------------------------ */

void neo430_itoa(uint32_t x, uint16_t leading_zeros, char *res) {

  const char numbers[10] = "0123456789";

  char buffer1[11];

  uint16_t i, j;

  buffer1[10] = '\0';

  res[10] = '\0';

  // convert

  for (i=0; i<10; i++) {

    buffer1[i] = numbers[x%10];

    x /= 10;

  }

  // delete 'leading' zeros

  for (i=9; i!=leading_zeros; i--) {

    if (buffer1[i] == '0')

      buffer1[i] = '\0';

    else

      break;

  }

  // reverse

  j = 0;

  do {

    if (buffer1[i] != '\0')

      res[j++] = buffer1[i];

  } while (i--);

  res[j] = '\0'; // terminate result string

}

/* ------------------------------------------------------------

 * INFO Embedded version of the printf function with reduced functionality

 * INFO Only use this function if it is really required!

 * INFO It is large and slow... ;)

 * INFO Original from http://forum.43oh.com/topic/1289-tiny-printf-c-version/

 * PARAM Argument string

 * ------------------------------------------------------------ */

void neo430_printf(char *format, ...) {

  char c, string_buf[11];

  int32_t n;

  va_list a;

  va_start(a, format);

  while ((c = *format++)) {

    if (c == '%') {

      c = *format++;

      switch (c) {

        case 's': // string

          neo430_uart_print(va_arg(a, char*));

          break;

        case 'c': // char

          neo430_uart_putc((char)va_arg(a, int));

          break;

        case 'b': // unsigned 16-bit binary

          neo430_uart_print_bin_word(va_arg(a, unsigned int));

          break;

        case 'i': // 16-bit integer

          n = (int32_t)va_arg(a, int);

          if (n < 0) {

            n = -n;

            neo430_uart_putc('-');

          }

          neo430_itoa((uint32_t)n, 0, string_buf);

          neo430_uart_br_print(string_buf);

          break;

        case 'u': // 16-bit unsigned

          neo430_itoa((uint32_t)va_arg(a, unsigned int), 0, string_buf);

          neo430_uart_br_print(string_buf);

          break;

        case 'l': // 32-bit signed long

          n = (int32_t)va_arg(a, int32_t);

          if (n < 0) {

            n = -n;

            neo430_uart_putc('-');

          }

          neo430_itoa((uint32_t)n, 0, string_buf);

          neo430_uart_br_print(string_buf);

          break;

        case 'n': // 32-bit unsigned long

          neo430_itoa(va_arg(a, uint32_t), 0, string_buf);

          neo430_uart_br_print(string_buf);

          break;

        case 'x': // 16-bit hexadecimal

          neo430_uart_print_hex_word(va_arg(a, unsigned int));

          break;

        case 'X': // 32-bit hexadecimal

          neo430_uart_print_hex_dword(va_arg(a, uint32_t));

          break;

        default:

          return;

      }

    }

    else {

      if (c == '\n')

        neo430_uart_putc('\r');

      neo430_uart_putc(c);

    }

  }

  va_end(a);

}

/* ------------------------------------------------------------

 * INFO Convert N hex chars into uint32

 * PARAM Pointer to buffer with hex chars

 * PARAM Number of hex chars to convert (1..8)

 * RETURN Conversion result

 * ------------------------------------------------------------ */

uint32_t neo430_hexstr_to_uint(char *buffer, uint8_t length) {

  uint32_t res = 0, d = 0;

  char c = 0;

  while (length--) {

    c = *buffer++;

    if ((c >= '0') && (c <= '9'))

      d = (uint32_t)(c - '0');

    else if ((c >= 'a') && (c <= 'f'))

      d = (uint32_t)((c - 'a') + 10);

    else if ((c >= 'A') && (c <= 'F'))

      d = (uint32_t)((c - 'A') + 10);

    else

      d = 0;

    res = res + (d << (length*4));

  }

  return res;

}

/* ------------------------------------------------------------

 * INFO Return terminal cursor n positions

 * PARAM n positions

 * ------------------------------------------------------------ */

void neo430_uart_bs(uint16_t n) {

  while (n--) {

    neo430_uart_putc(0x08);

  }

}

/* ------------------------------------------------------------

 * INFO Print signed 32-bit fixed point number (num)

 * PARAM fpf_c: Number of bin fractional bits in input (max 32)

 * PARAM num_frac_digits_c: Number of fractional digits to show (max 8)

 * ------------------------------------------------------------ */

void neo430_uart_print_fpf_32(int32_t num, uint16_t fpf_c, uint16_t num_frac_digits_c) {

  uint16_t i;

  // make positive

  if (num < 0) {

    neo430_uart_putc('-');

    num = -num;

  }

  uint32_t num_int = (uint32_t)num;

  // print integer part

  char int_buf[11];

  neo430_itoa((uint32_t)(num_int >> fpf_c), 0, int_buf);

  neo430_uart_br_print(int_buf);

  neo430_uart_putc('.');

  // compute fractional resolution

  uint32_t frac_dec_base = 1;

  for (i=0; i<num_frac_digits_c; i++) {

    frac_dec_base = frac_dec_base * 10;

  }

  frac_dec_base = frac_dec_base >> 1;

  // compute fractional part's bit-insulation shift mask

  uint32_t frac_dec_mask = 1L << (fpf_c-1);

  // compute actual fractional part

  uint32_t frac_data = num_int & ((1 << fpf_c)-1); // only keep fractional bits

  uint32_t frac_sum = 1;

  for (i=0; i<fpf_c; i++) { // test each fractional bit

    if (frac_data & frac_dec_mask) { // insulate current fractional bit

      frac_sum += frac_dec_base;

    }

    frac_dec_mask >>= 1; // go from MSB to LSB

    frac_dec_base >>= 1;

  }

  // print fractional part

  char frac_buf[11];

  neo430_itoa((uint32_t)frac_sum, num_frac_digits_c-1, frac_buf);

  frac_buf[num_frac_digits_c] = '\0'; // truncate

  neo430_uart_br_print(frac_buf);

}