Neuer Bereich: Plugins, Skins & Tools made by Boxpirates - Plugins, Skins & Tools die direkt hier aus unserem Board kommen



Nachrüstambilight für alle Quellen

    This site uses cookies. By continuing to browse this site, you are agreeing to our use of cookies. More details

    • Nachrüstambilight für alle Quellen

      Hallo. Ich habe von @Anz den Tip bekommen mich hier mal schlau zu machen.

      Ich hatte bis vor einem halben Jahr auf meiner Uno 4K SE Enigmalight. Ich hatte aber keine extra Hardware, ich habe nur Huelampen mittels deren Entertainment API in der Enigmalight.conf eingebunden. Das Ergebnis fand ich super. Was nur dumm war, war halt die Tatsache das ja nur des Bild des TV Bildes und dessen Mediaplayer abgegriffen werden konnte.

      Da ich zu dem Zeitpunkt mit einem neuen OLED geliebäugelt habe entschied ich mich für einen Philips Ambilight OLED 804, dachte dann mit originalem Ambilight alles perfekt abgedeckt zu haben. Pustekuchen!

      Die Enttäuschung war groß als ich merkte das die Farbtreue der Lampen subjektiv gesehen schlechter war als beim Enigmalight, was jedoch das allerschlimmste ist und mich bis heute einfach nur mega nervt ist die Tatsache das bei dunklen/schwarzen Bildinhalten die Huelampen und das eingebaute Ambilight dunkel weiß leuchtet anstatt wie bei Enigmalight ganz ausgeht.

      Wenn ich den OLED mit Android als Betriebssystem rooten könnte, könnte ich bestimmt an die Config gelangen und das mit dem schwarzen Bild als Lampen aus regeln. Aber nach meinem jetzigen Kenntnisstand ist dies nicht möglich.

      Daher suche ich nach einer anderen Lösung.
      Was ich möchte:
      - Ambilight für jede Quelle (Quasi am HDMI Out des AV Receivers abgreifbar)
      - bei schwarzen Bild alle Lampen aus
      - Huelampen einbinden
      - Günstig wie möglich das ganze, der scheiss OLED war schon teuer genug :P



      Für Tipps wäre ich dankbar.

      p.s. Falls jemand fragt warum unbedingt Huelampen mit eingebunden werden müssen. Ich habe links und rechts neben dem TV Papierstehlampen mit jeweils zwei Huelampen. Der Effekt wenn farblich das Bild in die Breite gezogen wird sieht einfach sehr schön aus und daher könnte ich eher auf das hintere Ambilight verzichten als auf die Stehlampen.

      Post was edited 1 time, last by Bimmler ().


    • @pclin Anz sagte mir du stehst in engeren Kontakt zu den Leuten von Insanlight.

      Kannst du mir paar Tips oder Ratschläge geben?

      So wie ich das sehe um alle Quellen mit Ambilight versehen zu können bräuchte ich das HDFury DIVA Set was quasi auch die teuerste Variante wäre, richtig? Oder gibt es etwas was günstiger ist? Dann ist dieses Diva ja ein Minicomputer der für die Ansteuerung zuständig ist. Wäre es dort möglich eine Entertainment API einzubinden wie es auch unter Enigmalight möglich war?

    • du kannst das ganze auch über ein raspi realisieren für alle hdmi Quellen
      Gruß Reiter

      Fragen gehören ins Forum und nicht in mein Postfach



    • Kann der auch 4K 60hz Material inclusive HDR und Dolby Vision verarbeiteten was zentral aus meinem AV Receiver kommen würde. Dort wäre eine PS4, ein Fire TV Stick 4K und meine Uno 4K SE angeschlossen.
      Einen Raspi hab ich noch rumfliegen den ich zur Zeit nicht brauche.

      Wenn ja, hast du nähere Infos wie dies zu realisieren wäre?

    • wie wäre es wenn du dich da selbst bei insanelight erstmal etwas einliest...das ist schon alles sehr umfangreich da
      Gruß Reiter

      Fragen gehören ins Forum und nicht in mein Postfach



    • Das tue ich bereits, jedoch ist das Thema wie du selbst sagst sehr komplex. Daher habe ich gehofft hier paar erste Infos zu bekommen zu meinem geschilderten Wunsch :rolleyes:

      Davon ab bin ich aus einem anderen Forum hierhin verwiesen worden, da hier kompetente Leute bezüglich Insanelight am Werk sein sollen.

      Post was edited 1 time, last by Bimmler ().


    • Nachrüstambilight für alle Quellen

      Sind Sie auch ;)
      Ich würde da mal auf @pclin warten bis der wieder online ist.
      Denke er hat bestimmt eine Idee oder kann zu mindestens deine Fragen beantworten.
      Er ist derjenige von uns der sich am besten mit der Materie auskennt.
      Kein support für Internet-Sharing!

      Bitte füllt euer Profil aus (Box und Image) ,das erleichtert es uns Euch zu helfen

    • Ohne Pi und hyperion wird das nicht gehen, was dann aber genau funktioniert grade in Bezug auf die Hue kann ich dir auch nicht genau sagen.
      Die Diva kann man meines wissen nach nicht für die Hue verwenden, entweder für den externen Grabber oder ihre eigenen LED Sets.
      Die Diva ist was Formate angeht das beste Gerät incl. HDR und Dolby Vision usw.

      Am besten informierst du dich im Hyperion-forum, und stellst da deine Fragen.

      gruß pclin
      Dreambox ONE / TWO, DM920UHD, DM900UHD, DM820HD HDD + USB-HUB, Stick 64GB, USB-HDD, Wireless Touch Keyboard K400r, Wlan-Stick 11n
      (Flash) DP-OE2.6 (BAXII) eigenes OE2.6, Debian-Buster, Diverse
      (Flash) DP-OE2.5 (BAXII) eigenes OE2.5-e2+kodi+X, debian-stretch, Diverse
      AudioDSP: miniDSP 2x4HD
      TV: LG 65" SUHD
      Hyperion und Plugin HyperionControl auf der Dreambox ONE / TWO
      nodeMCU ESP8266 mit WLED Wlan 268 LED's SK6812-RGBW-NW 60 LED/m



      Ambilight for ever

    • Diva mit Grabber und Pi ist ja nicht billig, da bist du schnell bei 600 €
      Ich komme mit meinem Splitter und Grabber auf ca. 60 €, und kann alles was ich habe (incl. 4K HDR usw) damit mit Ambilight verwenden.
      Ich verwende keine Hue habe aber 5 Instanzen mit hyperion und WLED (EST8266) laufen, also Stripes hinter dem TV und 4 selbstgebaute 'Lampen' links/rechts, über und unter dem TV.

      Zu Dolby Vision kann ich nichts sagen, das kann aber bestimmt im Hyperion Forum geklärt werden.
      Auch die Diva hat bei Dolby Vision wohl Probleme.

      Schreib mal bitte welche Geräte du hast und wie du am AV Receivers abgreiffen möchtest, und welche Formate und Auflösungen du wirklich benötigst.

      gruß pclin
      Dreambox ONE / TWO, DM920UHD, DM900UHD, DM820HD HDD + USB-HUB, Stick 64GB, USB-HDD, Wireless Touch Keyboard K400r, Wlan-Stick 11n
      (Flash) DP-OE2.6 (BAXII) eigenes OE2.6, Debian-Buster, Diverse
      (Flash) DP-OE2.5 (BAXII) eigenes OE2.5-e2+kodi+X, debian-stretch, Diverse
      AudioDSP: miniDSP 2x4HD
      TV: LG 65" SUHD
      Hyperion und Plugin HyperionControl auf der Dreambox ONE / TWO
      nodeMCU ESP8266 mit WLED Wlan 268 LED's SK6812-RGBW-NW 60 LED/m



      Ambilight for ever

      Post was edited 1 time, last by pclin ().


    • Hi :)

      Also, ich habe einen Denon AV Receiver mit einem einzigen eARC fähigen HDMI Out, von dort hätte ich gedacht zentral das Signal abzugreifen. Bitte immer korrigieren wenn ich mit was falsch liege. Der dann noch anzuschaffende Fire TV Stick 4K, meine Uno 4K SE und die PS4 Pro sind dann an die HDMI Eingänge des AV Receivers angeschlossen. Als höchste Ausgabe wäre es 2160p mit 60hz und HDR der PS4 Pro. Über den Fire TV 4K und Netflix Premium würde halt 4K und Dolby Vision kommen.

      Ich habe hier noch einen Raspberry 3 rumliegen der momentan nicht genutzt wird.

      Ich versuche mal kurz das mit den Hues zu entwirren. Grundsätzlich müßte meine gewünschte Lösung mit jeder Hardwarekombination funktionieren, wo auch diese Lichtleisten (Instanzen) eingebunden sind. Denn ich habe damals ja Enigmalight auf der VU+ gehabt und dies genau so eingerichtet wie alle anderen Menschen die LEDs angesteuert haben .....zumindest das Grundgerüst ist ja da gleiche. Nur das in den Configs halt der Eintrag meiner Hues bzw. die Entertainment API mit Benutzername und Key stand anstatt die Angaben zu den Lichtleisten.

      Ich hab jetzt mal das Forum durchforstet, ich hatte es Anfang 2018 mir solange zusammen geschustert bis es lief. Ich poste hier mal zwei Configs davon. Wenn du sie dir durchließt verstehst du vielleicht eher wie die Heus eingebunden waren @pclin .

      .conf

      Source Code

      1. #[global]
      2. [device]
      3. name ambilight
      4. output /home/elight-addons/wifilight/philips_hue/dtls_client
      5. channels 6
      6. type popen
      7. interval 200000
      8. debug off
      9. [color]
      10. name red
      11. rgb FF0000
      12. [color]
      13. name green
      14. rgb 00FF00
      15. [color]
      16. name blue
      17. rgb 0000FF
      18. [light]
      19. position left
      20. name 1HU
      21. color red ambilight 1
      22. color green ambilight 2
      23. color blue ambilight 3
      24. hscan 0 15
      25. vscan 0 100
      26. [light]
      27. position right
      28. name 2HU
      29. color red ambilight 4
      30. color green ambilight 5
      31. color blue ambilight 6
      32. hscan 85 100
      33. vscan 0 100
      Show All



      Also denk dir mal die Hues weg. Ich brauche nur was, was halt das Videosignal bis oben genannte Auflösung abgreifen kann und was irgendwie mit editierbaren
      Configs arbeitet um normalerweise diverse LEDs ansteuert. Dann kann man weiter gucken um dann halt die Entertainment API von Philips ein zubinden in die Configs und die Hues so anzusteuern.

      Eins nach dem anderem :)

    • dtls_client.c Teil 1 (Nachricht zu lang)

      C Source Code

      1. /*
      2. * Simple DTLS client demonstration program
      3. *
      4. * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
      5. * SPDX-License-Identifier: Apache-2.0
      6. *
      7. * Licensed under the Apache License, Version 2.0 (the "License"); you may
      8. * not use this file except in compliance with the License.
      9. * You may obtain a copy of the License at
      10. *
      11. * http://www.apache.org/licenses/LICENSE-2.0
      12. *
      13. * Unless required by applicable law or agreed to in writing, software
      14. * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
      15. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      16. * See the License for the specific language governing permissions and
      17. * limitations under the License.
      18. *
      19. * This file is part of mbed TLS (https://tls.mbed.org)
      20. */
      21. #if !defined(MBEDTLS_CONFIG_FILE)
      22. #include "mbedtls/config.h"
      23. #else
      24. #include MBEDTLS_CONFIG_FILE
      25. #endif
      26. #if defined(MBEDTLS_PLATFORM_C)
      27. #include "mbedtls/platform.h"
      28. #else
      29. #include <stdio.h>
      30. #define mbedtls_printf printf
      31. #define mbedtls_fprintf fprintf
      32. #endif
      33. #if !defined(MBEDTLS_SSL_CLI_C) || !defined(MBEDTLS_SSL_PROTO_DTLS) || \
      34. !defined(MBEDTLS_NET_C) || !defined(MBEDTLS_TIMING_C) || \
      35. !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_CTR_DRBG_C) || \
      36. !defined(MBEDTLS_X509_CRT_PARSE_C) || !defined(MBEDTLS_RSA_C) || \
      37. !defined(MBEDTLS_CERTS_C) || !defined(MBEDTLS_PEM_PARSE_C)
      38. int main( void )
      39. {
      40. mbedtls_printf( "MBEDTLS_SSL_CLI_C and/or MBEDTLS_SSL_PROTO_DTLS and/or "
      41. "MBEDTLS_NET_C and/or MBEDTLS_TIMING_C and/or "
      42. "MBEDTLS_ENTROPY_C and/or MBEDTLS_CTR_DRBG_C and/or "
      43. "MBEDTLS_X509_CRT_PARSE_C and/or MBEDTLS_RSA_C and/or "
      44. "MBEDTLS_CERTS_C and/or MBEDTLS_PEM_PARSE_C not defined.\n" );
      45. return( 0 );
      46. }
      47. #else
      48. #include <string.h>
      49. #include <unistd.h>
      50. #include "mbedtls/net_sockets.h"
      51. #include "mbedtls/debug.h"
      52. #include "mbedtls/ssl.h"
      53. #include "mbedtls/entropy.h"
      54. #include "mbedtls/ctr_drbg.h"
      55. #include "mbedtls/error.h"
      56. #include "mbedtls/certs.h"
      57. #include "mbedtls/timing.h"
      58. #include "mbedtls/config.h"
      59. #define SERVER_PORT "2100"
      60. #define SERVER_NAME "Hue"
      61. #define SERVER_ADDR "192.168.178.20" /* forces IPv4 */
      62. #define MESSAGE "Echo this"
      63. #define DFL_PSK_IDENTITY "JYY78dfPdO4QC79s5V-T5Orw98WTl1XnjnlcQ-Mk"
      64. #define READ_TIMEOUT_MS 1000
      65. #define MAX_RETRY 5
      66. #define DEBUG_LEVEL 0
      67. static void my_debug( void *ctx, int level,
      68. const char *file, int line,
      69. const char *str )
      70. {
      71. ((void) level);
      72. mbedtls_fprintf( (FILE *) ctx, "%s:%04d: %s", file, line, str );
      73. fflush( (FILE *) ctx );
      74. }
      75. int main( int argc, char *argv[] )
      76. {
      77. int ret, len;
      78. mbedtls_net_context server_fd;
      79. uint32_t flags;
      80. unsigned char buf[1024];
      81. const char *pers = "dtls_client";
      82. int retry_left = MAX_RETRY;
      83. const char *psk_identity;
      84. const unsigned char psk[] = {0x2F, 0x3F, 0x5A, 0xFE, 0x5F, 0xA8, 0x5C, 0x97, 0xDA, 0x92, 0x29, 0x1B, 0xE0, 0xBF, 0x12, 0x98 };
      85. int force_ciphersuite[2];
      86. char message1[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      87. 0x01, 0x00, //version 1.0
      88. 0x01, //sequence number 1
      89. 0x00, 0x00, //reserved
      90. 0x00, //color mode RGB
      91. 0x01, //linear filter
      92. 0x00, 0x00, 0x03, //light 1
      93. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      94. 0x00, 0x00, 0x04, //light 2
      95. 0xff, 0xff, 0x00, 0x00, 0x00, 0x00
      96. };
      97. char message2[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      98. 0x01, 0x00, //version 1.0
      99. 0x01, //sequence number 1
      100. 0x00, 0x00, //reserved
      101. 0x00, //color mode RGB
      102. 0x01, //linear filter
      103. 0x00, 0x00, 0x03, //light 1
      104. 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
      105. 0x00, 0x00, 0x04, //light 2
      106. 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
      107. };
      108. mbedtls_entropy_context entropy;
      109. mbedtls_ctr_drbg_context ctr_drbg;
      110. mbedtls_ssl_context ssl;
      111. mbedtls_ssl_config conf;
      112. mbedtls_x509_crt cacert;
      113. mbedtls_timing_delay_context timer;
      114. ((void) argc);
      115. ((void) argv);
      116. #if defined(MBEDTLS_DEBUG_C)
      117. mbedtls_debug_set_threshold( DEBUG_LEVEL );
      118. #endif
      119. psk_identity = DFL_PSK_IDENTITY;
      120. force_ciphersuite[0]= MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256;
      121. force_ciphersuite[1]= 0;
      122. /*
      123. * set hue in the right mode
      124. */
      125. system("curl -X PUT -H \"Content-Type: application/json\" -d '{\"stream\":{\"active\":true}}' \"http://192.168.178.20/api/JYY78dfPdO4QC79s5V-T5Orw98WTl1XnjnlcQ-Mk/groups/8\"");
      126. /*
      127. * 0. Initialize the RNG and the session data
      128. */
      129. mbedtls_net_init( &server_fd );
      130. mbedtls_ssl_init( &ssl );
      131. mbedtls_ssl_config_init( &conf );
      132. mbedtls_x509_crt_init( &cacert );
      133. mbedtls_ctr_drbg_init( &ctr_drbg );
      134. mbedtls_printf( "\n . Seeding the random number generator..." );
      135. fflush( stdout );
      136. mbedtls_entropy_init( &entropy );
      137. if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
      138. (const unsigned char *) pers,
      139. strlen( pers ) ) ) != 0 )
      140. {
      141. mbedtls_printf( " failed\n ! mbedtls_ctr_drbg_seed returned %d\n", ret );
      142. goto exit;
      143. }
      144. mbedtls_printf( " ok\n" );
      145. /*
      146. * 0. Load certificates
      147. */
      148. mbedtls_printf( " . Loading the CA root certificate ..." );
      149. fflush( stdout );
      150. ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_cas_pem,
      151. mbedtls_test_cas_pem_len );
      152. if( ret < 0 )
      153. {
      154. mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned -0x%x\n\n", -ret );
      155. goto exit;
      156. }
      157. mbedtls_printf( " ok (%d skipped)\n", ret );
      158. /*
      159. * 1. Start the connection
      160. */
      161. mbedtls_printf( " . Connecting to udp/%s/%s...", SERVER_NAME, SERVER_PORT );
      162. fflush( stdout );
      163. if( ( ret = mbedtls_net_connect( &server_fd, SERVER_ADDR,
      164. SERVER_PORT, MBEDTLS_NET_PROTO_UDP ) ) != 0 )
      165. {
      166. mbedtls_printf( " failed\n ! mbedtls_net_connect returned %d\n\n", ret );
      167. goto exit;
      168. }
      169. mbedtls_printf( " ok\n" );
      170. /*
      171. * 2. Setup stuff
      172. */
      173. mbedtls_printf( " . Setting up the DTLS structure..." );
      174. fflush( stdout );
      175. if( ( ret = mbedtls_ssl_config_defaults( &conf,
      176. MBEDTLS_SSL_IS_CLIENT,
      177. MBEDTLS_SSL_TRANSPORT_DATAGRAM,
      178. MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )
      179. {
      180. mbedtls_printf( " failed\n ! mbedtls_ssl_config_defaults returned %d\n\n", ret );
      181. goto exit;
      182. }
      183. mbedtls_ssl_conf_transport(&conf, MBEDTLS_SSL_TRANSPORT_DATAGRAM);
      184. /* OPTIONAL is usually a bad choice for security, but makes interop easier
      185. * in this simplified example, in which the ca chain is hardcoded.
      186. * Production code should set a proper ca chain and use REQUIRED. */
      187. mbedtls_ssl_conf_authmode( &conf, MBEDTLS_SSL_VERIFY_OPTIONAL );
      188. mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL );
      189. mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );
      190. mbedtls_ssl_conf_dbg( &conf, my_debug, stdout );
      191. if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )
      192. {
      193. mbedtls_printf( " failed\n ! mbedtls_ssl_setup returned %d\n\n", ret );
      194. goto exit;
      195. }
      196. if( ( ret = mbedtls_ssl_conf_psk( &conf, psk, sizeof(psk),
      197. (const unsigned char *) psk_identity,
      198. strlen( psk_identity ) ) ) != 0 )
      199. {
      200. mbedtls_printf( " failed\n ! mbedtls_ssl_conf_psk returned %d\n\n", ret );
      201. goto exit;
      202. }
      203. mbedtls_ssl_conf_ciphersuites(&conf, force_ciphersuite);
      204. if( ( ret = mbedtls_ssl_set_hostname( &ssl, SERVER_NAME ) ) != 0 )
      205. {
      206. mbedtls_printf( " failed\n ! mbedtls_ssl_set_hostname returned %d\n\n", ret );
      207. goto exit;
      208. }
      Show All

    • dtls_client.c Teil 2 (Nachricht zu lang)

      Source Code

      1. mbedtls_ssl_set_bio( &ssl, &server_fd,
      2. mbedtls_net_send, mbedtls_net_recv, mbedtls_net_recv_timeout );
      3. mbedtls_ssl_set_timer_cb( &ssl, &timer, mbedtls_timing_set_delay,
      4. mbedtls_timing_get_delay );
      5. mbedtls_ssl_conf_handshake_timeout(&conf, 100, 60000);
      6. mbedtls_printf( " ok\n" );
      7. /*
      8. * 4. Handshake
      9. */
      10. mbedtls_printf( " . Performing the SSL/TLS handshake..." );
      11. fflush( stdout );
      12. do ret = mbedtls_ssl_handshake( &ssl );
      13. while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
      14. ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      15. if( ret != 0 )
      16. {
      17. mbedtls_printf( " failed\n ! mbedtls_ssl_handshake returned -0x%x\n\n", -ret );
      18. goto exit;
      19. }
      20. mbedtls_printf( " ok\n" );
      21. /*
      22. * 5. Verify the server certificate
      23. */
      24. mbedtls_printf( " . Verifying peer X.509 certificate..." );
      25. /* In real life, we would have used MBEDTLS_SSL_VERIFY_REQUIRED so that the
      26. * handshake would not succeed if the peer's cert is bad. Even if we used
      27. * MBEDTLS_SSL_VERIFY_OPTIONAL, we would bail out here if ret != 0 */
      28. if( ( flags = mbedtls_ssl_get_verify_result( &ssl ) ) != 0 )
      29. {
      30. char vrfy_buf[512];
      31. mbedtls_printf( " failed\n" );
      32. mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), " ! ", flags );
      33. mbedtls_printf( "%s\n", vrfy_buf );
      34. }
      35. else
      36. mbedtls_printf( " ok\n" );
      37. /*
      38. * 6. Write the echo request
      39. */
      40. send_request:
      41. mbedtls_printf( " > sending message" );
      42. fflush( stdout );
      43. char *line = NULL;
      44. while(1) {
      45. size_t size;
      46. if (getline(&line, &size, stdin) == -1) {
      47. mbedtls_printf("No line\n");
      48. } else {
      49. mbedtls_printf( "%s\n", line);
      50. }
      51. char* pEnd;
      52. float f1, f2, f3, f4, f5, f6;
      53. f1 = strtof (line, &pEnd);
      54. f2 = strtof (pEnd, &pEnd);
      55. f3 = strtof (pEnd, &pEnd);
      56. f4 = strtof (pEnd, &pEnd);
      57. f5 = strtof (pEnd, &pEnd);
      58. f6 = strtof (pEnd, NULL);
      59. f1 = f1*65535;
      60. f2 = f2*65535;
      61. f3 = f3*65535;
      62. f4 = f4*65535;
      63. f5 = f5*65535;
      64. f6 = f6*65535;
      65. int i1, i2, i3, i4, i5, i6;
      66. i1 = (int)f1;
      67. i2 = (int)f2;
      68. i3 = (int)f3;
      69. i4 = (int)f4;
      70. i5 = (int)f5;
      71. i6 = (int)f6;
      72. mbedtls_printf( "%x\n", i1);
      73. mbedtls_printf( "%x\n", i2);
      74. mbedtls_printf( "%x\n", i3);
      75. mbedtls_printf( "%x\n", i4);
      76. mbedtls_printf( "%x\n", i5);
      77. mbedtls_printf( "%x\n", i6);
      78. char first[5];
      79. char second[5];
      80. char third[5];
      81. char fourth[5];
      82. char fith[5];
      83. char sixth[5];
      84. sprintf(second, "0x%02x", i1&0xFF);
      85. sprintf(first, "0x%02x", (i1>>8)&0xFF);
      86. sprintf(fourth, "0x%02x", i2&0xFF);
      87. sprintf(third, "0x%02x", (i2>>8)&0xFF);
      88. sprintf(sixth, "0x%02x", i3&0xFF);
      89. sprintf(fith, "0x%02x", (i3>>8)&0xFF);
      90. mbedtls_printf( first );
      91. mbedtls_printf("\n");
      92. mbedtls_printf( second);
      93. mbedtls_printf("\n");
      94. mbedtls_printf( third );
      95. mbedtls_printf("\n");
      96. mbedtls_printf( fourth);
      97. mbedtls_printf("\n");
      98. mbedtls_printf( fith );
      99. mbedtls_printf("\n");
      100. mbedtls_printf( sixth);
      101. mbedtls_printf("\n");
      102. char message[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      103. 0x01, 0x00, //version 1.0
      104. 0x01, //sequence number 1
      105. 0x00, 0x00, //reserved
      106. 0x00, //color mode RGB
      107. 0x01, //linear filter
      108. 0x00, 0x00, 0x05, //light 1
      109. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      110. 0x00, 0x00, 0x06, //light 2
      111. 0xff, 0xff, 0x00, 0x00, 0x00, 0x00
      112. };
      113. message[19] = (i1>>8)&0xFF;
      114. message[20] = i1&0xFF;
      115. message[21] = (i2>>8)&0xFF;
      116. message[22] = i2&0xFF;
      117. message[23] = (i3>>8)&0xFF;
      118. message[24] = i3&0xFF;
      119. message[28] = (i4>>8)&0xFF;
      120. message[29] = i4&0xFF;
      121. message[30] = (i5>>8)&0xFF;
      122. message[31] = i5&0xFF;
      123. message[32] = (i6>>8)&0xFF;
      124. message[33] = i6&0xFF;
      125. len = sizeof( message );
      126. fflush( stdout );
      127. do ret = mbedtls_ssl_write( &ssl, (unsigned char *) message, len );
      128. while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
      129. ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      130. if( ret < 0 )
      131. {
      132. mbedtls_printf( " failed\n ! mbedtls_ssl_write returned %d\n\n", ret );
      133. goto exit;
      134. }
      135. }
      136. /*
      137. * 7. Read the echo response
      138. */
      139. mbedtls_printf( " < Read from server:" );
      140. fflush( stdout );
      141. len = sizeof( buf ) - 1;
      142. memset( buf, 0, sizeof( buf ) );
      143. do ret = mbedtls_ssl_read( &ssl, buf, len );
      144. while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
      145. ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      146. if( ret <= 0 )
      147. {
      148. switch( ret )
      149. {
      150. case MBEDTLS_ERR_SSL_TIMEOUT:
      151. mbedtls_printf( " timeout\n\n" );
      152. if( retry_left-- > 0 )
      153. goto send_request;
      154. goto exit;
      155. case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
      156. mbedtls_printf( " connection was closed gracefully\n" );
      157. ret = 0;
      158. goto close_notify;
      159. default:
      160. mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n\n", -ret );
      161. goto exit;
      162. }
      163. }
      164. len = ret;
      165. mbedtls_printf( " %d bytes read\n\n%s\n\n", len, buf );
      166. /*
      167. * 8. Done, cleanly close the connection
      168. */
      169. close_notify:
      170. mbedtls_printf( " . Closing the connection..." );
      171. /* No error checking, the connection might be closed already */
      172. do ret = mbedtls_ssl_close_notify( &ssl );
      173. while( ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      174. ret = 0;
      175. mbedtls_printf( " done\n" );
      176. /*
      177. * 9. Final clean-ups and exit
      178. */
      179. exit:
      180. #ifdef MBEDTLS_ERROR_C
      181. if( ret != 0 )
      182. {
      183. char error_buf[100];
      184. mbedtls_strerror( ret, error_buf, 100 );
      185. mbedtls_printf( "Last error was: %d - %s\n\n", ret, error_buf );
      186. }
      187. #endif
      188. mbedtls_net_free( &server_fd );
      189. mbedtls_x509_crt_free( &cacert );
      190. mbedtls_ssl_free( &ssl );
      191. mbedtls_ssl_config_free( &conf );
      192. mbedtls_ctr_drbg_free( &ctr_drbg );
      193. mbedtls_entropy_free( &entropy );
      194. #if defined(_WIN32)
      195. mbedtls_printf( " + Press Enter to exit this program.\n" );
      196. fflush( stdout ); getchar();
      197. #endif
      198. /* Shell can not handle large exit numbers -> 1 for errors */
      199. if( ret < 0 )
      200. ret = 1;
      201. return( ret );
      202. }
      203. #endif /* MBEDTLS_SSL_CLI_C && MBEDTLS_SSL_PROTO_DTLS && MBEDTLS_NET_C &&
      204. MBEDTLD_TIMING_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C &&
      205. MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_RSA_C && MBEDTLS_CERTS_C &&
      206. MBEDTLS_PEM_PARSE_C */
      Show All

    • Hier mal was zur Hue Entertainment API aus dem Developer Bereich:

      Your feedback following our hue launch was clear. You want to use light as you want it. Here we provide you some material to do so. The hue bridge has a powerful RESTful interface, which behaves like a simple web service. Use it as your tool. We hope this will help you to truly use light as you want it, by making new apps, websites and digital installations; integrating hue into something else or just playing around.

      Free to publish
      Philips has a quite progressive policy with hue. As you are free to create with our product, we think it should also be you who profits from your work. What you produce you own and are free to give away or sell. There’s a little catch – this also means that everything connected with use of your product is your responsibility. Philips will not accept liability if your product causes harm, for example. So use your powers for good!
      And, it’s up to you whether and on what terms you choose to commercialize your product. So while we say “what is yours is yours”, on the flip side we also say, “what is ours is ours”. Here, we mean the software, trademarks documentation, and any other materials we provide to help you develop hue apps.
      For example, you may refer to “hue” and “Philips” in plain text but you aren’t allowed to use “hue” or “Philips” branding in any logo or graphics. Also important to note is that the interface specifications “API” belong to Philips. Imagine you are working on an app and you come up with a brilliant idea for an improvement in the API or our materials. If you suggest any improvements to us and we adopt them, they become part of the platform used by everyone, and will belong to us.
      Oh, a little aside on UI: as the interface between your apps and the hue platform will evolve over time, we will do our level best to maintain backwards compatibility and will inform you with enough time, before we roll out updates. That’s why, to keep everyone up to date, we ask you to register your app/s in the whitelist and make it clear they are your creation.

      Hue API Entertainment Developer Ganz interessant die Seite, ist halt nur auf English und für Leute die sich gut auskennen, ich also nicht :P Dort muß man sich kurz registrieren und dann sieht man schon sehr viel an Infos...

    • Mit hyperion-ng funktioniert Hue Entertainment auf dem Pi.

      Da du alle Geräte am Denon dran hast werden deine Geräte mit den Daten (EDID) vom Denon versorgt.
      Aus meiner Sicht würde da dann ein 4K/60 HDR Splitter zum TV reichen und ein günstiger 4K/60 USB Grabber, also die Kombination die ich auch verwende.
      Der Grabber liegt bei 12 € und der Splitter bei ca. 40-45 €.
      Ich würde mir das anschaffen und testen bevor ich mir eine DIVA und teuren Splitter kaufen würde.
      Funktioniert es mit der billig Lösung nicht sendet man zurück oder verkauft es wieder. ;)

      Aber wie schon geschrieben am besten im Hyperion-Forum lesen und Fragen, da ich selber z.Zt. keinen AV Receiver, PS4 Pro, Fire TV 4K und Hue verwende.

      Ich empfehle nur ungerne etwas das ich nicht selbst getestet habe.

      gruß pclin
      Dreambox ONE / TWO, DM920UHD, DM900UHD, DM820HD HDD + USB-HUB, Stick 64GB, USB-HDD, Wireless Touch Keyboard K400r, Wlan-Stick 11n
      (Flash) DP-OE2.6 (BAXII) eigenes OE2.6, Debian-Buster, Diverse
      (Flash) DP-OE2.5 (BAXII) eigenes OE2.5-e2+kodi+X, debian-stretch, Diverse
      AudioDSP: miniDSP 2x4HD
      TV: LG 65" SUHD
      Hyperion und Plugin HyperionControl auf der Dreambox ONE / TWO
      nodeMCU ESP8266 mit WLED Wlan 268 LED's SK6812-RGBW-NW 60 LED/m



      Ambilight for ever

    • Das ist doch mal ne Ansage :thumbsup:

      Kannst du mir mal die genauen Bezeichnungen deines Spitter und Grabber nennen....dann schau ich mal bei Amazon nach den Teilen und werd das mal so weit testen...

      Denke dann wird mein nächster Schritt sein im Hyperion Forum mir Hilfe zu Hue Entertainment zu suchen :)

      Eine Frage noch, wenn mein AV Receiver zwei HDMI Out hätte, könnte ich mir den Spitter sparen, richtig?

      Post was edited 1 time, last by Bimmler ().


    • Ist es richtig das wenn ich einen AV Receiver (Denon AVR X2600 zum Beispiel) mit zwei HDMI Out HÄTTE, das dies nichts nützt bezüglich Kauf eines Spitters, wegen HDCP 2.3 ? Oder kommt es da wieder auf den Grabber an ob er mit dem HDCP 2.3 Signal was anfangen kann? Ich hab einen 6 Monate alten Denon AVR X1600 und noch einen gut erhaltenen 8 Jahre alten Yamaha AVR. Beides bei eBay rein und dann den Denon X2600 kaufen dachte ich....

    • Nein könntest du nicht, bei 2 HDMI Out wird immer der beste gemeinsame Wert genommen.
      Also müsste der Grabber alles können was auch der TV kann.

      Links zu 'meinem' Splitter und Grabber kommen gleich.

      gruß pclin
      Dreambox ONE / TWO, DM920UHD, DM900UHD, DM820HD HDD + USB-HUB, Stick 64GB, USB-HDD, Wireless Touch Keyboard K400r, Wlan-Stick 11n
      (Flash) DP-OE2.6 (BAXII) eigenes OE2.6, Debian-Buster, Diverse
      (Flash) DP-OE2.5 (BAXII) eigenes OE2.5-e2+kodi+X, debian-stretch, Diverse
      AudioDSP: miniDSP 2x4HD
      TV: LG 65" SUHD
      Hyperion und Plugin HyperionControl auf der Dreambox ONE / TWO
      nodeMCU ESP8266 mit WLED Wlan 268 LED's SK6812-RGBW-NW 60 LED/m



      Ambilight for ever

    • Ach...bevor ich’s vergesse...von der Uno 4K SE kommt auch Material in 1080p/24hz oder 2160p/24hz.

      Hab mich nun im Hyperion Forum angemeldet, dauert aber wohl noch bis ich dort Themen erstellen kann.