int
main(
int argc,
const char ** argv
)
{
int width = 64;
int height = 64;
ledscape_config_t * config = &ledscape_matrix_default;
if (argc > 1)
{
config = ledscape_config(argv[1]);
if (!config)
return EXIT_FAILURE;
}
if (config->type == LEDSCAPE_MATRIX)
{
config->matrix_config.width = width;
config->matrix_config.height = height;
}
ledscape_t * const leds = ledscape_init(config, 0);
printf("init done\n");
time_t last_time = time(NULL);
unsigned last_i = 0;
unsigned i = 0;
uint32_t * const p = calloc(width*height,4);
render_game(p);
i++;
ledscape_draw(leds, p);
usleep(20000);
// wait for the previous frame to finish;
//const uint32_t response = ledscape_wait(leds);
const uint32_t response = 0;
time_t now = time(NULL);
if (now != last_time)
{
printf("%d fps. starting %d previous %"PRIx32"\n",
i - last_i, i, response);
last_i = i;
last_time = now;
}
printf("init done\n");
ledscape_close(leds);
return EXIT_SUCCESS;
}
int
main(
int argc,
char ** argv
)
{
ledscape_t * const leds = ledscape_init(width, height);
printf("init done\n");
time_t last_time = time(NULL);
unsigned last_i = 0;
unsigned i = 0;
uint32_t * const p = calloc(width*height,4);
int scroll_x = 128;
memset(p, 0x10, width*height*4);
for (int x = 0 ; x < 128 ; x += 32)
{
for (int y = 0 ; y < 128 ; y += 16)
{
char buf[32];
snprintf(buf, sizeof(buf), "%d,%d", x, y);
font_write(p, 0xFF0000, x, y, buf);
}
}
while (1)
{
ledscape_draw(leds, p);
usleep(20000);
// wait for the previous frame to finish;
//const uint32_t response = ledscape_wait(leds);
const uint32_t response = 0;
time_t now = time(NULL);
if (now != last_time)
{
printf("%d fps. starting %d previous %"PRIx32"\n",
i - last_i, i, response);
last_i = i;
last_time = now;
}
}
ledscape_close(leds);
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
ledscape_t * const leds = ledscape_init_with_programs(LEDSCAPE_NUM_LEDS,"pru/bin/ws281x-valhalla-pru0.bin","pru/bin/ws281x-valhalla-pru1.bin");
uint8_t rgb[3];
if ( argc > 4 ) {
rgb[0] = atoi(argv[1]);
rgb[1] = atoi(argv[2]);
rgb[2] = atoi(argv[3]);
} else {
printf("Provide at least 3 colors!\n");
exit(1);
}
printf("here\n");
ledscape_frame_t * const frame = ledscape_frame(leds, 0);
if ( argc > 4 ) {
unsigned strip_input = atoi(argv[4]);
printf("Using strip %i.\n", strip_input);
for (unsigned p = 0 ; p < LEDSCAPE_NUM_LEDS; p++)
{
ledscape_set_color(frame, COLOR_ORDER_RGB, strip_input, p, rgb[0] , rgb[1], rgb[2]);
}
} else {
printf("Using all strips.\n");
for (unsigned strip = 0 ; strip < LEDSCAPE_NUM_STRIPS ; strip++)
{
for (unsigned p = 0 ; p < LEDSCAPE_NUM_LEDS; p++)
{
ledscape_set_color(frame, COLOR_ORDER_RGB, strip, p, rgb[0] , rgb[1], rgb[2]);
}
}
}
ledscape_wait(leds);
ledscape_draw(leds, 0);
//ledscape_close(leds);
return EXIT_SUCCESS;
}
int
main(
int argc,
char ** argv
)
{
uint16_t port = 9999;
uint16_t num_pixels = 256;
uint16_t num_strips = LEDSCAPE_NUM_STRIPS;
extern char *optarg;
int opt;
while ((opt = getopt(argc, argv, "p:c:d:")) != -1)
{
switch (opt)
{
case 'p':
port = atoi(optarg);
break;
case 'c':
num_pixels = atoi(optarg);
break;
case 'd': {
int width=0, height=0;
if (sscanf(optarg,"%dx%d", &width, &height) == 2) {
num_pixels = width * height;
} else {
printf("Invalid argument for -d; expected NxN; actual: %s", optarg);
exit(EXIT_FAILURE);
}
}
break;
default:
fprintf(stderr, "Usage: %s [-p <port>] [-c <led_count> | -d <width>x<height>]\n", argv[0]);
exit(EXIT_FAILURE);
}
}
const int sock = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_addr.s_addr = INADDR_ANY,
.sin_port = htons(port),
};
if (sock < 0)
die("socket failed: %s\n", strerror(errno));
if (bind(sock, (const struct sockaddr*) &addr, sizeof(addr)) < 0)
die("bind port %d failed: %s\n", port, strerror(errno));
ledscape_t * const leds = ledscape_init(num_pixels);
fprintf(stderr, "Started LEDscape UDP receiver on port %d for %d pixels\n", port, num_pixels);
fprintf(stderr, "WARNING: udp-rx is deprecated! opc-rx supports more options and should be used instead.\n\n");
unsigned frame_num = 0;
uint8_t buf[num_pixels * num_strips * 4];
time_t last_time = time(NULL);
int fps_counter=0;
while (1)
{
const ssize_t rc = recv(sock, buf, sizeof(buf), 0);
if (rc < 0) {
printf("recv failed: %s\n", strerror(errno));
continue;
}
ledscape_frame_t * const frame
= ledscape_frame(leds, frame_num);
for(uint16_t x=0 ; x < num_pixels ; x++)
{
for(uint16_t strip = 0 ; strip < num_strips ; strip++)
{
const uint8_t r = buf[strip*num_pixels*3 + x*3 + 0];
const uint8_t g = buf[strip*num_pixels*3 + x*3 + 1];
const uint8_t b = buf[strip*num_pixels*3 + x*3 + 2];
ledscape_set_color(frame, strip, x, r, g, b);
}
}
ledscape_wait(leds);
ledscape_draw(leds, frame_num);
time_t now = time(NULL);
if (now != last_time)
{
printf("%d fps\n", fps_counter);
last_time = now;
fps_counter = 0;
}
fps_counter++;
frame_num = (frame_num+1) % 2;
}
ledscape_close(leds);
return 0;
}
int
main(
int argc,
char ** argv
)
{
const int width = 256;
const int height = 128;
ledscape_config_t * config = &ledscape_matrix_default;
if (argc > 1)
{
config = ledscape_config(argv[1]);
if (!config)
return EXIT_FAILURE;
}
if (config->type == LEDSCAPE_MATRIX)
{
config->matrix_config.width = width;
config->matrix_config.height = height;
}
ledscape_t * const leds = ledscape_init(config, 0);
//printf("init done %d,%d\n", width, height);
time_t last_time = time(NULL);
unsigned last_i = 0;
unsigned i = 0;
uint32_t * const p = calloc(width*height,4);
int scroll_x = 128;
memset(p, 0x10, width*height*4);
for (int i = 0 ; i < 8 ; i++)
{
for (int j = 0 ; j < 8 ; j++)
{
ledscape_printf(
&p[8+j*32 + width*i*16],
width,
0xFF0000, // red
"%d-%d",
i,
j
);
ledscape_printf(
&p[1+j*32 + width*i*16],
width,
0x00FF00, // green
"^"
);
ledscape_printf(
&p[1+j*32 + width*(i*16+8)],
width,
0x0000FF, // blue
"|"
);
p[j*32+width*i*16] = 0xFFFF00;
}
}
while (1)
{
ledscape_draw(leds, p);
usleep(20000);
// wait for the previous frame to finish;
//const uint32_t response = ledscape_wait(leds);
const uint32_t response = 0;
time_t now = time(NULL);
if (now != last_time)
{
printf("%d fps. starting %d previous %"PRIx32"\n",
i - last_i, i, response);
last_i = i;
last_time = now;
}
}
ledscape_close(leds);
return EXIT_SUCCESS;
}
static int
tcp_socket(
const int port
)
{
const int sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_port = htons(port),
.sin_addr.s_addr = INADDR_ANY,
};
if (sock < 0)
return -1;
if (bind(sock, (const struct sockaddr*) &addr, sizeof(addr)) < 0)
return -1;
if (listen(sock, 5) == -1)
return -1;
return sock;
}
int
main(
int argc,
char ** argv
)
{
int port = 7890;
int led_count = 256;
extern char *optarg;
int opt;
while ((opt = getopt(argc, argv, "p:c:d:")) != -1)
{
switch (opt)
{
case 'p':
port = atoi(optarg);
break;
case 'c':
led_count = atoi(optarg);
break;
case 'd': {
int width=0, height=0;
if (sscanf(optarg,"%dx%d", &width, &height) == 2) {
led_count = width * height;
} else {
printf("Invalid argument for -d; expected NxN; actual: %s", optarg);
exit(EXIT_FAILURE);
}
}
break;
default:
fprintf(stderr, "Usage: %s [-p <port>] [-c <led_count> | -d <width>x<height>]\n", argv[0]);
exit(EXIT_FAILURE);
}
}
const int sock = tcp_socket(port);
if (sock < 0)
die("socket port %d failed: %s\n", port, strerror(errno));
const size_t image_size = led_count * 3;
// largest possible UDP packet
uint8_t buf[65536];
if (sizeof(buf) < image_size + 1)
die("%u too large for UDP\n", image_size);
fprintf(stderr, "OpenPixelControl LEDScape Receiver started on TCP port %d for %d pixels.\n", port, led_count);
fprintf(stderr, "NOTE: This is a preliminary implementation of OPC for LEDscape and does not support multiple clients or updating multiple channels.\n");
fprintf(stderr, "Use udp-rx in cases where those features are needed.\n");
ledscape_t * const leds = ledscape_init(led_count);
const unsigned report_interval = 10;
unsigned last_report = 0;
unsigned long delta_sum = 0;
unsigned frames = 0;
uint32_t * const fb = calloc(image_size,4);
int fd;
while ((fd = accept(sock, NULL, NULL)) >= 0)
{
while(1)
{
opc_cmd_t cmd;
ssize_t rlen = read(fd, &cmd, sizeof(cmd));
if (rlen < 0)
die("recv failed: %s\n", strerror(errno));
if (rlen == 0)
{
close(fd);
break;
}
const size_t cmd_len = cmd.len_hi << 8 | cmd.len_lo;
warn("received %zu bytes: %d %zu\n", rlen, cmd.command, cmd_len);
size_t offset = 0;
while (offset < cmd_len)
{
rlen = read(fd, buf + offset, cmd_len - offset);
if (rlen < 0)
die("recv failed: %s\n", strerror(errno));
if (rlen == 0)
break;
offset += rlen;
}
if (cmd.command != 0)
continue;
struct timeval start_tv, stop_tv, delta_tv;
gettimeofday(&start_tv, NULL);
const unsigned frame_num = 0;
for (unsigned int i=0; i<image_size; i++) {
uint8_t * const out = (void*) &fb[i];
const uint8_t * const in = &buf[3 * i];
out[0] = in[0];
out[1] = in[1];
out[2] = in[2];
}
ledscape_draw(leds, fb);
gettimeofday(&stop_tv, NULL);
timersub(&stop_tv, &start_tv, &delta_tv);
frames++;
delta_sum += delta_tv.tv_usec;
if (stop_tv.tv_sec - last_report < report_interval)
continue;
last_report = stop_tv.tv_sec;
const unsigned delta_avg = delta_sum / frames;
printf("%6u usec avg, max %.2f fps, actual %.2f fps (over %u frames)\n",
delta_avg,
report_interval * 1.0e6 / delta_avg,
frames * 1.0 / report_interval,
frames
);
frames = delta_sum = 0;
}
}
return 0;
}
int
main(
int argc,
char ** argv
)
{
/* getopt_long stores the option index here. */
int option_index = 0;
int port = 9999;
const char * config_file = NULL;
const char * startup_message = "";
int timeout = 60;
unsigned width = 512;
unsigned height = 64;
int no_init = 0;
while (1)
{
const int c = getopt_long(
argc,
argv,
"vp:c:t:W:H:m:n",
long_options,
&option_index
);
if (c == -1)
break;
switch (c)
{
case 'v':
verbose++;
break;
case 'n':
no_init++;
break;
case 'c':
config_file = optarg;
break;
case 't':
timeout = atoi(optarg);
break;
case 'W':
width = atoi(optarg);
break;
case 'H':
height = atoi(optarg);
break;
case 'm':
startup_message = optarg;
break;
default:
usage();
return -1;
}
}
const int sock = udp_socket(port);
if (sock < 0)
die("socket port %d failed: %s\n", port, strerror(errno));
const size_t image_size = width * height * 3;
const size_t buf_size = (width*height*4)/packets_per_frame + 1;
// largest possible UDP packet
uint8_t *buf = malloc(buf_size);
#if 0
if (sizeof(buf) < image_size + 1)
die("%u x %u too large for UDP\n", width, height);
#endif
fprintf(stderr, "%u x %u, UDP port %u\n", width, height, port);
ledscape_config_t * config = &ledscape_matrix_default;
if (config_file)
{
config = ledscape_config(config_file);
if (!config)
return EXIT_FAILURE;
}
if (config->type == LEDSCAPE_MATRIX)
{
config->matrix_config.width = width;
config->matrix_config.height = height;
}
ledscape_t * const leds = ledscape_init(config, no_init);
if (!leds)
return EXIT_FAILURE;
const unsigned report_interval = 10;
unsigned last_report = 0;
unsigned long delta_sum = 0;
unsigned frames = 0;
uint32_t * const fb = calloc(width*height,4);
ledscape_printf(fb, width, 0xFF0000, "%s", startup_message);
ledscape_printf(fb+16*width, width, 0x00FF00, "%dx%d UDP port %d", width, height, port);
ledscape_draw(leds, fb);
while (1)
{
int rc = wait_socket(sock, timeout*1000);
if (rc < 0)
{
// something failed
memset(fb, 0, width*height*4);
ledscape_printf(fb, width, 0xFF0000, "read failed?");
ledscape_draw(leds, fb);
exit(EXIT_FAILURE);
}
if (rc == 0)
{
// go into timeout mode
memset(fb, 0, width*height*4);
ledscape_printf(fb, width, 0xFF0000, "timeout");
ledscape_draw(leds, fb);
continue;
}
const ssize_t rlen = recv(sock, buf, buf_size, 0);
if (rlen < 0)
die("recv failed: %s\n", strerror(errno));
warn_once("received %zu bytes\n", rlen);
/*
if (buf[0] == 2)
{
// image type
printf("image type: %.*s\n",
(int) rlen - 1,
&buf[1]
);
continue;
}
if (buf[0] != 1)
{
// What is it?
warn_once("Unknown image type '%c' (%02x)\n",
buf[0],
buf[0]
);
continue;
}
*/
const unsigned frame_part = buf[0];
if (frame_part != 0 && frame_part != 1)
{
printf("bad type %d\n", frame_part);
continue;
}
if ((size_t) rlen != image_size + 1)
{
warn_once("WARNING: Received packet %zu bytes, expected %zu\n",
rlen,
image_size + 1
);
}
struct timeval start_tv, stop_tv, delta_tv;
gettimeofday(&start_tv, NULL);
const unsigned frame_num = 0;
// copy the 3-byte values into the 4-byte framebuffer
// and turn onto the side
for (unsigned x = 0 ; x < width ; x++) // 256
{
for (unsigned y = 0 ; y < 32 ; y++) // 64
{
uint32_t * out = (void*) &fb[(y+32*frame_part)*width + x];
const uint8_t * const in = &buf[1 + 3*(y*width + x)];
uint32_t r = in[0];
uint32_t g = in[1];
uint32_t b = in[2];
*out = (r << 16) | (g << 8) | (b << 0);
}
}
// only draw after the second frame
if (frame_part == 1)
ledscape_draw(leds, fb);
gettimeofday(&stop_tv, NULL);
timersub(&stop_tv, &start_tv, &delta_tv);
frames++;
delta_sum += delta_tv.tv_usec;
if (stop_tv.tv_sec - last_report < report_interval)
continue;
last_report = stop_tv.tv_sec;
const unsigned delta_avg = delta_sum / frames;
printf("%6u usec avg, max %.2f fps, actual %.2f fps (over %u frames)\n",
delta_avg,
report_interval * 1.0e6 / delta_avg,
frames * 1.0 / report_interval,
frames
);
frames = delta_sum = 0;
}
return 0;
}
