Double Soft Serial + Hard Serial variable transmission

Hello good people! I've been doing some mental gymnastics around this for the last few weeks, and I have decided to try the forum.
My project is going to involve taking coordinate readings from 2 PixyCam2's (one placed facing up, the other facing sideways into a small space) to get an X Y Z coordinate reading in the 20*20cm ish space. However, as I am using the ICSP (I think that's what it's called? 6-pin header on end of Uno), I can only hook up one Pixy to an arduino at a time. Thus stems my problem.
I want to use software serial from 2 different Arduino Uno's to transmit the coordinate value (x is from 0 to 315, y is from 0 to 207) from each Pixy (which isn't the problem), and transmit them over software serial ports to a 3rd Arduino, which will assign them to a variable and do some math - eventually transmitting it over a DMX shield to some lights - but at the moment, I want to print the recieved value to the hardware serial to check it works.
I am recieving "????" instead of numbers.
I have tried variations of DEC, BIN, etc, as well as serial print and write, and nothing seems to change it.

Current code: I have 2 arduinos sending a single 3-digit number constantly over soft serial, using this code:
(the deactivated bits are what will grab the number from the Pixy, so don't stress about that)
portOne:

#include <SPI.h>
//#include <Pixy2.h>
//#include <Pixy2CCC.h>
#include <SoftwareSerial.h>

int xval = 1;

SoftwareSerial portOne(4, 5);

//Pixy2 pixy;

void setup() {
  //pixy.init();
  
  Serial.begin(9600);
  portOne.begin(9600); //corresponds with portone on master
  
}

void loop() {
  //pixy.ccc.blocks[i].m_x
  //pixy.ccc.blocks[i].m_y

  //int i;
  //pixy.ccc.getBlocks();

/*  if (pixy.ccc.numBlocks) {
    Serial.print("Detected ");
    Serial.println(pixy.ccc.numBlocks);
    
    for (i=0; i<pixy.ccc.numBlocks; i++) {
      Serial.print(" block ");
      Serial.print(i);
      Serial.print(": ");
      pixy.ccc.blocks[i].print();
    }
 
  }
*/
  //xval = pixy.ccc.blocks[i].m_x;
  portOne.print(200);
}

portTwo:

#include <SPI.h>
#include <Pixy2.h>
#include <Pixy2CCC.h>
#include <SoftwareSerial.h>

int yval = 1;

SoftwareSerial portTwo(6, 7);

//Pixy2 pixy;

void setup() {
  //pixy.init();
  
  Serial.begin(9600);
  portTwo.begin(9600); //corresponds with porttwo on master
  
}

void loop() {
  //pixy.ccc.blocks[i].m_x
  //pixy.ccc.blocks[i].m_y

  //int i;
  //pixy.ccc.getBlocks();

/*  if (pixy.ccc.numBlocks) {
    Serial.print("Detected ");
    Serial.println(pixy.ccc.numBlocks);
    
    for (i=0; i<pixy.ccc.numBlocks; i++) {
      Serial.print(" block ");
      Serial.print(i);
      Serial.print(": ");
      pixy.ccc.blocks[i].print();
    }
 
  }
*/
  //yval = pixy.ccc.blocks[i].m_y;
  portTwo.print(150);
}

The 'core' arduino is running this code to take readings from the soft serial and printing to hard serial:

#include <SoftwareSerial.h>
SoftwareSerial portOne(4, 5); //software serial #1: RX = digital pin 4, TX = digital pin 5 - from front pixy
SoftwareSerial portTwo(6, 7); //software serial #1: RX = digital pin 6, TX = digital pin 7 - from bottom pixy


void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ;
  }

  portOne.begin(9600);
  portTwo.begin(9600);

}

void loop() {
  portOne.listen();
  Serial.println("Data from port one:");
  while (portOne.available() > 0) {
    int inByte = portOne.read();
    Serial.write(inByte);
  }
  Serial.println();

  portTwo.listen();
  Serial.println("Data from port two:");
  while (portTwo.available() > 0) {
    char inByte = portTwo.read();
    Serial.write(inByte); 
  } 
  Serial.println();

}

and the monitor feed I get from it at the moment is this:

Data from port one:
⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮
Data from port two:

Data from port one:
⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮O⸮⸮m⸮⸮m⸮⸮⸮⸮O⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮>⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮w⸮⸮⸮⸮⸮⸮w⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮O⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮
Data from port two:

Data from port one:
⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮>⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮?⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮O⸮⸮o⸮⸮o⸮⸮o⸮⸮O⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮~⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮|⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮w⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮w⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮;⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮߿⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮_⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮o⸮⸮
Data from port two:

Data from port one:
⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮wuw?w7www⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮o⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮|⸮⸮⸮⸮⸮}⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮{⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮o⸮⸮⸮⸮⸮?⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮
Data from port two:

Data from port one:
⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮>⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮?⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮ۻ⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮{⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮{⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮w⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮?⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮o⸮⸮⸮⸮⸮⸮
Data from port two:
(etc)

Hardware wise, the current setup - with core arduino connected to USB cable/PC, and the other two being powered by the power plug - is the attached image from Fritzing.

Any insights at all would be greatly appreciated! This is for my year 12 project, so if what I'm doing isn't even possible, some alternate suggestions would be terriffic!

Cheers, ProfessoRJ13

as I am using the ICSP (I think that's what it's called? 6-pin header on end of Uno), I can only hook up one Pixy to an arduino at a time.

What does using the ICSP pins have to do with connecting a Pixy to the Uno ?

If you are using 2 instances of SoftwareSerial on the same Uno then stop right now and use a Mega instead for the master so that you can use 2 of its 4 hardware UARTs

If the 2 slaves are sending data asynchronously then your current setup will not work. It is just possible that if you change the project so that each slave Uno sends data on receipt of a command from the master then you could make it work

ProfessoRJ13:
I want to use software serial from 2 different Arduino Uno's to transmit the coordinate value (x is from 0 to 315, y is from 0 to 207) from each Pixy (which isn't the problem), and transmit them over software serial ports to a 3rd Arduino,

Use a Mega for the 3rd Arduino as it has 3 spare HardwareSerial ports which work very much better than SoftwareSerial. That way it will have no trouble receiving data from the two Unos

...R
Serial Input Basics - simple reliable non-blocking ways to receive data.

I find this kind of advice strange: Do you have a VW Golf? Better drive a Lamborghini!

I find this kind of advice strange

Why? OP said:

ProfessoRJ13:
Any insights at all would be greatly appreciated!

RudolfAtRTC:
I find this kind of advice strange: Do you have a VW Golf? Better drive a Lamborghini!

If you want really fast acceleration then you need a high performance car. No amount of fiddling with the Golf will match it - though there may well be cheaper performance cars than a Lamborghini.

Coming back down to earth - some jobs are much easier to do when you have the appropriate tool. In this case the value of time wasted trying to get this to work with 3 Unos would easily exceed the price of a Mega.

...R

Possibly use I2C to communicate between the arduinos, multiple software serials are problematic.

Do you really need three arduinos? Is a single UNO capable of handling the cam and receiving data from the 2nd UNO, while also doing the additional processing?

Does anyone know if a single UNO can handle two pixycam2's at once? The fact that the default connector goes to the ICSP pins does not necessarily mean you cannot connect two of them.

My preference would be to use Nanos for the pixycam boards, and use the hardware serial port instead of software serial, I doubt the Serial debugging output is needed when this is actually operational, although you could structure the pixycam data output so that the 'core' arduino can easily ignore everything except the desired data and then use the same Serial for both.

david_2018:
Possibly use I2C to communicate between the arduinos, multiple software serials are problematic.

That's a good idea - I had forgotten about that option. It should work fine with 3 Unos.

This Arduino to Arduino I2C Tutorial may help.

...R

RudolfAtRTC:
Do you have a VW Golf? Better drive a Lamborghini!

That is just being a smartarse. The Mega isn't a Lamborghini, it is a solution to a problem. Further, if OP really does need all that serial stuff, a single Mega could save him three Unos.

For all that, the actual problem is far from clear, and may even be born of a misconception. I would certainly question this.

ProfessoRJ13:
However, as I am using the ICSP (I think that's what it's called? 6-pin header on end of Uno), I can only hook up one Pixy to an arduino at a time.

I don't know anything about Pixy2, other than it can be used on the SPI bus - something that the OP might actually be aware of. So, what is all this serial stuff really about, and why cannot a single Arduino run two Pixy2s?

If the Pixy2 is a resources hog, maybe a Mega is required to handle two. That would have to be a saner solution than three Unos. (Just an alternate suggestion....)

Thanks for all the replies so far! In answer to a bunch of the stuff brought up here:
Firstly, to the people suggesting I use a mega - I would love to, but the way I am connecting to the DMX lighting system is through a DMX shield for Uno, so unless I can find an alternative for that I was hoping to stick with the Uno.
The other issue with using hardware serial to communicate is that the DMX shield https://core-electronics.com.au/dmx-shield.html piggybacks off the hardware serial, so the arduino is unable to send/recieve hardware serial information while the shield is operating, thus why I turned to soft serial.

UKHeliBob - The pixy2 comes with a cable for those pins on the arduino, and to the people who said if I could run 2 off the same arduino, i researched this as much as I could and found nothing on it, as pixy runs off certain protocols which I believe mean that I can only have 1. - wiki:v2:porting_guide [Documentation]

RudolfAtRTC - It's all good, I appreciate any advice!

david_2018 & Robin2 - Thanks for the I2C suggestion - I'll read the link and ponder!

Nick_Pyner - Yes, I would much prefer to use 1 arduino, but as I said in response to UKHeliBob, I don't believe it's possible to run 2 pixy's on a single arduino.

Thanks so much for the responses so far! I'll see what happens when I try out I2C.

ProfessoRJ13:
Firstly, to the people suggesting I use a mega - I would love to, but the way I am connecting to the DMX lighting system is through a DMX shield for Uno, so unless I can find an alternative for that I was hoping to stick with the Uno.

I think this is nonsense. God only knows what a DMX shield is but I bet one made for a Uno will fit on a Mega. The most you might have to do to pursuade it into action is provide jumpers for it to use the I2C bus and/or SPI bus. If it has the central 6-pin cluster, you are OK for SPI as it comes out of the box.

The other issue with using hardware serial to communicate is that the DMX shield (https://core-electronics.com.au/dmx-shield.html) piggybacks off the hardware serial, so the arduino is unable to send/recieve hardware serial information while the shield is operating, thus why I turned to soft serial.

And I'm betting this is nonsense too. It is most certainly incoherent. About the worst that can happen in this arena is that you are likely to need to disconnect hardware serial devices when you upload your programme. Your term "piggybacking off hardware serial" is just irrelevant technobabble.
I think you should start over and read the PixyWiki again, particularly the section on interfaces. Nothing you have said, and nothing I know, clearly suggests that you cannot run two Pixy2s on one Uno. As I said above, it may be that a Uno hasn't enough grunt to run two but I bet you don't know that either, and I'm just speculating.

I doubt that it is normal to run two devices of the same type on one bus, but I'm sure somebody has done it. Besides, the way things are, just about the worst that can happen is that you may be obliged to run one Pixy2 on SPI and the other on 12C - or even serial...

One point worthy of note is that the Pixy2 carries quite a bit of on-board memory, which surely lightens the load on the Uno, thereby making it more likely that it can run two.

Nick_Pyner:
I think this is nonsense. God only knows what a DMX shield is but I bet one made for a Uno will fit on a Mega.

If you look at the link I sent, you will see that it won't fit on a mega.

Nick_Pyner:
Nothing you have said, and nothing I know, clearly suggests that you cannot run two Pixy2s on one Uno.

I doubt that it is normal to run two devices of the same type on one bus, but I'm sure somebody has done it. Besides, the way things are, just about the worst that can happen is that you may be obliged to run one Pixy2 on SPI and the other on 12C - or even serial...

I spent literal days trying to figure out how to do this, and couldnt find any mention of other people who have either. I even read an entire university report on people using pixys and no mention of it anywhere.
I was wanting to use the premade arduino libraries and connections, because I believe that at this point, doing my own thing is beyond my abilities. I thought a simpler solution was to transmit digits from one arduino to another.
I might be able to get away with only using 2 unos - one for the second pixy and the other with the DMX and first pixy. It's quite hard to figure out, as I don't have the pixys with me yet, or the shield for that matter, as I dont want to blow $200+ before realising it's not possible.
Thanks for the suggestion, but I would prefer to keep down the current track unless it is not possible.

Cheers!

If you look at the link I sent, you will see that it won't fit on a mega.

I have corrected the link and it now works

It is not clear to me what stops the shield being used with a Mega

ProfessoRJ13:
If you look at the link I sent, you will see that it won't fit on a mega.

There is no need to look at the link. A shield for a Uno will fit on a Mega. This does not necessarily mean it fits ideally, but it will fit. You may also find that the shield you link to is not the best choice for your purpose anyway, as you are already departing from a norm. I'm not sure how relevant the above is though, because the more one looks at this, the more one concludes that this job can be done with a single Uno. While using software serial is a means of last resort, using a swag of Unos is surely possible, but I'm sure it is not the sort of thing that you would want to show your mother. If you insist on going that route, replacing one Uno with a Mega is probably a good idea.

couldn't find any mention of other people who have either. I even read an entire university report on people using pixys and no mention of it anywhere.

This may mean no more than that you haven't been looking hard enough. It may simply mean that not many people need two Pixys. It may also mean that, if you can run one, running two is so easy it doesn't warrant mentioning. The university report you really need is the one that says it cannot be done, and gives the reason why.

I again submit that you should look at this more deeply. The fact that you have spent days on this and only come up with a mish-mash of software serial says quite a lot, and it is very clear that the best thing you have done so far is not buy anything.

The shield connects using the layout of pins fitted to the uno and plugs on top of every pin. How would I go about modifying this for a mega?

The reason I turned to the forum for help was becase I couldn't find anything. Instead of suggesting to go and look harder, would you be able to give suggestions on how to actually put 2 pixys on an arduino?

"However, as I am using the ICSP (I think that's what it's called? 6-pin header on end of Uno), I can only hook up one Pixy to an arduino at a time.

Well, ICSP lets you connect most of the SPI bus - SCK, MISO, MOSI.
What the 6-pin connector doesn't get you is a slave select - that comes from D10, D7, D4, etc.
So you need to figure out what the default pin is that is used for the first PixyCam, and then figure out how to use a 2nd slave select so you can talk to the 2nd PixyCam. SCK, MISO, and MOSI get connected in parallel to both devices (and 5V and Gnd, and Reset if used).

Have a look at the wiki page on how to talk to Pixy2, there is an option for enabling a slave select line for multiple devices on the SPI bus, although that is not implemented through the ICSP connector.

CrossRoads:
Well, ICSP lets you connect most of the SPI bus - SCK, MISO, MOSI.
What the 6-pin connector doesn't get you is a slave select - that comes from D10, D7, D4, etc.
So you need to figure out what the default pin is that is used for the first PixyCam, and then figure out how to use a 2nd slave select so you can talk to the 2nd PixyCam. SCK, MISO, and MOSI get connected in parallel to both devices (and 5V and Gnd, and Reset if used).

Right, I think I get where youre going, but could you elaborate, as my familiarity with SPI only comes from using an RFID scanner.
So I need to find which pin of the 6-pin cable is SCK, MISO, MOSI, GND, RST and 5v and take a parallel wire from that pin to go to the 2nd pixy? Would I then end up having both pixys plugged into the same 6-pin header?

Also david, I'm not famillier with what a slave select line is. I'll read the wiki again and see if I can get my head around it.
My past arduino skills is just basic stuff eg line following bot, so this is quite a jump for me haha

ProfessoRJ13:
The shield connects using the layout of pins fitted to the uno and plugs on top of every pin. How would I go about modifying this for a mega?

The Mega has a connector layout identical to the UNO, with an additional three connectors for the pins that the UNO lacks. Any shield that plugs onto an UNO should fit onto a Mega, but there are a few functional differences in the pins that may require modification to the code.

I'm not famillier with what a slave select line is.

The slave select (SS) line is used to select which SPI device the UNO is communicating with, allowing multiple devices to be attached to the SPI bus.

With the DMX shield you linked, the ICSP connector will not be accessible, but on an UNO you can use D11, D12, and D13 for MOSI, MISO, and SCK.

ProfessoRJ13:
The shield connects using the layout of pins fitted to the uno and plugs on top of every pin. How would I go about modifying this for a mega?

You plug it in where it will fit. This will be self-evident. Note that Mega uses different pins for SPI and I2C bus. This does not prevent you from using a Uno shield on a Mega, it simply means that you may have to make other provisions for those bus connections. As an example, if you need to use the I2C bus, you may run jumpers from the shield's A4,A5 to Mega 20,21.

would you be able to give suggestions on how to actually put 2 pixys on an arduino?

Well, it is very hard to see what you understand. It is not even clear that you know what a bus is, or that you have yourself properly read the wiki that you link to. I know virtually nothing about Pixy, but it seems to me that it is so versatile it will be hard to go wrong. In case you are not aware of it, a bus means that a multitude of compatible devices can share the same pins on Arduino. So that's the pin problem solved - if there ever was a problem. I have already said that you are not obliged to use one bus. It may be more convenient to use both SPI and I2C. It is likely that both libraries will fit in a Uno. Another consideration is whether Uno has enough memory for the job, but I have already addressed that. Then there is the matter of transporting the data, for which a Mega may be more suitable, but I think a Uno will suffice.
No matter what Arduino or shield you use, or how many, there is no obligation for you to use the ICSP cluster. They are just alternative SPI pins, sans the selector.