Arduino (LEDs) not being responsive to received bytes from i2c and Roborio

No matter what we’ve tried, our code:

Subsystem:


package frc.robot.subsystems;

import frc.robot.Robot;
import edu.wpi.first.wpilibj.I2C;
import frc.robot.OI;
import edu.wpi.first.wpilibj.I2C.Port;
import edu.wpi.first.wpilibj.smartdashboard.*;
import edu.wpi.first.wpilibj.command.Subsystem;
import frc.robot.commands.ArduinoCommand;

import edu.wpi.first.wpilibj.DriverStation;
import edu.wpi.first.wpilibj.DriverStation.Alliance;

public class ArduinoSubsystem extends Subsystem {

	private static I2C Wire = new I2C(Port.kOnboard, 4);//uses the i2c port on the RoboRIO													//uses address 4, must match arduino
	private static final int MAX_BYTES = 32;

	//String status = "";

	public Alliance getAlliance() {
		return DriverStation.getInstance().getAlliance();
	}

	public void write(){//writes to the arduino 
		
		String LEDColor = "none";

		if (getAlliance() == Alliance.Red) {
			LEDColor = "red";
		}
		if (getAlliance() == Alliance.Blue) {
			LEDColor = "blue";
		}
		if (getAlliance() == Alliance.Invalid) {
			LEDColor = "none";
		}

		LEDColor = "blue";

		char[] CharArray = LEDColor.toCharArray();//creates a char array from the input string
		byte[] WriteData = new byte[CharArray.length];//creates a byte array from the char array
		for (int i = 0; i < CharArray.length; i++) {//writes each byte to the arduino
			WriteData[i] = (byte)CharArray[i];//adds the char elements to the byte array 
		}
		Wire.writeBulk(WriteData, WriteData.length);
		//Wire.transaction(WriteData, WriteData.length, null, 0);//sends each byte to arduino
	}

	public Arduino getArduino(){//reads the data from arduino and saves it
		String info[] = read().split("\\|");//everytime a "|" is used it splits the data,
		Arduino arduino = new Arduino();  //creates a new packet to hold the data 
		if(info[0].equals("none") || info[0].equals("")){//checks to make sure there is data 
			arduino.x = -1;//the x val will never be -1 so we can text later in code to make sure 
			arduino.y = -1;
			arduino.area = -1;
			if (info.length >= 2) {
				arduino.distance = Double.parseDouble(info[1]);
			}
		}else if(info.length >= 3){//if there is an x, y, and area value the length equals 3
			arduino.x = Double.parseDouble(info[0]);//set x
			arduino.y = Double.parseDouble(info[1]);//set y
			arduino.area = Double.parseDouble(info[2]);//set area
			arduino.distance = Double.parseDouble(info[3]);
		}
		return arduino;
	}

	public void getData() {
		Arduino receive = getArduino();
		//System.out.println(receive.distance);
		if (OI.leftJoystick.getRawButtonPressed(12)) {
			System.out.println("Test:" + receive.x + " | " + receive.y + " | " + receive.area);
			System.out.println("Distance: " + receive.distance);
		}
	}

	private String read(){//function to read the data from arduino
		byte[] data = new byte[MAX_BYTES];//create a byte array to hold the incoming data
		Wire.read(4, MAX_BYTES, data);//use address 4 on i2c and store it in data
		String output = new String(data);//create a string from the byte array
		int pt = output.indexOf((char)255);
		return (String) output.subSequence(0, pt < 0 ? 0 : pt);
	}

	public void initDefaultCommand() {
        setDefaultCommand(new ArduinoCommand());
	}
	
}

Command:


import edu.wpi.first.wpilibj.command.Command;
import frc.robot.Robot;
import frc.robot.RobotMap;

import static frc.robot.OI.*;

public class ArduinoCommand extends Command {

	public ArduinoCommand() {
		requires(Robot.LED);
	}

	@Override
	protected void initialize() {
	}

	@Override
	protected void execute() {
		Robot.LED.write();
    }

	@Override
	protected boolean isFinished() {
		return false;
	}

	@Override

	protected void end() {
	}

	@Override
	protected void interrupted() {
	}

}

Arduino:

#include <FastLED.h>
#include <SPI.h>
#include <Wire.h>

#define LED_PIN     5
#define NUM_LEDS    300
#define BRIGHTNESS  64
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 100

// This example shows several ways to set up and use 'palettes' of colors
// with FastLED.
//
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
//
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code.  Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
//
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
//
// Some notes on the more abstract 'theory and practice' of
// FastLED compact palettes are at the bottom of this file.

//plug sda on RoboRIO into A4
//plug scl on RoboRIO into A5
//connect the two grounds

String piOutput = "none";//string to be sent to the robot
               
String input = "blank";  //string received from the robot

String x;
// Get x value from Shuffleboard.
int y = 1;

CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;


void setup() {
    Serial.begin(9600);
    Wire.begin(4);
    Wire.onReceive(receiveEvent);
    delay( 3000 ); // power-up safety delay
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness(  BRIGHTNESS );

    x = "none";
    
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;
}

void loop()
{    
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */

    if (!x.equals("red") && !x.equals("blue")) {
      y = 0;
      for( int i = 0; y = 1; i++) {
        //recieve x from RoboRIO via I2C
        leds[i] = CRGB::White;
        //leds[i] = CRGB::Green;
        //if White turns Red
        //change to latter code
        FastLED.show();
        if (x.equals("red") || x.equals("blue")) {
          int y = 1;
        }
      }
    }
    
    else if (x.equals("red")) {
      y = 0;
      for( int i = 0; y = 1; i++) {
        //recieve x from RoboRIO via I2C
        leds[i] = CRGB::Red;
        FastLED.show();
      }
    }
    else if (x.equals("blue")) {
      y = 0;
      for( int i = 0; y = 1; i++) {
        //recieve x from RoboRIO via I2C
        leds[i] = CRGB::Blue;
        FastLED.show();
      }
    }
    /*Was rainbow palette but doesn't work,
    FillLEDS to UPDATES_PER_SECONDS) };
    needs to be in a void loop(), but
    a void loop() can't be in another
    void loop, which we already have.
    So this code only runs red and blue.
    while (x.equals("2")) {
      FillLEDsFromPaletteColors( startIndex);
      FastLED.show();
      FastLED.delay(1000 / UPDATES_PER_SECOND);
    }*/
  }
void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
    uint8_t brightness = 255;
    
}

void ChangePalettePeriodically()
{
    uint8_t secondHand = (millis() / 1000) % 60;
    static uint8_t lastSecond = 99;
    
}


void receiveEvent(int bytes) {//called when RoboRIO "gives" this device a message
  String LED = "";
 
  while ( Wire.available() > 0 )
  {
    char n=(char)Wire.read();
    if(((int)n)>((int)(' ')))
    LED += n; 
  }
  x = LED;
 }


const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{
    CRGB::Red,
    CRGB::Gray, // 'white' is too bright compared to red and blue
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Red,
    CRGB::Gray,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Blue,
    CRGB::Black,
    CRGB::Black
};

Hardware:
LEDs are wired into pwm port 5 on the arduino
The arduino is connected to the roborio by the usb port
i2c: scl = A5, sda = A4

Are you trying to power your LEDs from the PWM port? It won’t provide enough current (amperes).

No, but the Arduino’s themselves have a PWM port. We are using Arduino Unos, and on the left side, it says “PWM Digital” and we put in one of the wires into number 5

What are you using the PWM port for?

the PWM port sends data from the arduino to the LEDs

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