Use the unix Screen program to interact with Arduino via UART

I can use screen to Read values coming from Arduino just fine:

Serial.begin(9600);

int n = 0;
while (1)

{
   Serial.println(n++);
}

And can see the output with screen /dev/cu.usbmodem14201 9600.

But I cannot write anything To Arduino, this code with Screen never prints anything. I press keys in Screen, RX led flashes on the Arduino board but nothing is printed back on my Screen.

int serIn;
Serial.begin(9600);

while (1)
{
    if (Serial.available())  // <-- this is always -1
    {
        while (Serial.available() > 0)
        {
            serIn = Serial.read();
            Serial.print(serIn);
        }
        Serial.println();
    }
}

i’ve used the code recently to communicate to a serial interface on an arduino mega. i built it using cygwin on a Windows 10 laptop

// monitor NCE cab-bus

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <getopt.h>
#include <string.h>

#include <fcntl.h>
#include <unistd.h>

#include <pthread.h>
#include <termios.h>
#include <time.h>


#define DBG_TTY     1
#define RD_BUF_SIZE 32

char        *progname;
unsigned int debug = 0;
unsigned int flag  = 0;

int     addr        = 9;
int     speed       = B9600;
char    port [20]   = "ttyS4";

// --------------------------------------------------------------------
// open and configure RS-485
//    NCE cab-bus is 9600bps, 8 data bits, no parity, 2 stop bits


void
dispTty (
    struct termios  tty,
    char*           label )
{
    printf (" %s: %s\n", __func__, label);

    // check configuration
    printf (" %s: %08x c_iflag\n", __func__, tty.c_iflag);
    printf (" %s: %08x c_oflag\n", __func__, tty.c_oflag);
    printf (" %s: %08x c_cflag\n", __func__, tty.c_cflag);
    printf (" %s: %08x c_lflag\n", __func__, tty.c_lflag);

    printf (" %s: %08x c_cc [VMIN]\n",  __func__, tty.c_cc [VMIN]);
    printf (" %s: %08x c_cc [VTIME]\n", __func__, tty.c_cc [VTIME]);

    printf (" %s: %08x c_cc [VSTART]\n",  __func__, tty.c_cc [VSTART]);
    printf (" %s: %08x c_cc [VSTOP]\n",   __func__, tty.c_cc [VSTOP]);

 // printf (" %s: %8d  NCCS\n", __func__, NCCS);
    printf (" %s: %08x i speed\n", __func__, cfgetispeed (&tty) );
    printf (" %s: %08x o speed\n", __func__, cfgetospeed (&tty) );
    printf ("\n");
}

// -------------------------------------
struct termios  ttyStdin;

void
restoreStdin ()
{
    if (0 != tcsetattr (0, TCSANOW, & ttyStdin))  {
        perror ("tcsetattr fault");
        exit (1);
    }
}

// -------------------------------------
void
reconfigStdin ()
{
    struct termios  tty;

    if (0 != tcgetattr (0, & tty))
    {
        perror ("tcgetattr fault");
        exit (1);
    }

    memcpy ((char *) & ttyStdin, (char *) & tty, sizeof (tty));

    // dispTty (tty, "stdin before");

    tty.c_lflag  = tty.c_cflag & ~ICANON;       // disable canonical 
//  tty.c_lflag  = tty.c_cflag & ~ECHO;

    if (debug & DBG_TTY) 
        dispTty (tty, "stdin");

    if (0 != tcsetattr (0, TCSANOW, & tty))  {
        perror ("tcsetattr fault");
        exit (1);
    }
}

// -------------------------------------
int
openCfgRs485 (
    int     rd_size )
{
    struct termios  tty;
    char            dev [50]   = "/dev/";
    int             fd;

    strcat (dev, (const char*) port);

 // fd = open (dev, O_RDWR | O_NOCTTY | O_NDELAY);
    fd = open (dev, O_RDWR | O_NOCTTY           );
    if (0 > fd)
    {
        perror (dev);
        exit (1);
    }
    printf ("%s: opened %s\n", __func__, dev);

    // get configuration
    if (0 != tcgetattr (fd, &tty))
    {
        perror ("tcgetattr fault");
        exit (1);
    }

    // dispTty (tty, "usb");

    // change configuration
    cfsetospeed (&tty, speed);
    cfsetispeed (&tty, speed);

    tty.c_lflag = 0;                                // no echo
    tty.c_oflag = 0;                                // no remapping/delays

    tty.c_cflag  = (tty.c_cflag & ~CSIZE) | CS8;    // 8 data bits
    tty.c_cflag  = (tty.c_cflag & ~PARENB);         // no parity
    tty.c_cflag |= CSTOPB;                          // 2 stop bits

#if 0
    tty.c_cc [VMIN]  = 4;     ;                     // read timeout
    tty.c_cc [VTIME] = 0;                           // read timeout
#else
    tty.c_cc [VMIN]  = 1;                           // read timeout
    tty.c_cc [VTIME] = 0;                           // read timeout
#endif

#undef  StartStop
#ifdef StartStop
    tty.c_cc [VSTART] = 0x88;                       // read timeout
    tty.c_cc [VSTOP]  = 0x80;                       // read timeout

    tty.c_iflag       = IXON;                       // enable start/stop
#else
    tty.c_cc [VSTART] = 0x88;                       // read timeout
    tty.c_cc [VSTOP]  = 0x80;                       // read timeout

    tty.c_iflag       = 0;                          // enable start/stop
#endif

    if (debug & DBG_TTY) 
        dispTty (tty, "usb");

    if (0 != tcsetattr (fd, TCSANOW, &tty))  {
        perror ("tcsetattr fault");
        exit (1);
    }

    return fd;
}

// --------------------------------------------------------------------
// display data in hex

void
disp (uint8_t *buf, int nbyte)
{
    int i;

    // printf ("%s: %d\n", __func__);

    for (i = 0; i < nbyte; i++)  {
        if ( ! (i % 16))
            printf ("\n  %4x: ", i);
        else if (! (i % 4))
            printf ("  ");

        printf (" %02x", buf [i]);
    }
    printf ("\n");
}

// --------------------------------------------------------------------
// monitor

void *
monitor (
    void    *p)
{
    uint8_t     rdBuf [RD_BUF_SIZE];
    int         nread;
    int         n;
    int         fd      = (int) p;

    printf ("%s:\n", __func__);

    while (0 != (nread = read (fd, rdBuf, RD_BUF_SIZE)) )
    {
        if (EOF == nread)
            break;

        for (n = 0; n < nread; n++)  {
            putchar (rdBuf [n]);
        }
    }

    printf ("%s: EOF\n", __func__);

    return NULL;
}

// --------------------------------------------------------------------
// 
void
terminal ()  {
    pthread_t   tid;
    int         c;
    int         fd;

    printf ("%s:\n", __func__);

    fd      = openCfgRs485 (RD_BUF_SIZE);

    // keyboard icanonical
    reconfigStdin ();

    // create thread to monitor bus
    if (0 != pthread_create ( & tid, NULL, & monitor, (void*) fd))
    {
        perror ("pthread_create");
        exit (1);
    }

    // monitor keyboard for keypresses
    while (1)  {
        c = getchar ();

        if ('q' == c)  {
            restoreStdin ();
            return;
        }

        write (fd, &c, 1);
    }

    close (fd);
}

// --------------------------------------------------------------------
void
help (void)
{
    printf (" Usage: %s \n", progname);
}

// --------------------------------------------------------------------
int
main (
    int     argc,
    char  **argv )
{
    int     c;

    progname = *argv;

    while ((c = getopt(argc, argv, "D:s:p:")) != -1)  {
        switch (c)  {
        case 'D':
            debug = atoi (optarg);
            break;

        case 'p':
            strcpy (port, optarg);
            break;

        case 's':
            speed = atoi (optarg);
            break;

        default:
            printf ("Error: unknown option '%c'\n", optopt);
                        help();
            break;
        };
    }

    terminal ();

    return 0;
}

So that we can test your code, please provide complete sketches.

why not simply

loop ()
{
    if (Serial.available())
         Serial.print (Serial.read());
}

Serial.available() is always returning -1 for some reason.

Perhaps we could investigate that reason if you would post your entire sketch.

I use the simple “Minicom” terminal program on Linux Mint

apt-get install minicom, after install, minicom -s for setup.