Ambilight - Amblone - Arduino MEGA

0

Witam,
zainteresował mnie ostatnio projekt: http://majsterkowo.pl/ambient-light-dyn ... go-ekranu/
Sprawiłem sobie ostatnio coś takiego, jednak chciałem to zrobić na arduino MEGA, nie UNO gdyż nieodpowiada mi miganie diod spowodowane SoftPWM.
Kod do arduino pobrałem z amblone.com jak i program (Amblone 1.3).
Sketch:

 // Amblone code for the Arduino Mega
// Author: Bart van der Drift

// License:
// Anyone is free to change, redistribute or copy parts of this code
// as long as it is not for commercial purposes
// Please be so kind to pay credit where due

//---------------------------------------------------------------------------
//---------------------------------- DEFINES --------------------------------
//---------------------------------------------------------------------------



// Flags for the USB communication protocol
#include <LiquidCrystal.h>
#define C_SF1 0xF1 // Startflag for 1-channel mode (1 RGB channel)
#define C_SF2 0xF2 // Startflag for 2-channel mode (2 RGB channels)
#define C_SF3 0xF3 // Startflag for 3-channel mode (3 RGB channels)
#define C_SF4 0xF4 // Startflag for 4-channel mode (4 RGB channels)
#define C_END 0x33 // End flag
#define C_ESC 0x99 // Escape character

// States for receiving the information, see the flow chart for more info
#define S_WAIT_FOR_SF  0
#define S_RECV_RGB     1
#define S_RECV_RGB_ESC 2

//---------------------------------------------------------------------------
//--------------------------- FUNCTION DECLARATIONS -------------------------
//---------------------------------------------------------------------------

// Receives bytes and returns true if a valid packet was received
bool PacketReceived();

// Uses the rgb values to set the PWMs
void SetPWMs();

//---------------------------------------------------------------------------
//--------------------------- VARIABLE DECLARATIONS -------------------------
//---------------------------------------------------------------------------

int pulse = 0;

// State we are in: one of the S_* defines
int State = 0;
// The payload of a received message
int Payload[32];
// The amount of RGB values we have received
int ByteCount = 0;
// The character we received
int Recv;

// The amount of RGB channels we are using
int ChannelMode;

// PWM pins for channel 1
int r1_pin = 2;
int g1_pin = 3;
int b1_pin = 4;

// PWM pins for channel 2
int r2_pin = 5;
int g2_pin = 6;
int b2_pin = 7;

// PWM pins for channel 3
int r3_pin = 8;
int g3_pin = 9;
int b3_pin = 10;

// PWM pins for channel 4
int r4_pin = 11;
int g4_pin = 12;
int b4_pin = 13;

LiquidCrystal lcd(22, 24, 26, 28, 30, 32);
//---------------------------------------------------------------------------
//----------------------------- IMPLEMENTATIONS -----------------------------
//---------------------------------------------------------------------------

void setup()   {                
  // initialize the serial communication
  Serial.begin(256000);  // opens serial port, sets data rate to 256000 bps
  
  TCCR0B = TCCR0B & 0b11111000 | 0x2;
  TCCR1B = TCCR0B & 0b11111000 | 0x2;
  TCCR2B = TCCR0B & 0b11111000 | 0x2;
  TCCR3B = TCCR0B & 0b11111000 | 0x2;
  TCCR4B = TCCR0B & 0b11111000 | 0x2;
  
  pinMode(53, OUTPUT);
  digitalWrite(53, LOW);
  State = S_WAIT_FOR_SF;

  lcd.begin(16, 2);
  
}
//---------------------------------------------------------------------------

void loop()                     
{
  if (Serial.available() > 0) 
  {
     if (PacketReceived())
     {
        SetPWMs();
     }
  }
  lcd.clear();
}
//---------------------------------------------------------------------------

bool PacketReceived() {
  Recv = Serial.read();

  switch (State) {
    case S_WAIT_FOR_SF:
      // =============================== Wait for start flag state
      switch (Recv) {
        case C_SF1:
          // Start flag for 1-channel mode
          ChannelMode = 1;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
        case C_SF2:
          // Start flag for 2-channel mode
          ChannelMode = 2;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
      case 243://C_SF3:
          // Start flag for 3-channel mode
          ChannelMode = 3;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
        case C_SF4:
          // Start flag for 4-channel mode
          ChannelMode = 4;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
        default:
          // No action for all other characters
          return false;
      }
      break;
    case S_RECV_RGB:
      // =============================== RGB Data reception state
      switch (Recv) {
        case C_SF1:
          // Start flag for 1-channel mode
          ChannelMode = 1;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
        case C_SF2:
          // Start flag for 2-channel mode
          ChannelMode = 2;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
        case C_SF3:
          // Start flag for 3-channel mode
          ChannelMode = 3;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
        case C_SF4:
          // Start flag for 4-channel mode
          ChannelMode = 4;
          State = S_RECV_RGB;
          ByteCount = 0;
          return false;
      case C_END:
          // End Flag
          // For each channel, we should have received 3 values. If so, we have received a valid packet
         lcd.home();
         lcd.print("BC: ");
         lcd.setCursor(5, 0);
         lcd.print(ByteCount);
         lcd.setCursor(0, 1);
         lcd.print("CM: ");
         lcd.setCursor(5, 1);
         lcd.print(ChannelMode * 3);
         delay(1000);
          if (ByteCount == ChannelMode * 3) {
            State = S_WAIT_FOR_SF;
            ByteCount = 0;
            return true; // <------------------------ TRUE IS RETURNED
          }
          else {
            // Something's gone wrong: restart
            State = S_WAIT_FOR_SF;
            ByteCount = 0;
            return false;
          }
        case C_ESC:
          // Escape character
          State = S_RECV_RGB_ESC;
          return false;
        default:
          // The character received wasn't a flag, so store it as an RGB value        
          Payload[ByteCount] = Recv;
          ByteCount++;
          return false;
      }
      case S_RECV_RGB_ESC:
        // =============================== RGB Escaped data reception state
        // Store the value in the payload, no matter what it is
        Payload[ByteCount] = Recv;
        ByteCount++;
        State = S_RECV_RGB;
        return false;
  }
  
  return false;
}
//---------------------------------------------------------------------------

void SetPWMs() {
  // Channel 1
  analogWrite(r1_pin, Payload[0]);
  analogWrite(g1_pin, Payload[1]);
  analogWrite(b1_pin, Payload[2]);
  
  // Channel 2
  if (ChannelMode > 1) {
    analogWrite(r2_pin, Payload[3]);
    analogWrite(g2_pin, Payload[4]);
    analogWrite(b2_pin, Payload[5]);
  }
  else {
    // turn the rest to 0 (black)
    analogWrite(r2_pin, 0);
    analogWrite(g2_pin, 0);
    analogWrite(b2_pin, 0);
    
    analogWrite(r3_pin, 0);
    analogWrite(g3_pin, 0);
    analogWrite(b3_pin, 0);
    
    analogWrite(r4_pin, 0);
    analogWrite(g4_pin, 0);
    analogWrite(b4_pin, 0);
  }

  // Channel 3
  if (ChannelMode > 2) {
    analogWrite(r3_pin, Payload[6]);
    analogWrite(g3_pin, Payload[7]);
    analogWrite(b3_pin, Payload[8]);
  }
  else {
    // turn the rest to 0 (black)
    analogWrite(r3_pin, 0);
    analogWrite(g3_pin, 0);
    analogWrite(b3_pin, 0);
    
    analogWrite(r4_pin, 0);
    analogWrite(g4_pin, 0);
    analogWrite(b4_pin, 0);
  }
  
  // Channel 4
  if (ChannelMode > 3) {
    analogWrite(r4_pin, Payload[9]);
    analogWrite(g4_pin, Payload[10]);
    analogWrite(b4_pin, Payload[11]);
  }
  else {
    // turn the rest to 0 (black)
    analogWrite(r4_pin, 0);
    analogWrite(g4_pin, 0);
    analogWrite(b4_pin, 0);
  }
}
//---------------------------------------------------------------------------

Sketch jest delikatnie zmodyfikowany o LCD, ponieważ ambilight w ogóle się nie włączał (chciałem sprawdzić co jest przyczyną i doszedłem do tego).
Funkcja PacketReceived() praktycznie zawsze zwraca fałsz, ponieważ ByteCount != ChannelMode*3
Sprawdziłem to na LCD i faktycznie te wartości choć się zmieniają praktycznie zawsze są różne. Nie mam pojęcia co może być przyczyną i jak to zmodyfikować, żeby było dobrze. Jak zmienie tego if'a, albo w ogóle go usunę to wtedy ledy świecą, ale "jak chcą" - praktycznie w ogóle nie odwzorowują tego co na ekranie.
Tworzył może ktoś z was tego Ambilight'a i byłby w stanie coś podpowiedzieć ? Wiem, że to forum programistyczne, nie elektroniczne jednak mój problem zdaje się mieć podłoże programistyczne :P

Używam:
Laptop z Win 10
Dodatkowy monitor z którego pobieram dane (tam też są przyklejone diody LED)
Amblone 1.3
Arduino MEGA (klon z chin)
tranzystory ST13007A
rezystory 220 OM na bazę

0

Jaki masz kwarc i czy na pewno wysyłasz to co chcesz wysłać/odbierasz na uC to co wysłałeś na PC? Ustawienia są zgodne?

0

Mam arduino Mega, nie działam na samym uC. Z tego co widze to kwarc na arduino to 12Mhz.
Podpiąłem się converterem TTL do arduino i sprawdziłem pakiety jakie dostaje,
Kawałek z nich:

 ChannelMode: 4, ByteCount: 10, Pakiet[]: 0 0 0 0 0 0 0 0 0 0 
ChannelMode: 4, ByteCount: 11, Pakiet[]: 0 0 0 0 0 0 0 0 0 0 0 
ChannelMode: 4, ByteCount: 10, Pakiet[]: FE FE FE FE FE FE FE FE FE FE 
ChannelMode: 4, ByteCount: 10, Pakiet[]: FE FE FE FE FE FE FE FE FE FE 
ChannelMode: 4, ByteCount: 3, Pakiet[]: 1A 1A 1A 
ChannelMode: 4, ByteCount: 8, Pakiet[]: 34 34 34 34 34 34 34 34 
ChannelMode: 4, ByteCount: 8, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 8, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 8, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 8, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 8, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 8, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 7, Pakiet[]: 26 26 26 26 26 26 26 
ChannelMode: 4, ByteCount: 8, Pakiet[]: 91 91 91 91 91 91 91 91 
ChannelMode: 4, ByteCount: 8, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 10, Pakiet[]: FE FE FE FE FE FE FE FE FE FE 
ChannelMode: 4, ByteCount: 2, Pakiet[]: A6 A6 
ChannelMode: 4, ByteCount: 9, Pakiet[]: B4 B4 B4 B4 B4 B4 B4 B4 B4 
ChannelMode: 4, ByteCount: 9, Pakiet[]: FE FE FE FE FE FE FE FE FE 
ChannelMode: 4, ByteCount: 9, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 9, Pakiet[]: 34 34 34 34 34 34 34 34 34 
ChannelMode: 4, ByteCount: 9, Pakiet[]: 34 34 34 34 34 34 34 34 34 
ChannelMode: 4, ByteCount: 9, Pakiet[]: B4 B4 B4 B4 B4 B4 B4 B4 B4 
ChannelMode: 4, ByteCount: 8, Pakiet[]: 89 89 89 89 89 89 89 89 
ChannelMode: 4, ByteCount: 8, Pakiet[]: 89 89 89 89 89 89 89 89 
ChannelMode: 2, ByteCount: 3, Pakiet[]: 28 28 28 
ChannelMode: 4, ByteCount: 2, Pakiet[]: A3 A3 
ChannelMode: 4, ByteCount: 9, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 9, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 9, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 9, Pakiet[]: 9A 9A 9A 9A 9A 9A 9A 9A 9A 
ChannelMode: 4, ByteCount: 9, Pakiet[]: 9A 9A 9A 9A 9A 9A 9A 9A 9A 
ChannelMode: 4, ByteCount: 9, Pakiet[]: DA DA DA DA DA DA DA DA DA 
ChannelMode: 4, ByteCount: 9, Pakiet[]: DA DA DA DA DA DA DA DA DA 
ChannelMode: 4, ByteCount: 9, Pakiet[]: DA DA DA DA DA DA DA DA DA 
ChannelMode: 4, ByteCount: 9, Pakiet[]: B3 B3 B3 B3 B3 B3 B3 B3 B3 
ChannelMode: 4, ByteCount: 2, Pakiet[]: 43 43 
ChannelMode: 4, ByteCount: 2, Pakiet[]: 43 43 
ChannelMode: 4, ByteCount: 9, Pakiet[]: 9A 9A 9A 9A 9A 9A 9A 9A 9A 
ChannelMode: 4, ByteCount: 5, Pakiet[]: AC AC AC AC AC 
ChannelMode: 1, ByteCount: 4, Pakiet[]: 6B 6B 6B 6B 
ChannelMode: 4, ByteCount: 9, Pakiet[]: A6 A6 A6 A6 A6 A6 A6 A6 A6  

Funkcja PacketReceived i kawałek kodu (case C_END) który wyświetla te wartości:

boolean PacketReceived() {
	Recv = Serial.read();

	switch (State) {
	case S_WAIT_FOR_SF:
		// =============================== Wait for start flag state
		switch (Recv) {
		case C_SF1:
			// Start flag for 1-channel mode
			ChannelMode = 1;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		case C_SF2:
			// Start flag for 2-channel mode
			ChannelMode = 2;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		case 243://C_SF3:
			// Start flag for 3-channel mode
			ChannelMode = 3;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		case C_SF4:
			// Start flag for 4-channel mode
			ChannelMode = 4;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		default:
			// No action for all other characters
			return false;
		}
		break;
	case S_RECV_RGB:
		// =============================== RGB Data reception state
		switch (Recv) {
		case C_SF1:
			// Start flag for 1-channel mode
			ChannelMode = 1;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		case C_SF2:
			// Start flag for 2-channel mode
			ChannelMode = 2;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		case C_SF3:
			// Start flag for 3-channel mode
			ChannelMode = 3;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		case C_SF4:
			// Start flag for 4-channel mode
			ChannelMode = 4;
			State = S_RECV_RGB;
			ByteCount = 0;
			return false;
		case C_END:
			// End Flag
			// For each channel, we should have received 3 values. If so, we have received a valid packet
			Serial3.print("ChannelMode: ");
			Serial3.print(ChannelMode);
			Serial3.print(", ByteCount: ");
			Serial3.print(ByteCount);
			Serial3.print(", Pakiet[]: ");
			for (int i = 0; i < ByteCount; i++)
			{
			Serial3.print(Payload[ByteCount],HEX);
			Serial3.print(" ");
			}
			Serial3.println();
			if (ByteCount == ChannelMode * 3) {
				State = S_WAIT_FOR_SF;
				ByteCount = 0;
				return true; // <------------------------ TRUE IS RETURNED
			}
			else {
				// Something's gone wrong: restart
				State = S_WAIT_FOR_SF;
				ByteCount = 0;
				return false;
			}
		case C_ESC:
			// Escape character
			State = S_RECV_RGB_ESC;
			return false;
		default:
			// The character received wasn't a flag, so store it as an RGB value        
			Payload[ByteCount] = Recv;
			ByteCount++;
			return false;
		}
	case S_RECV_RGB_ESC:
		// =============================== RGB Escaped data reception state
		// Store the value in the payload, no matter what it is
		Payload[ByteCount] = Recv;
		ByteCount++;
		State = S_RECV_RGB;
		return false;
	}

	return false;
}

Wygląda jakbym za mało pakietów dostawał oraz złe pakiety, ponieważ każdy to odcień szarości R=G=B, czyli pewnie problem z programem :/

0

Nie bardzo rozumiem... Zmienna ByteCount przy inicjalizacji jest równa zero, potem w całym programie zmienia się tylko raz i to w miejscu, które i tak po jej zmianie zwróci fałsz. W każdej ścieżce dla switch(case) masz ustawienie ByteCount = 0 i zwrot fałszu, więc jak chcesz otrzymać ChannelMode == ByteCount*3 gdy ChannelMode z tego co widzę nigdy nie będzie równe 0?
Po drugie, widzę TCCR0B, a potem delay(1000), używanie jednocześnie timerów i zwykłych opóźnień, które jedynie co robią to mielą w procesorze parę rejestrów jest (według mnie) trochę niebezpiecznym połączeniem :P
Po trzecie

Mam arduino Mega, nie działam na samym uC. Z tego co widze to kwarc na arduino to 12Mhz.
Zawsze tak naprawdę działa się na samym uC, Arduino jest o tyle wygodne, że posiada w swoim IDE wiele makr i funkcji które upraszczają zabawę, ale pisząc

  TCCR0B = TCCR0B & 0b11111000 | 0x2;
  TCCR1B = TCCR0B & 0b11111000 | 0x2;
  TCCR2B = TCCR0B & 0b11111000 | 0x2;
  TCCR3B = TCCR0B & 0b11111000 | 0x2;
  TCCR4B = TCCR0B & 0b11111000 | 0x2; 

już dotykasz procesora. A zagłębiając się bardziej w Arduino i jego bity konfiguracyjne da się zmienić kwarc jakiego się używa, więc może sprawdź czy rzeczywiście korzystasz z 12 MHz, bo jeśli nie a Timery ustawiasz pod 12 MHz to może tutaj będzie źródło problemu?
Czwartą rzeczą, drobnostką jest brak wartości początkowej przy ChannelMode, nie wiem czy to ma znaczenie, ale kto wie... A czasem warto na to uważać, bo nie wiem co Arduino robi z brakiem inicjalizacji zmiennych :P
To tyle ode mnie, życzę powodzenia ;)

Pozdrawiam :)

P.S. Zawsze lubiłem Arduino :)

0

Z bytecount to działa tak że każdy pakiet który jest wysyłany z komputera ma jakąś flagę początkową, końcowa i jeszcze parę które są wypisane na górze. Jeśli arduino otrzyma flagę to ustawia bytecount na 0 ponieważ jest to albo początek albo koniec pakietu. Między flagą początkową a końcowa występuje informacja na jakie wartości zaswiecic poszczególne ledy(jeśli informacja nie jest flagą to w deafaulcie dodawana jest do payload i bytecount++), dlatego funkcja zwraca true tylko w jednym miejscu (jak już wiadomo że cały pakiet został odebrany).
Co do rejestrów to powiem szczerze że nie zaglebialem się jak to działa i po co to w tamtym miejscu, ale chyba będę musiał.

Aha. Co do delay(1000) to jak zobaczysz w moim 2 poście gdzie jest sama funkcja packetReceived to juz nie występuje.
Dodałem to jak wyswietlalem info na lcd, bo bez tego bym nic nie zobaczył. Wiem, że to było słabe rozwiązanie dlatego podłączyłem się pod TTL i sprawdziłem wartości pakietów na serialu. (Jednak nic to nie zmieniło w działaniu ambilight). :(

0

Zrobiłem parę testów, sprawdziłem na innym komputerze jednak ten sam problem.
Stwierdziłem, że napiszę sam program do zczytywania kolorów z monitora i wysyłania do arduino, jednak pojawił się tym razem problem z komunikacją.
Program w Javie, który napisałem:

import java.awt.AWTException;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import jssc.*;
import java.util.Enumeration;


public class Ambilight implements Runnable
{
	private Robot robot;
	private int WIDTH = 1920; // 2400
	private int HEIGHT = 1080; // 1350
	private int SECTIONS = 4;
	private int SECT_WIDTH = 300;
	private int SECT_HEIGHT = 300;
	private int SECT_SKIP = 10;
	private final static int DELAY = 100;
	private SerialPort serial;
	
	private static final String PORT_NAME = "COM5";
	
	public Ambilight() throws AWTException, IOException, SerialPortException
	{
		robot = new Robot();
		initSerial();
		Thread th = new Thread(this);
		th.start();
	}
	
	private void initSerial() throws SerialPortException
	{
	    serial = new SerialPort(PORT_NAME);
		serial.openPort();
		serial.setParams(SerialPort.BAUDRATE_9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
	}
	
	
	private Color[] getColors() throws IOException 
	{
		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
		GraphicsDevice[] gs = ge.getScreenDevices();
			
		Color[] leds = new Color[SECTIONS];
		leds[0] = Color.BLACK;
		leds[1] = Color.BLACK;
		leds[2] = Color.BLACK;
		leds[3] = Color.BLACK;
 
		if (gs.length > 0)
		{
			Rectangle rect = gs[0].getDefaultConfiguration().getBounds();
			BufferedImage screen = robot.createScreenCapture(new Rectangle((int)rect.getWidth(),0,WIDTH,HEIGHT));
			BufferedImage section1 = screen.getSubimage(WIDTH - SECT_WIDTH, 0, SECT_WIDTH, HEIGHT);
			BufferedImage section2 = screen.getSubimage(0, 0, 1920, SECT_HEIGHT);
			BufferedImage section3 = screen.getSubimage(0, HEIGHT - SECT_HEIGHT, 1920, SECT_HEIGHT);
			BufferedImage section4 = screen.getSubimage(0, 0, SECT_WIDTH, HEIGHT);
			Color section1AvgColor = getAvgColor(section1);
			Color section2AvgColor = getAvgColor(section2);
			Color section3AvgColor = getAvgColor(section3);
			Color section4AvgColor = getAvgColor(section4);
			leds[0] = section1AvgColor;
			leds[1] = section2AvgColor;
			leds[2] = section3AvgColor;
			leds[3] = section4AvgColor;
		}
		return leds;
	}
	
	private void sendColors(Color[] colors) throws IOException, SerialPortException
	{
		serial.writeByte((byte)0xff);
		for(int i = 0; i < SECTIONS; i++)
		{
			serial.writeByte((byte)colors[i].getRed());
			serial.writeByte((byte)colors[i].getGreen());
			serial.writeByte((byte)colors[i].getBlue());
		}
	}
	
	private Color getAvgColor(BufferedImage imgSection)
	{
		int r = 0;
		int g = 0;
		int b = 0;
		int loops = 0;
		
		for(int i = 0; i < imgSection.getWidth(); i += SECT_SKIP)
		{
			for(int j = 0; j < imgSection.getHeight(); j += SECT_SKIP)
			{
				Color color = new Color(imgSection.getRGB(i, j));
				r += color.getRed();
				g += color.getGreen();
				b += color.getBlue();
				loops++;
			}
		}
		return new Color(r/loops, g/loops, b/loops);
	}

	public void run()
	{
		while(true)
		{
			System.out.println("cos");
				try
				{
					Color[] colors = getColors();
					sendColors(colors);
				}
				catch (IOException | SerialPortException e1)
				{
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
					
				try
				{
					Thread.sleep(DELAY);
				}
				catch (InterruptedException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
	}
	
	public static void main(String[] args) throws AWTException, IOException, SerialPortException
	{
		new Ambilight();
	}
}

Odczytywanie kolorów z ekranu działa idealnie, bo sprawdzałem, jednak nie mogę dostarczyć tych wartości do arduino (Na arduino miga lampka TX -> nie powinna czasem RX skoro odbiera dane ?). Parę razy udało mi się odebrać te wartości, ale zazwyczaj arduino nic nie odbiera. Nie wiem od czego to zależy.
Program na arduino: (Póki co tylko sprawdzam czy te dane dochodzą, później zajmę się ustawianiem PWM na właściwe wartości).

void setup()
{
	Serial.begin(9600);
	Serial3.begin(9600);
}

void loop()
{
	if (Serial.available() > 0)
		Serial3.println(Serial.read());
	delay(1000);
}

Podłączenia:
COM5 w komputerze i Serial - Arduino Mega
COM7 w komputerze i Serial3 w Arduino - Konwerter TTL

0

Problem rozwiązany.
Na początku stwierdziłem, że zamienię i zacznę wysyłać dane przez TTL i ku mojemu zaskoczeniu ambilight zaczął działać :)
Potem zacząłem przeszukiwać internety czemu przez kabel nie chciało działać i okazało się, że kondensator 10uF między RESET i GND załatwił sprawę :P
Teraz normalnie przez Serial też działa. Dzięki za pomoc.
PS. Dlaczego Amblone dalej nie działa to nie wiem, ale jest tak dobry efekt tego co mam teraz, że nic innego mi nie potrzeba :) Każdemu polecam takie cudo :)

1 użytkowników online, w tym zalogowanych: 0, gości: 1