# Inquiries regarding sending data to host PC

**URL:** <https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065>\
**Category:** General Guidance\
**Created:** [December 24, 2022, 12:55pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065 "2022-12-24T12:55:17Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![hasanthesyrian](https://avatars.discourse-cdn.com/v4/letter/h/c5a1d2/32.png) [@hasanthesyrian](https://forum.arduino.cc/u/hasanthesyrian)\
**Post date:** [December 24, 2022, 12:55pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/1 "2022-12-24T12:55:17Z")

</div>

I was wondering if it is possible to send data to the host PC (PC connected to the Arduino board) via USB.

What I'm trying to do is, for now, open a browser with a link on my computer that is connected to my Arduino after I scan an NFC/RFID tag using an [RC522](https://microcontrollerslab.com/rc522-rfid-reader-pinout-arduino-interfacing-examples-features/).

I was also wondering can the Arduino library interface with the PC? For example, how would I open the browser? Do I need an external script and just tell the Arduino to run that script instead of having that script part of the RC522 sketch?

For example, I'm sure doing something like `open.browser("link");` wouldn't work with it being part of the sketch.

I also have ESP32/HC-06 boards if wireless interfacing is needed.

---

<div class="post-metadata">

**Author:** ![Railroader](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/railroader/32/274550_2.png) [@Railroader](https://forum.arduino.cc/u/Railroader)\
**Post date:** [December 24, 2022, 1:17pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/2 "2022-12-24T13:17:41Z")

</div>

Most likely the Pc app needs to read the COM port connected to the microcontroller.

---

<div class="post-metadata">

**Author:** ![hasanthesyrian](https://avatars.discourse-cdn.com/v4/letter/h/c5a1d2/32.png) [@hasanthesyrian](https://forum.arduino.cc/u/hasanthesyrian)\
**Post date:** [December 24, 2022, 2:00pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/3 "2022-12-24T14:00:11Z")

</div>

There is no PC app. I'm asking if I can write the code as part of the RC522 Arduino code and how can I open the browser with the link - can I do it with the Arduino library or do I let the Arduino open an external script and the script itself opens the browser with the link.

---

<div class="post-metadata">

**Author:** ![Railroader](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/railroader/32/274550_2.png) [@Railroader](https://forum.arduino.cc/u/Railroader)\
**Post date:** [December 24, 2022, 2:21pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/4 "2022-12-24T14:21:16Z")

</div>

> [@hasanthesyrian](#):
>
> my Arduino

What would that be? There are some 20 different boards and they are different regarding communication and USB ports.,

Consider the browser as an app.  
You need to study the concept of USB. Some Arduino has an USB type like "slave" that works with PC USB being like a "master".  
For some Arduinos a "master" USB shield needs to be used, some "Ardionos" might have it built in.

---

<div class="post-metadata">

**Author:** ![hasanthesyrian](https://avatars.discourse-cdn.com/v4/letter/h/c5a1d2/32.png) [@hasanthesyrian](https://forum.arduino.cc/u/hasanthesyrian)\
**Post date:** [December 24, 2022, 2:23pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/5 "2022-12-24T14:23:49Z")

</div>

I'm using a Nano, but I have an UNO, a Mega, and an ESP32 board.

---

<div class="post-metadata">

**Author:** ![Idahowalker](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/idahowalker/32/238858_2.png) [@Idahowalker](https://forum.arduino.cc/u/Idahowalker)\
**Post date:** [December 24, 2022, 2:25pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/6 "2022-12-24T14:25:42Z")

</div>

This fellow sends data to a thingy via the USB, perhaps looking at his code can be a source of how to do a thing?

> [@PLX-DAQ version 2 - now with 64 bit support! (and further new features)](https://forum.arduino.cc/t/plx-daq-version-2-now-with-64-bit-support-and-further-new-features/420628/463):
>
> Hi Marko, there is an additonal comma at the end of your CELL,SET statement. Try removing that. It could confuse PLX DAQ in Excel. Serial.println("CELL,SET,ONSHEET,Sheet1,G,4,0,"); to Serial.println("CELL,SET,ONSHEET,Sheet1,G,4,0"); In a private message you said that it is needed for your Excel version to recognize the command. That is strange and I have never heard of that or can explain that in my head. Could you paste your full code to investigate? Please make use of the [code] and [ /…

I have a RPi that runs MQTT Broker. I have 13 ESP32's sharing information through the MQTT Broker and a Python program, node-red can be used instead of writing your own.

> **[ESP32 HTTP GET and HTTP POST with Arduino IDE | Random Nerd Tutorials](https://randomnerdtutorials.com/esp32-http-get-post-arduino/)**
>
> Learn how to make HTTP GET and HTTP POST Requests with the ESP32 board with Arduino IDE. How to get values, post JSON data objects, URL encoded requests, etc.

Perhaps one of those items may give aid.

---

<div class="post-metadata">

**Author:** ![b707](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/b707/32/854321_2.png) [@b707](https://forum.arduino.cc/u/b707)\
**Post date:** [December 24, 2022, 2:38pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/7 "2022-12-24T14:38:40Z")

</div>

> [@hasanthesyrian](#):
>
> I'm asking if I can write the code as part of the RC522 Arduino code and how can I open the browser with the link - can I do it with the Arduino library or do I let the Arduino open an external script and the script itself opens the browser with the link.

With an arduino, you can't do either one or the other. All the arduino can do is send bytes to the serial port. No PC applications or scripts can be launched from the arduino side.  
Therefore, with Nano or Mega your only option is to use some application on the PC, lanched **in advance** , which will wait for serial messages from the arduino and perform actions on these commands.

The other way is using some WiFi capable boards (ESP32 for example) and interact with web-server directly without PC.

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 2:40pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/8 "2022-12-24T14:40:59Z")

</div>

> [@hasanthesyrian](#):
>
> There is no PC app. I'm asking if I can write the code as part of the RC522 Arduino code and how can I open the browser with the link - can I do it with the Arduino library or do I let the Arduino open an external script and the script itself opens the browser with the link.

Maybe, let's discuss:

- PC needs a "listener app" except for HID where the Arduino is a keyboard/mouse. Thus, the Arduino could run keyboard shortcuts to open menu/applications.

Arduino HID comes easy for some Arduino models.

[arduino models supporting "USB" + "HID" - Search (bing.com)](https://www.bing.com/search?q=arduino%20models%20supporting%20%22USB%22%20%2B%20%22HID%22&qs=ds&form=QBRE)

([https://www.arduino.cc/reference/en/language/functions/usb/keyboard/](https://www.arduino.cc/reference/en/language/functions/usb/keyboard/))

[Keyboard/Keyboard.h at master · arduino-libraries/Keyboard · GitHub](https://github.com/arduino-libraries/Keyboard/blob/master/src/Keyboard.h)

---

<div class="post-metadata">

**Author:** ![NetDevil](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/netdevil/32/243926_2.png) [@NetDevil](https://forum.arduino.cc/u/NetDevil)\
**Post date:** [December 24, 2022, 2:44pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/9 "2022-12-24T14:44:32Z")

</div>

This fellow's solution requires an open Microsoft Excel worksheet on a PC, which is using COMM port to listen to commands send from Arduino to PC.

Using VBA commands ([Application.OpenBrowser method (Project) | Microsoft Learn](https://learn.microsoft.com/en-us/office/vba/api/project.application.openbrowser)) one could trigger opening a website on the PC from Arduino, yes. That is not included by default and needs some very basic custom lines of code to be including by OP

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 2:47pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/10 "2022-12-24T14:47:27Z")

</div>

> [@NetDevil](#):
>
> This fellow's solution requires an open Microsoft Excel worksheet on a PC, which is using COMM port to listen to commands send from Arduino to PC.

VBA is actually not required for simple input:

> [@String numeric output with V-USB HID](https://forum.arduino.cc/t/string-numeric-output-with-v-usb-hid/132654/10):
>
> Johan, As soon as the sketch uploads, the Arduino reboots and the Arduino USB port keeps the same serial port. The V-USB port is completely separate and can be plugged into the PC at the same time as the Arduino port is active as virtual com. The V-USB side will take on the personality of HID keyboard. If you use two USB ports simultaneously, only one (the Arduino) must power the Uno. -UNO connect to pc - upload sketch - UNO disconnect - connect usb-circuit - open excel? Program the UNO on…

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 3:00pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/11 "2022-12-24T15:00:43Z")

</div>

> [@b707](#):
>
> Therefore, with Nano or Mega your only option is to use some application on the PC, lanched **in advance** , which will wait for serial messages from the arduino and perform actions on these commands.

True.  
HID does change the landscape.

On Linux, a serial console totally makes your statement not-true.

---

<div class="post-metadata">

**Author:** ![b707](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/b707/32/854321_2.png) [@b707](https://forum.arduino.cc/u/b707)\
**Post date:** [December 24, 2022, 3:06pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/12 "2022-12-24T15:06:39Z")

</div>

> [@mrburnette](#):
>
> On Linux, a serial console totally makes your statement not-true.

What is "serial-console" ? Do you mean standard Linux tty or something different?

I can't imagine how a standard linux terminal can process some commands from arduino without additional scripts or applications. I would appreciate clarification.

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 3:10pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/13 "2022-12-24T15:10:18Z")

</div>

> [@b707](#):
>
> What is "serial-console" ? Do you mean standard Linux tty or something different?

Let's change radio stations on Raspberry Pi with an Audio board:

```arduino
/*
  This implementation specific to Maple Mini and used with a NOKIA 5110 Graphic LCD.
    Compiled under Arduino 1.8.6 on Linux Mint 18.3 Cinnamon tested 20180921
      Sketch uses 18844 bytes (15%) of program storage space. Maximum is 122880 bytes.
      Global variables use 3280 bytes (16%) of dynamic memory, leaving 17200 bytes for local variables. Maximum is 20480 bytes.
*/

#include <Streaming.h> // http://arduiniana.org/libraries/streaming/
#include "Defines.h" // Nokia 5110 LCD electrical connections

// constants
const int BAUD = 115200; // rPi3B defaults to 115200
const byte ContrastPin = 8; // D8 low activates the Contrast adjustment
const unsigned long FiveSec = 5000 ; // do something every 5 seconds

// global prog variables
byte nRow; // line count (0- 5 for NOKIA LCD)
byte nColumn; // character count (0-11 for NOKIA LCD)
byte NOKIAcontrast = 0xBE; // LCD initialization contrast values B0 thru BF
boolean mute; // mute volume / stop mpc
unsigned int Channels = 10; // How many channels are stored?
unsigned int CurrentChnl = 1; // channnel playing; eg: 1, 2, ... 9, 10
unsigned int OldChannel = 1;
uint8_t paddleX ; // Value to represent station selection
uint8_t paddleY ; // Value to represent volume
uint8_t previousX ;
uint8_t previousY ;
unsigned long TimeMarker; // Software variable for creating an event

char temp;
char* BlankLine[] = {" "}; // Nokia 12 x 6 (84 * 48)

// Character array pointers - message and command table
const char* msg0[] = {"mpc clear;mpc add http://"}; // prefix
const char* msg1[] = {";mpc play;sleep 1;mpc play"}; // suffix
const char* msg2[] = {"71.125.37.66:7000"}; // Rewound Radio:
const char* msg3[] = {"206.190.136.212:7744"}; // Classic Hits JFRC
const char* msg4[] = {"64.78.234.173:8528"};
const char* msg5[] = {"204.141.167.19:9170"};
const char* msg6[] = {"198.178.123.17:10922"}; // San Francisco's 70's HITS!
const char* msg7[] = {"91.121.155.204:8048"}; // 1000 HITS 80s
const char* msg8[] = {"45.79.186.124:8160"}; // Personal Favorites 60s/70s/80s/90s/More
const char* msg9[] = {"51.15.152.81:8085"};
const char* msg10[] = {"198.58.98.83:8062"}; // Bulldogs-Radio:
const char* msg11[] = {"50.7.129.122:8433"}; // Flower Power Radio - Far Out And Groovy Tunes From The 50's 60's & 70's
const char* msg12[] = {""};
const char* msg13[] = {""};
const char* msg14[] = {""};
const char* msg15[] = {""};
const char* msg16[] = {""};
const char* msg17[] = {""};
const char* msg18[] = {""};
const char* msg19[] = {""};
const char* msg20[] = {""};
const char* msg21[] = {"mpc play"};
const char* msg22[] = {"mpc stop"};
const char* msg23[] = {"sudo reboot now"};
const char* msg24[] = {"mpc volume +5"};
const char* msg25[] = {"mpc volume -5"};
const char* msg26[] = {"sudo reboot now"};

void setup(void)
{
  pinMode(ContrastPin, INPUT);
  digitalWrite(ContrastPin, HIGH); // activate internal pullup resistor
  pinMode(JoyButton, INPUT); // "Key"
  pinMode(PinInX, INPUT_ANALOG); // X potentiometer
  pinMode(PinInY, INPUT_ANALOG); // Y potentiometer

  Serial1.begin(BAUD);

  LcdInitialise();
  LcdClear();
  delay(100);
  previousX = Joystick_X(); // capture centerpoint X null
  previousY = Joystick_Y(); // capture centerpoint Y null
  Serial1 << endl; // CR+LF to rPi serial console

  TimeMarker = millis(); // variable to implement function timing events
}

void loop(void)
{
  IsMute();
  AdjustVolume();
  ChangeChannel();
  SerialInput();
  ForceUpdate();
}

```

```arduino
// UtilFuncts.ino

int Joystick_X() {
  uint8_t x;
  // map ( value, fromLow, fromHigh, toLow, toHigh) ; // Label V
  x = map( analogRead(PinInX), 0, 1023, 1, 20) ; // Analog D11 == PA0/CH0
  return ( x) ; // Volume +/-

}

int Joystick_Y() {
  uint8_t y;
  // map ( value, fromLow, fromHigh, toLow, toHigh) ; // Label H
  y = map( analogRead(PinInY), 0, 1023, 1, 20) ; // Analog D10 == PA1/CH1
  return ( y) ; // Channel +/-
}

boolean UserButtonInput() {
  return digitalRead(JoyButton); // joystick button on D12 of Maple Mini
}

void IsMute( void ) {
  mute = ! UserButtonInput();
  if( mute ) {
    Serial1 << msg22[0] << endl; // mpc stop
    LcdClear(); gotoXY(2, 1); LcdString("MUTE is On");
    gotoXY(0, 5); LcdString( BlankLine[0] ); gotoXY(0, 5); dispcountt( CurrentChnl ); LcdString(" :Channel");
    delay(1000);
    do {delay(50);} while ( abs(Joystick_X() - previousX) < 5 );
    mute = false;
    LcdClear();
    Serial1 << msg21[0] << endl; // mpc play
  }
}

boolean AdjustVolume( void ) {
  if( Joystick_X() > previousX + 5 ) {
    Serial1 << msg24[0] << endl;
    delay(500);
  } else if (Joystick_X() < previousX - 5 ) {
    Serial1 << msg25[0] << endl;
    delay(500);
  } return true;
}

boolean ChangeChannel( void ) {
  OldChannel = CurrentChnl;
  if( Joystick_Y() > previousY + 5 ) {
    ++CurrentChnl;
    if(CurrentChnl > 10) CurrentChnl = 1;
    delay(500);
  } else if (Joystick_Y() < previousY - 5 ) {
    CurrentChnl--;
    TimeMarker = FiveSec + millis();
    delay(500);
    if(CurrentChnl < 1) CurrentChnl = 1;
    do {
      delay(500);
    } while ( Joystick_Y() < previousY - 5 ) ;
        if (TimeMarker < millis() ) {
          Serial1 << msg26[0] << endl; // force reboot if control held > 5 seconds
          LcdClear();
          delay(100);
          gotoXY(2, 1); LcdString("REBOOTING...");
        }
  }

  if (CurrentChnl != OldChannel) {
    gotoXY(0, 5); LcdString( BlankLine[0] ); gotoXY(0, 5); dispcountt( CurrentChnl ); LcdString(" :Channel");
    ChannelChanger(CurrentChnl);
    TimeMarker = millis() - 6000; // Force songtitle update
    OldChannel = CurrentChnl;
  }
  return true;
}

void SerialInput( void ) {
  // extract the song title and display it on the LCD
  if (Serial1.available() > 0) { // anything in the serial hw buffer?
    char temp = Serial1.read(); // if so, fetch the next character from FIFO
    SongTitle(temp); // Parse the Artist+Title
  }
}

void ForceUpdate( void ) {
  // Every 5 seconds force update of mpc to extract current song info
  if ((TimeMarker + FiveSec) < millis() ) {
    TimeMarker = millis();
    Serial1 << msg21[0] << endl; // refresh the display using "mpc play"
  }
}

void SongTitle(char c) {
  static int i, j;
  static char q;
  static bool flag = false, flag1 = true;
  static char Titlebuffer[72];
  q = c;

  if ( q == 0x24) // '$' last line in "mpc play" command
  {
    // Serial << "found $ setting flag false" << endl;
    i = 0;
    flag1 = false; // 1st key double-lock for LCD output
    flag = false; // 2nd key ... we want first line info on next "mpc play"
  }

  if (q == 0x3a) { // ':'
    flag = true; // song title capture enabled on 1st line
    // Serial << "found ':' setting flag true" << endl;
    i = 0;
  }

  if (flag && !flag1) { // double-lock
    if (i < 72) Titlebuffer[i++] = q; // auto increment index
      
    if ( q == 0x0a || q == 0x0d ) // CR or LF? End of line capture
    {
      flag1 = true; // stay out of spooler until next '$'
      LcdClear(); gotoXY(0, 5); LcdString( BlankLine[0] ); gotoXY(0, 5); dispcountt( CurrentChnl );
                                LcdString(" :Channel"); gotoXY(0, 0);
      for (j = 2; j < i-1 ; j++) { // [0],[1] == space, display song title [1]...[n]
        if (Titlebuffer[j] == 0x0d || Titlebuffer[j] == 0x0a) exit; // end of 1st line
        delay(25); // necessary for slow Nokia
        LcdCharacter(Titlebuffer[j]);
        if (Titlebuffer[j] == '-') { gotoXY(0, (nRow + 2)); ++j;} // force linebreak before song title
      }
      flag = false; // close second lock until '$' in stream
    }
  }
}

void ChannelChanger(int chnl)
{
  Serial1 << msg0[0]; // prefix

  switch (chnl) 
  {
    case 1:
      Serial1 << msg2[0];
      break;
    case 2:
      Serial1 << msg3[0];
      break;
    case 3:
      Serial1 << msg4[0];
      break;
    case 4:
      Serial1 << msg5[0];
      break;
    case 5:
      Serial1 << msg6[0];
      break;
    case 6:
      Serial1 << msg7[0];
      break;
    case 7:
      Serial1 << msg8[0];
      break;
    case 8:
      Serial1 << msg9[0];
      break;
    case 9:
      Serial1 << msg10[0];
      break;
    case 10:
      Serial1 << msg11[0];
      break;
    default:
      Serial1 << msg5[0];
      break;
  }
  Serial1 << msg1[0] << endl; // suffix
}

```

```arduino
// ScrnFuncts.ino
// Nokia 5110 LCD support functions and font mapping
static const byte ASCII[][5] =
{{0x00, 0x00, 0x00, 0x00, 0x00} // 20  
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c £¤
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j 
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ¡û
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f ¡ú
};

char disp_tab[]={'0','1','2','3','4','5','6','7','8','9'};

void LcdInitialise()
  { pinMode(PIN_SCE, OUTPUT);
    pinMode(PIN_RESET, OUTPUT);
    pinMode(PIN_DC, OUTPUT);
    pinMode(PIN_SDIN, OUTPUT);
    pinMode(PIN_SCLK, OUTPUT);
    digitalWrite(PIN_RESET, LOW);
    digitalWrite(PIN_RESET, HIGH);
    LcdWrite(LCD_C, 0x21 ); // LCD Extended Commands.
    LcdWrite(LCD_C, NOKIAcontrast );
    LcdWrite(LCD_C, 0x04 ); // Set Temp coefficent. //0x04
    LcdWrite(LCD_C, 0x14 ); // LCD bias mode 1:48. //0x13
    LcdWrite(LCD_C, 0x0C ); // LCD in normal mode.
    LcdWrite(LCD_C, 0x20 );
    LcdWrite(LCD_C, 0x0C ); }

void LcdCharacter(char character)
  { LcdWrite(LCD_D, 0x00);
     for (int index = 0; index < 5; index++) {
      LcdWrite(LCD_D, ASCII[character - 0x20][index]); }
  LcdWrite(LCD_D, 0x00); }

void LcdClear(void) //20130504 Added nColumn/nRow reset and goto(0, 0)
  { for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  { LcdWrite(LCD_D, 0x00); }
    nColumn = 0; nRow = 0;
    gotoXY(0, 0);}

void LcdString(char *characters)
  { while (*characters)
    {LcdCharacter(*characters++); }}

void LcdWrite(byte dc, byte data) // Software SPI for Nokia
  { digitalWrite(PIN_DC, dc); // Pin D5
    digitalWrite(PIN_SCE, LOW); // Pin D7
    shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data); // Pin D4, Pin D3,,
    digitalWrite(PIN_SCE, HIGH); } // Pin D7

void gotoXY(int x, int y)
  { LcdWrite( 0, 0x80 | x); // Column.
    LcdWrite( 0, 0x40 | y); } // Row.  

void dispcountt(int count)
{
  //LcdCharacter(disp_tab[count/10000]);
  //LcdCharacter(disp_tab[count/1000%10]);
  //LcdCharacter(disp_tab[count/100%10]);
  LcdCharacter(disp_tab[count%100/10]);
  //LcdString(".");
  LcdCharacter(disp_tab[count%10]);
}

// Routine to create a black current line to overtype
void LcdCurrentLine(int line)
{
  unsigned char j;  
  for(j=0; j<84; j++) //Bottom
	{ gotoXY (j, line);
          LcdWrite (1,0x70); }
}

 void SendCharLCD( char temp ) {
  gotoXY(nColumn * 7, nRow); // Nokia LCD function to place character 6 lines of 12 characters in font
  LcdCharacter ( temp ); 
  ++nColumn;
  if (nColumn >= 12) { // lines fill to 12 characters and increase through line 6 then line 1 is cleared
    nColumn = 0;
    nRow = ++nRow % 6;
    gotoXY(nColumn, nRow);
  }
}

```

[Connecting to your Raspberry Pi Console via the Serial Cable | by Sarala Saraswati | Medium](https://medium.com/@sarala.saraswati/connecting-to-your-raspberry-pi-console-via-the-serial-cable-44d7df95f03e)

**Added:**  
Neat about my code is the serial comms are full-duplex, so The display on the Nokia will show the song being played.

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 3:20pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/14 "2022-12-24T15:20:25Z")

</div>

> [@b707](#):
>
> I can't imagine how a standard linux terminal can process some commands from arduino without additional scripts or applications.

So, on Windows OS, getting from the GUI to Command promp requires HID or a background service looking for serial "triggers", but Linux has a serial console completely GUI-unaware. Once you have access to the serial terminal, you can take over the entire machine, assuming you configure the user login and permissions.

Long Live Linux

---

<div class="post-metadata">

**Author:** ![b707](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/b707/32/854321_2.png) [@b707](https://forum.arduino.cc/u/b707)\
**Post date:** [December 24, 2022, 3:23pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/15 "2022-12-24T15:23:57Z")

</div>

Thanks, I understand, we are talking about terminal emulation using arduino. In that case everything that comes from the serial port will be processed as commands entered on the command line.  
I myself have been working in Linux for years, but somehow I forgot about this possibility.

---

<div class="post-metadata">

**Author:** ![hasanthesyrian](https://avatars.discourse-cdn.com/v4/letter/h/c5a1d2/32.png) [@hasanthesyrian](https://forum.arduino.cc/u/hasanthesyrian)\
**Post date:** [December 24, 2022, 3:25pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/16 "2022-12-24T15:25:48Z")

</div>

In this case can I use something like [PySerial](https://pypi.org/project/pyserial/) to listen to the serial port and have the Python script also open the browser for example?

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 3:31pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/17 "2022-12-24T15:31:14Z")

</div>

If you can make PyScripy invoke an old-style DOS session (like BASIC calling the system with a string) then my approach would be to have a batch file created, written , closed, and then called. Said batch file would invoke your 32/64 bit GUI application and exit.

Win-11 Icon from my desktop calls:

```cpp
REM http://archive.fabacademy.org/archives/2017/fablabverket/students/100/web/assignments/week16/pyserial_tutorial.html
ECHO OFF
cls
python -m serial.tools.list_ports

pause
exit

```

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 3:34pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/18 "2022-12-24T15:34:29Z")

</div>

> [@b707](#):
>
> In that case everything that comes from the serial port will be processed as commands entered on the command line.

And this, my friend, is magic.

---

<div class="post-metadata">

**Author:** ![mrburnette](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/mrburnette/32/702556_2.png) [@mrburnette](https://forum.arduino.cc/u/mrburnette)\
**Post date:** [December 24, 2022, 3:50pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/19 "2022-12-24T15:50:30Z")

</div>

![WIN_20221224_10_46_04_Pro](https://europe1.discourse-cdn.com/arduino/original/4X/3/0/3/303f6d34fe144f86d996cebab57e52ca5ae51afa.jpeg)

---

<div class="post-metadata">

**Author:** ![system](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/system/32/1140315_2.png) [@system](https://forum.arduino.cc/u/system)\
**Post date:** [June 22, 2023, 3:50pm UTC](https://forum.arduino.cc/t/inquiries-regarding-sending-data-to-host-pc/1069065/20 "2023-06-22T15:50:52Z")

</div>

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.