Philips Hue Leuchten mit Enigmalight steuern

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • please, have fun with it.

      Here is an example for 3 lamps.

      Source Code: enigmalight.conf

      1. #[global]
      2. [device]
      3. name ambilight
      4. output /etc/dtls_client
      5. channels 9
      6. type popen
      7. interval 100000
      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 1XX
      21. color red ambilight 1
      22. color green ambilight 2
      23. color blue ambilight 3
      24. hscan 1 4 #0 10
      25. vscan 60 80 #0 100
      26. [light]
      27. position top
      28. name 2XX
      29. color red ambilight 4
      30. color green ambilight 5
      31. color blue ambilight 6
      32. hscan 35 65 #0 10
      33. vscan 1 10 #0 100
      34. [light]
      35. position right
      36. name 2XX
      37. color red ambilight 7
      38. color green ambilight 8
      39. color blue ambilight 9
      40. hscan 97 100 #0 10
      41. vscan 60 80 #0 100
      Display All

      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.1.70" /* forces IPv4 */
      62. #define MESSAGE "Echo this"
      63. #define DFL_PSK_IDENTITY "Lsn5FIwdFMRvL32lDNbWJIuk0AojlDqGv7BawPG4"
      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[] = {0x54, 0xCB, 0x49, 0xEE, 0x0F, 0xC9, 0x8A, 0xE4, 0xCE, 0xBD, 0xE6, 0x6B, 0x88, 0xFF, 0x59, 0xE6 };
      85. int force_ciphersuite[1];
      86. mbedtls_entropy_context entropy;
      87. mbedtls_ctr_drbg_context ctr_drbg;
      88. mbedtls_ssl_context ssl;
      89. mbedtls_ssl_config conf;
      90. mbedtls_x509_crt cacert;
      91. mbedtls_timing_delay_context timer;
      92. ((void) argc);
      93. ((void) argv);
      94. #if defined(MBEDTLS_DEBUG_C)
      95. mbedtls_debug_set_threshold( DEBUG_LEVEL );
      96. #endif
      97. psk_identity = DFL_PSK_IDENTITY;
      98. force_ciphersuite[0]= MBEDTLS_TLS_PSK_WITH_AES_128_GCM_SHA256;
      99. /* force_ciphersuite[1]= 0; */
      100. /*
      101. * set hue in the right mode
      102. */
      103. system("curl -X PUT -H \"Content-Type: application/json\" -d '{\"stream\":{\"active\":true}}' \"http://192.168.1.70/api/Lsn5FIwdFMRvL32lDNbWJIuk0AojlDqGv7BawPG4/groups/5\"");
      104. /*
      105. * 0. Initialize the RNG and the session data
      106. */
      107. mbedtls_net_init( &server_fd );
      108. mbedtls_ssl_init( &ssl );
      109. mbedtls_ssl_config_init( &conf );
      110. mbedtls_x509_crt_init( &cacert );
      111. mbedtls_ctr_drbg_init( &ctr_drbg );
      112. mbedtls_printf( "\n . Seeding the random number generator..." );
      113. fflush( stdout );
      114. mbedtls_entropy_init( &entropy );
      115. if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
      116. (const unsigned char *) pers,
      117. strlen( pers ) ) ) != 0 )
      118. {
      119. mbedtls_printf( " failed\n ! mbedtls_ctr_drbg_seed returned %d\n", ret );
      120. goto exit;
      121. }
      122. mbedtls_printf( " ok\n" );
      123. /*
      124. * 0. Load certificates
      125. */
      126. mbedtls_printf( " . Loading the CA root certificate ..." );
      127. fflush( stdout );
      128. ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_cas_pem,
      129. mbedtls_test_cas_pem_len );
      130. if( ret < 0 )
      131. {
      132. mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned -0x%x\n\n", -ret );
      133. goto exit;
      134. }
      135. mbedtls_printf( " ok (%d skipped)\n", ret );
      136. /*
      137. * 1. Start the connection
      138. */
      139. mbedtls_printf( " . Connecting to udp/%s/%s...", SERVER_NAME, SERVER_PORT );
      140. fflush( stdout );
      141. if( ( ret = mbedtls_net_connect( &server_fd, SERVER_ADDR,
      142. SERVER_PORT, MBEDTLS_NET_PROTO_UDP ) ) != 0 )
      143. {
      144. mbedtls_printf( " failed\n ! mbedtls_net_connect returned %d\n\n", ret );
      145. goto exit;
      146. }
      147. mbedtls_printf( " ok\n" );
      148. /*
      149. * 2. Setup stuff
      150. */
      151. mbedtls_printf( " . Setting up the DTLS structure..." );
      152. fflush( stdout );
      153. if( ( ret = mbedtls_ssl_config_defaults( &conf,
      154. MBEDTLS_SSL_IS_CLIENT,
      155. MBEDTLS_SSL_TRANSPORT_DATAGRAM,
      156. MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )
      157. {
      158. mbedtls_printf( " failed\n ! mbedtls_ssl_config_defaults returned %d\n\n", ret );
      159. goto exit;
      160. }
      161. mbedtls_ssl_conf_transport(&conf, MBEDTLS_SSL_TRANSPORT_DATAGRAM);
      162. /* OPTIONAL is usually a bad choice for security, but makes interop easier
      163. * in this simplified example, in which the ca chain is hardcoded.
      164. * Production code should set a proper ca chain and use REQUIRED. */
      165. mbedtls_ssl_conf_authmode( &conf, MBEDTLS_SSL_VERIFY_OPTIONAL );
      166. mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL );
      167. mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );
      168. mbedtls_ssl_conf_dbg( &conf, my_debug, stdout );
      169. if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )
      170. {
      171. mbedtls_printf( " failed\n ! mbedtls_ssl_setup returned %d\n\n", ret );
      172. goto exit;
      173. }
      174. if( ( ret = mbedtls_ssl_conf_psk( &conf, psk, sizeof(psk),
      175. (const unsigned char *) psk_identity,
      176. strlen( psk_identity ) ) ) != 0 )
      177. {
      178. mbedtls_printf( " failed\n ! mbedtls_ssl_conf_psk returned %d\n\n", ret );
      179. goto exit;
      180. }
      181. mbedtls_ssl_conf_ciphersuites(&conf, force_ciphersuite);
      182. if( ( ret = mbedtls_ssl_set_hostname( &ssl, SERVER_NAME ) ) != 0 )
      183. {
      184. mbedtls_printf( " failed\n ! mbedtls_ssl_set_hostname returned %d\n\n", ret );
      185. goto exit;
      186. }
      187. mbedtls_ssl_set_bio( &ssl, &server_fd,
      188. mbedtls_net_send, mbedtls_net_recv, mbedtls_net_recv_timeout );
      189. mbedtls_ssl_set_timer_cb( &ssl, &timer, mbedtls_timing_set_delay,
      190. mbedtls_timing_get_delay );
      191. mbedtls_ssl_conf_handshake_timeout(&conf, 100, 60000);
      192. mbedtls_printf( " ok\n" );
      193. /*
      194. * 4. Handshake
      195. */
      196. mbedtls_printf( " . Performing the SSL/TLS handshake..." );
      197. fflush( stdout );
      198. do ret = mbedtls_ssl_handshake( &ssl );
      199. while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
      200. ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      201. if( ret != 0 )
      202. {
      203. mbedtls_printf( " failed\n ! mbedtls_ssl_handshake returned -0x%x\n\n", -ret );
      204. goto exit;
      205. }
      206. mbedtls_printf( " ok\n" );
      207. /*
      208. * 5. Verify the server certificate
      209. */
      210. mbedtls_printf( " . Verifying peer X.509 certificate..." );
      211. /* In real life, we would have used MBEDTLS_SSL_VERIFY_REQUIRED so that the
      212. * handshake would not succeed if the peer's cert is bad. Even if we used
      213. * MBEDTLS_SSL_VERIFY_OPTIONAL, we would bail out here if ret != 0 */
      214. if( ( flags = mbedtls_ssl_get_verify_result( &ssl ) ) != 0 )
      215. {
      216. char vrfy_buf[512];
      217. mbedtls_printf( " failed\n" );
      218. mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), " ! ", flags );
      219. mbedtls_printf( "%s\n", vrfy_buf );
      220. }
      221. else
      222. mbedtls_printf( " ok\n" );
      223. /*
      224. * 6. Write the echo request
      225. */
      226. send_request:
      227. mbedtls_printf( " > sending message" );
      228. fflush( stdout );
      229. char *line = NULL;
      230. while(1) {
      231. size_t size;
      232. if (getline(&line, &size, stdin) == -1) {
      233. mbedtls_printf("No line\n");
      234. } else {
      235. mbedtls_printf( "%s\n", line);
      236. }
      237. char* pEnd;
      238. float f1, f2, f3, f4, f5, f6, f7, f8, f9;
      239. f1 = strtof (line, &pEnd);
      240. f2 = strtof (pEnd, &pEnd);
      241. f3 = strtof (pEnd, &pEnd);
      242. f4 = strtof (pEnd, &pEnd);
      243. f5 = strtof (pEnd, &pEnd);
      244. f6 = strtof (pEnd, &pEnd);
      245. f7 = strtof (pEnd, &pEnd);
      246. f8 = strtof (pEnd, &pEnd);
      247. f9 = strtof (pEnd, NULL);
      248. f1 = f1*65535;
      249. f2 = f2*65535;
      250. f3 = f3*65535;
      251. f4 = f4*65535;
      252. f5 = f5*65535;
      253. f6 = f6*65535;
      254. f7 = f7*65535;
      255. f8 = f8*65535;
      256. f9 = f9*65535;
      257. int i1, i2, i3, i4, i5, i6, i7, i8, i9;
      258. i1 = (int)f1;
      259. i2 = (int)f2;
      260. i3 = (int)f3;
      261. i4 = (int)f4;
      262. i5 = (int)f5;
      263. i6 = (int)f6;
      264. i7 = (int)f7;
      265. i8 = (int)f8;
      266. i9 = (int)f9;
      267. mbedtls_printf( "%x\n", i1);
      268. mbedtls_printf( "%x\n", i2);
      269. mbedtls_printf( "%x\n", i3);
      270. mbedtls_printf( "%x\n", i4);
      271. mbedtls_printf( "%x\n", i5);
      272. mbedtls_printf( "%x\n", i6);
      273. mbedtls_printf( "%x\n", i7);
      274. mbedtls_printf( "%x\n", i8);
      275. mbedtls_printf( "%x\n", i9);
      276. char message[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      277. 0x01, 0x00, //version 1.0
      278. 0x01, //sequence number 1
      279. 0x00, 0x00, //reserved
      280. 0x00, //color mode RGB
      281. 0x01, //linear filter
      282. 0x00, 0x00, 0x03, //light 1
      283. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      284. 0x00, 0x00, 0x05, //light 2
      285. 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
      286. 0x00, 0x00, 0x06, //light 2
      287. 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
      288. };
      289. message[19] = (i1>>8)&0xFF;
      290. message[20] = i1&0xFF;
      291. message[21] = (i2>>8)&0xFF;
      292. message[22] = i2&0xFF;
      293. message[23] = (i3>>8)&0xFF;
      294. message[24] = i3&0xFF;
      295. message[28] = (i4>>8)&0xFF;
      296. message[29] = i4&0xFF;
      297. message[30] = (i5>>8)&0xFF;
      298. message[31] = i5&0xFF;
      299. message[32] = (i6>>8)&0xFF;
      300. message[33] = i6&0xFF;
      301. message[37] = (i7>>8)&0xFF;
      302. message[38] = i7&0xFF;
      303. message[39] = (i8>>8)&0xFF;
      304. message[40] = i8&0xFF;
      305. message[41] = (i9>>8)&0xFF;
      306. message[42] = i9&0xFF;
      307. len = sizeof( message );
      308. fflush( stdout );
      309. do ret = mbedtls_ssl_write( &ssl, (unsigned char *) message, len );
      310. while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
      311. ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      312. if( ret < 0 )
      313. {
      314. mbedtls_printf( " failed\n ! mbedtls_ssl_write returned %d\n\n", ret );
      315. goto exit;
      316. }
      317. }
      318. /*
      319. * 7. Read the echo response
      320. */
      321. mbedtls_printf( " < Read from server:" );
      322. fflush( stdout );
      323. len = sizeof( buf ) - 1;
      324. memset( buf, 0, sizeof( buf ) );
      325. do ret = mbedtls_ssl_read( &ssl, buf, len );
      326. while( ret == MBEDTLS_ERR_SSL_WANT_READ ||
      327. ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      328. if( ret <= 0 )
      329. {
      330. switch( ret )
      331. {
      332. case MBEDTLS_ERR_SSL_TIMEOUT:
      333. mbedtls_printf( " timeout\n\n" );
      334. if( retry_left-- > 0 )
      335. goto send_request;
      336. goto exit;
      337. case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
      338. mbedtls_printf( " connection was closed gracefully\n" );
      339. ret = 0;
      340. goto close_notify;
      341. default:
      342. mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n\n", -ret );
      343. goto exit;
      344. }
      345. }
      346. len = ret;
      347. mbedtls_printf( " %d bytes read\n\n%s\n\n", len, buf );
      348. /*
      349. * 8. Done, cleanly close the connection
      350. */
      351. close_notify:
      352. mbedtls_printf( " . Closing the connection..." );
      353. /* No error checking, the connection might be closed already */
      354. do ret = mbedtls_ssl_close_notify( &ssl );
      355. while( ret == MBEDTLS_ERR_SSL_WANT_WRITE );
      356. ret = 0;
      357. mbedtls_printf( " done\n" );
      358. /*
      359. * 9. Final clean-ups and exit
      360. */
      361. exit:
      362. #ifdef MBEDTLS_ERROR_C
      363. if( ret != 0 )
      364. {
      365. char error_buf[100];
      366. mbedtls_strerror( ret, error_buf, 100 );
      367. mbedtls_printf( "Last error was: %d - %s\n\n", ret, error_buf );
      368. }
      369. #endif
      370. mbedtls_net_free( &server_fd );
      371. mbedtls_x509_crt_free( &cacert );
      372. mbedtls_ssl_free( &ssl );
      373. mbedtls_ssl_config_free( &conf );
      374. mbedtls_ctr_drbg_free( &ctr_drbg );
      375. mbedtls_entropy_free( &entropy );
      376. #if defined(_WIN32)
      377. mbedtls_printf( " + Press Enter to exit this program.\n" );
      378. fflush( stdout ); getchar();
      379. #endif
      380. /* Shell can not handle large exit numbers -> 1 for errors */
      381. if( ret < 0 )
      382. ret = 1;
      383. return( ret );
      384. }
      385. #endif /* MBEDTLS_SSL_CLI_C && MBEDTLS_SSL_PROTO_DTLS && MBEDTLS_NET_C &&
      386. MBEDTLD_TIMING_C && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C &&
      387. MBEDTLS_X509_CRT_PARSE_C && MBEDTLS_RSA_C && MBEDTLS_CERTS_C &&
      388. MBEDTLS_PEM_PARSE_C */
      Display All
      Files
    • Hi Happy2000 thnx for your time.

      The 3lamp dtls client is not working correct, light do not turn on

      in dtls.c you make it look like this
      Display Spoiler
      char message[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      0x01, 0x00, //version 1.0
      0x01, //sequence number 1
      0x00, 0x00, //reserved
      0x00, //color mode RGB
      0x01, //linear filter
      0x00, 0x00, 0x03, //light 1
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x05, //light 2
      0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x06, //light 2
      0x00, 0x00, 0x00, 0x00, 0xff, 0xff
      I use lights 4, 5, 6, so i think its like this !? or not.
      Display Spoiler
      char message[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      0x01, 0x00, //version 1.0
      0x01, //sequence number 1
      0x00, 0x00, //reserved
      0x00, //color mode RGB
      0x01, //linear filter
      0x00, 0x00, 0x04, //light 1
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x05, //light 2
      0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x06, //light 3
      0x00, 0x00, 0x00, 0x00, 0xff, 0xff


      dtls_client.c (1).txt

      I use this config

      enigmalight.txt

      Have a nice day ;)

      The post was edited 1 time, last by hgdo ().

    • Habs jetzt hinbekommen, aber irgendetwas stimmt mit der "dtls_client" Datei nicht!
      Die Rechte habe ich auch hochgesetzt. Die EL.log sagt:

      [CDevicePopen::WriteOutput] ERROR: ambilight: fprintf() python /etc/enigma2/Enigmalight/dtls_client Broken pipe

      File "/etc/enigma2/Enigmalight/dtls_client", line 1
      SyntaxError: Non-ASCII character '\xb3' in file /etc/enigma2/Enigmalight/dtls_client on line 2
      , but no encoding declared; see PEP 263 -- Defining Python Source Code Encodings | Python.org for details

      The post was edited 1 time, last by BBQ ().

    • Die Tage auf verschiedenen Linux Systemen versucht zu kompilieren. Es treten immer folgende Fehler auf:

      Display Spoiler

      ssl/dtls_client.c: In function ‘main’:
      ssl/dtls_client.c:309:5: warning: ISO C90 forbids mixed declarations and code [-Wdeclaration-a fter-statement]
      char *line = NULL;
      ^~~~
      ssl/dtls_client.c:320:2: warning: ISO C90 forbids mixed declarations and code [-Wdeclaration-a fter-statement]
      char* pEnd;
      ^~~~
      ssl/dtls_client.c:337:7: warning: ISO C90 forbids mixed declarations and code [-Wdeclaration-a fter-statement]
      int i1, i2, i3, i4, i5, i6;
      ^~~
      ssl/dtls_client.c:353:12: warning: ISO C90 forbids mixed declarations and code [-Wdeclaration- after-statement]
      char first[5];
      ^~~~
      ssl/dtls_client.c:390:5: warning: ISO C90 forbids mixed declarations and code [-Wdeclaration-a fter-statement]
      char message[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      ^~~~
      ssl/dtls_client.c:113:10: warning: unused variable ‘message2’ [-Wunused-variable]
      char message2[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      ^~~~~~~~
      ssl/dtls_client.c:102:10: warning: unused variable ‘message1’ [-Wunused-variable]
      char message1[] = {'H', 'u', 'e', 'S', 't', 'r', 'e', 'a', 'm', //protocol
      ^~~~~~~~


      weiss jetzt leider nicht mehr weiter! :( ?(
    • Habe in der dtls_client.c noch einen IP Fehler gefunden, ändert aber leider nichts daran, dass die file nicht richtig kompiliert wird (meiner Meinung nach).

      Vielleicht findet ja jemand die Zeit das mal gegen zuprüfen, wäre nett!

      Danke
      Files
    • THX @Happy2000
      läuft aber leider genauso wenig. Bringt beim Sarten vom EL den gleichen Fehler, somit ist meine complimierung auch richtig.
      Woran es liegt, keine Ahnung! Es muss ja nichts auf der box nachinstalliert werden, oder?
      Bin dann erstmal raus!

      The post was edited 1 time, last by BBQ ().

    • Hey, hatte eine von euch schon das Problem wenn er 2 Hue ansteuert das es einwandfrei funktioniert. Nehme ich jetzt eine Konfiguration mit 3 Hue, geht EnigmLight zwar an und funktioniert auch bis zum ausschalten dann bleiben sie auf der farbe stehen die sie gerade hatten und gehen nicht aus. es scheint so als würde es hängen bleiben. Vllt hat jemand ne Lösung. Danke
    • Philips Hue Leuchten mit Enigmalight steuern

      Hallo ,

      Ich hab eine vu uno 4kse
      Ich Nutze WLED auf NodeMCU mit ws2812b stripes
      Ich bin eigentlich auch zufrieden würde jetz natürlich gern erweitern das WLED unterstützt von haus aus schon die hue bridge keine ahnung ob das so funktioniert Ketzer ist die frage ob das so geht oder was brauche ich für mein Vorhaben...


      Ich will links und rechts neben dem tv hinter den Boxen 2 hue stripes anbringen (wenn es möglich ist würde ich auch gern auf die bridge und die hue steipes verzichten und die ws2812b nutzen)

      Ich möchte das links die Lampe passen zum Bildschirm links leuchtet und rechts das selbe

      Was brauche ich um das zu realisieren?



      Gesendet von meinem SM-N975F mit Tapatalk
    • gutername26 wrote:

      Hey, hatte eine von euch schon das Problem wenn er 2 Hue ansteuert das es einwandfrei funktioniert. Nehme ich jetzt eine Konfiguration mit 3 Hue, geht EnigmLight zwar an und funktioniert auch bis zum ausschalten dann bleiben sie auf der farbe stehen die sie gerade hatten und gehen nicht aus. es scheint so als würde es hängen bleiben. Vllt hat jemand ne Lösung. Danke
      das hab ich auch mit nur zwei Hue Lampen in meiner Konfiguration, da wird das Stopp Signal einfach nicht korrekt gesendet. Ich schalte die Lampen dann einfach über die Hueapp aus.