Inquiries regarding sending data to host PC

Projects General Guidance
1

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.

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.

2

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

3

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.

4

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.

5

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

6

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?

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.

Perhaps one of those items may give aid.

7

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.

8

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.arduino.cc/reference/en/language/functions/usb/keyboard/)

Keyboard/Keyboard.h at master · arduino-libraries/Keyboard · GitHub

9

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) 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

10

VBA is actually not required for simple input:

11

True.
HID does change the landscape.

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

12

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.

13

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

/*
  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();
}


// 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
}


// 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

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

1 Like
14

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

15

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.

16

In this case can I use something like PySerial to listen to the serial port and have the Python script also open the browser for example?

17

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:

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
18

And this, my friend, is magic.

1 Like
19

WIN_20221224_10_46_04_Pro
WIN_20221224_10_46_04_Pro1920×1080 212 KB

20

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