Line data    Source code

       1             : // ---------------------------------------------------------------------------
       2             : // USB EPROM/Flash Programmer
       3             : //
       4             : // Copyright (2022) Robson Martins
       5             : //
       6             : // This work is licensed under a Creative Commons Attribution-NonCommercial-
       7             : // ShareAlike 4.0 International License.
       8             : // ---------------------------------------------------------------------------
       9             : /**
      10             :  * @ingroup Firmware
      11             :  * @file hal/serial.cpp
      12             :  * @brief Implementation of the Pico Serial Communication Class.
      13             :  *
      14             :  * @author Robson Martins (https://www.robsonmartins.com)
      15             :  */
      16             : // ---------------------------------------------------------------------------
      17             : 
      18             : #include <cstring>
      19             : 
      20             : #include "pico/stdlib.h"
      21             : 
      22             : #include "hal/serial.hpp"
      23             : #include "hal/string.hpp"
      24             : 
      25             : // ---------------------------------------------------------------------------
      26             : 
      27          38 : Serial::Serial() {
      28          38 :     stdio_init_all();
      29          38 : }
      30             : 
      31           2 : int Serial::getChar(uint32_t us) {
      32           2 :     return getchar_timeout_us(us);
      33             : }
      34             : 
      35           3 : size_t Serial::getBuf(void *buf, size_t len, uint32_t us) {
      36           3 :     if (!buf || !len) {
      37           1 :         return 0;
      38             :     }
      39           2 :     size_t rd = 0;
      40           2 :     char *p = reinterpret_cast<char *>(buf);
      41             :     int c;
      42             :     do {
      43          17 :         if ((c = getchar_timeout_us(us)) != PICO_ERROR_TIMEOUT) {
      44          16 :             *p = c;
      45          16 :             p++;
      46          16 :             rd++;
      47             :         } else {
      48           1 :             break;
      49             :         }
      50          16 :     } while (rd < len);
      51           2 :     return rd;
      52             : }
      53             : 
      54           4 : std::string Serial::getStr(uint32_t us) {
      55           4 :     std::string result;
      56             :     int c;
      57             :     do {
      58           4 :         if ((c = getchar_timeout_us(us)) == PICO_ERROR_TIMEOUT || c == '\n') {
      59           4 :             break;
      60             :         }
      61           0 :         result += static_cast<char>(c);
      62             :     } while (true);
      63           4 :     return result;
      64           0 : }
      65             : 
      66           2 : int Serial::getInt(uint base, uint32_t us) {
      67           2 :     return StringUtils::toInt(getStr(us), base);
      68             : }
      69             : 
      70           1 : float Serial::getFloat(uint32_t us) {
      71           1 :     return StringUtils::toFloat(getStr(us));
      72             : }
      73             : 
      74           2 : void Serial::putChar(char c, bool flush) {
      75           2 :     putchar_raw(c);
      76           2 :     if (flush) {
      77           1 :         stdio_flush();
      78             :     }
      79           2 : }
      80             : 
      81           8 : void Serial::putBuf(const void *src, size_t len, bool flush) {
      82           8 :     if (!src || !len) {
      83           0 :         return;
      84             :     }
      85           8 :     const char *p = reinterpret_cast<const char *>(src);
      86          80 :     for (size_t i = 0; i < len; i++) {
      87          72 :         putchar_raw(p[i]);
      88             :     }
      89           8 :     if (flush) {
      90           2 :         stdio_flush();
      91             :     }
      92             : }
      93             : 
      94           6 : void Serial::putStr(const std::string &src, bool flush) {
      95           6 :     if (src.empty()) {
      96           0 :         return;
      97             :     }
      98           6 :     putBuf(src.data(), src.length(), flush);
      99             : }
     100             : 
     101           2 : void Serial::putInt(int src, uint base, uint digits, char fill, bool flush) {
     102           2 :     putStr(StringUtils::fromInt(src, base, digits, fill), flush);
     103           2 : }
     104             : 
     105           2 : void Serial::putFloat(float src, uint precision, bool flush) {
     106           2 :     putStr(StringUtils::fromFloat(src, precision), flush);
     107           2 : }
     108             : 
     109           1 : std::ostream &Serial::out() {
     110           1 :     return std::cout;
     111             : }
     112             : 
     113           1 : std::istream &Serial::in() {
     114           1 :     return std::cin;
     115             : }