int main(void)
{
union uKeyRoster scan;
init();
while (1)
{
wait_for_press();
// Result is stored in prev_keys & keys and hopefully keys2
SET_LED_1();
scan = pack_array( keys );
build_key_list ( keys );
if (isConfigured(MODE_SEND_ROSTER)==0) {
can_prep_button_roster_msg( &msg1, scan );
can_send_msg_no_wait( CAN_TRANSMIT_CHANNEL1, &msg1 );
}
if (isConfigured(MODE_SEND_PRESSED)==0) {
can_prep_button_pressed_msg( &msg2 );
can_send_msg_no_wait( CAN_TRANSMIT_CHANNEL2, &msg2 );
}
RESET_LED_1();
}
return(0);
}
static json_t *pack(scanner_t *s, va_list *ap)
{
switch(s->token) {
case '{':
return pack_object(s, ap);
case '[':
return pack_array(s, ap);
case 's': /* string */
{
const char *str = va_arg(*ap, const char *);
if(!str) {
set_error(s, "<args>", "NULL string argument");
return NULL;
}
if(!utf8_check_string(str, -1)) {
set_error(s, "<args>", "Invalid UTF-8 string");
return NULL;
}
return json_string_nocheck(str);
}
case 'n': /* null */
return json_null();
case 'b': /* boolean */
return va_arg(*ap, int) ? json_true() : json_false();
case 'i': /* integer from int */
return json_integer(va_arg(*ap, int));
case 'I': /* integer from json_int_t */
return json_integer(va_arg(*ap, json_int_t));
case 'f': /* real */
return json_real(va_arg(*ap, double));
case 'O': /* a json_t object; increments refcount */
return json_incref(va_arg(*ap, json_t *));
case 'o': /* a json_t object; doesn't increment refcount */
return va_arg(*ap, json_t *);
default:
set_error(s, "<format>", "Unexpected format character '%c'",
s->token);
return NULL;
}
}
quint8 *MsgPackPrivate::pack(const QVariant &v, quint8 *p, bool wr, QVector<QByteArray> &user_data)
{
QMetaType::Type t = (QMetaType::Type)v.type();
if (v.isNull() && !v.isValid())
p = pack_nil(p, wr);
else if (t == QMetaType::Int)
p = pack_int(v.toInt(), p, wr);
else if (t == QMetaType::UInt)
p = pack_uint(v.toUInt(), p, wr);
else if (t == QMetaType::Bool)
p = pack_bool(v, p, wr);
else if (t == QMetaType::QString)
p = pack_string(v.toString(), p, wr);
else if (t == QMetaType::QVariantList)
p = pack_array(v.toList(), p, wr, user_data);
else if (t == QMetaType::QStringList)
p = pack_stringlist(v.toStringList(), p, wr);
else if (t == QMetaType::LongLong)
p = pack_longlong(v.toLongLong(), p, wr);
else if (t == QMetaType::ULongLong)
p = pack_ulonglong(v.toULongLong(), p, wr);
else if (t == QMetaType::Double)
p = pack_double(v.toDouble(), p, wr);
else if (t == QMetaType::Float)
p = pack_float(v.toFloat(), p, wr);
else if (t == QMetaType::QByteArray)
p = pack_bin(v.toByteArray(), p, wr);
else if (t == QMetaType::QVariantMap)
p = pack_map(v.toMap(), p, wr, user_data);
else {
if (t == QMetaType::User)
t = (QMetaType::Type)v.userType();
QReadLocker locker(&packers_lock);
bool has_packer = user_packers.contains(t);
if (has_packer)
has_packer &= user_packers[t].packer != 0;
locker.unlock();
if (has_packer)
p = pack_user(v, p, wr, user_data);
else
qWarning() << "MsgPack::pack can't pack type:" << t;
}
return p;
}
//***** main *****************************************************
int main(void)
{
union uKeyRoster scan;
chip_init(); // Chip initialization
can_init(); /* Enables Mob0 for Reception! */
can_init_test_msg();
byte result = CANSTMOB;
send_test_msgs();
/* TEST A) Initial Board Alive test, call this below. Watch LEDs go.
led_test_pattern(); */
/* B) Enable Receive Interrupts and call Show_byte() in the ISR.
ALL CODE IS IN ISR() */
while (1) {};
while (1)
{
wait_for_press();
// Result is stored in prev_keys & keys and hopefully keys2
scan = pack_array( keys );
can_prep_button_roster_msg( &msg1, scan );
can_send_msg( 0, &msg1 );
show_byte( scan.array[0], 1 );
// result = CANEN2; // shows MOb n in use mob1 is staying "in use" after 1 can_tx()
// result = CANSTMOB; // shows TXOK or ERRs BERR staying on instead of TXOK
// result = CANGSTA; // shows TXOK or ERRs TXBSY blinking (retires?)
// result = 0x83;
// result = scan.array[0];
// show_byte( a, 1 );
// [0] upper nibble is front row
// [0] lower is top row
// [1] upper nibble is 2nd row
// [1] lower is 3rd row
// [2] upper nibble is 4th row
/* for (int j=0; j<4; j++)
{
show_result_toggle(result);
delay (one_second/2);
} */
}
return(0);
}
/*
* process the reply string
*/
void
chat_send(char *s)
{
if (say_next) {
say_next = 0;
s = clean(s,0);
write(STDERR_FILENO, s, strlen(s));
free(s);
return;
}
if (hup_next) {
hup_next = 0;
if (strcmp(s, "OFF") == 0)
signal(SIGHUP, SIG_IGN);
else
signal(SIGHUP, sighup);
return;
}
if (echo_next) {
echo_next = 0;
echo = (strcmp(s, "ON") == 0);
return;
}
if (abort_next) {
char *s1;
abort_next = 0;
if (n_aborts >= MAX_ABORTS)
fatal(2, "Too many ABORT strings");
s1 = clean(s, 0);
if (strlen(s1) > strlen(s)
|| strlen(s1) + 1 > sizeof(fail_buffer))
fatal(1, "Illegal or too-long ABORT string ('%v')", s);
abort_string[n_aborts++] = s1;
if (verbose)
chat_logf("abort on (%v)", s);
return;
}
if (clear_abort_next) {
char *s1;
int i;
int old_max;
int pack = 0;
clear_abort_next = 0;
s1 = clean(s, 0);
if (strlen(s1) > strlen(s)
|| strlen(s1) + 1 > sizeof(fail_buffer))
fatal(1, "Illegal or too-long CLR_ABORT string ('%v')", s);
old_max = n_aborts;
for (i=0; i < n_aborts; i++) {
if ( strcmp(s1,abort_string[i]) == 0 ) {
free(abort_string[i]);
abort_string[i] = NULL;
pack++;
n_aborts--;
if (verbose)
chat_logf("clear abort on (%v)", s);
}
}
free(s1);
if (pack)
pack_array(abort_string,old_max);
return;
}
if (report_next) {
char *s1;
report_next = 0;
if (n_reports >= MAX_REPORTS)
fatal(2, "Too many REPORT strings");
s1 = clean(s, 0);
if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1)
fatal(1, "Illegal or too-long REPORT string ('%v')", s);
report_string[n_reports++] = s1;
if (verbose)
chat_logf("report (%v)", s);
return;
}
if (clear_report_next) {
char *s1;
int i;
int old_max;
int pack = 0;
clear_report_next = 0;
s1 = clean(s, 0);
if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1)
fatal(1, "Illegal or too-long REPORT string ('%v')", s);
old_max = n_reports;
for (i=0; i < n_reports; i++) {
if ( strcmp(s1,report_string[i]) == 0 ) {
free(report_string[i]);
report_string[i] = NULL;
pack++;
n_reports--;
if (verbose)
chat_logf("clear report (%v)", s);
}
}
free(s1);
if (pack)
pack_array(report_string,old_max);
return;
}
if (timeout_next) {
timeout_next = 0;
timeout = atoi(s);
if (timeout <= 0)
timeout = DEFAULT_CHAT_TIMEOUT;
if (verbose)
chat_logf("timeout set to %d seconds", timeout);
return;
}
if (strcmp(s, "EOT") == 0)
s = strdup("^D\\c");
else if (strcmp(s, "BREAK") == 0)
s = strdup("\\K\\c");
if (!put_string(s))
fatal(1, "Failed");
}
int serve(int serv_sock, const char *dest)
{
size_t response_size;
char *response_data = build_redirect(dest, &response_size);
struct Client *connections[MAX_PENDING_REQUESTS];
size_t i;
for(i = 0; i < MAX_PENDING_REQUESTS; ++i)
connections[i] = NULL;
while(1)
{
int greatest;
fd_set fds;
FD_ZERO(&fds);
FD_SET((SOCKET)serv_sock, &fds);
greatest = serv_sock;
for(i = 0; i < MAX_PENDING_REQUESTS && connections[i] != NULL; ++i)
{
int s = connections[i]->sock;
FD_SET((SOCKET)s, &fds);
if(s > greatest)
greatest = s;
}
select(greatest + 1, &fds, NULL, NULL, NULL);
if(FD_ISSET(serv_sock, &fds))
{
/* If all connections are taken */
if(connections[MAX_PENDING_REQUESTS - 1] != NULL)
{
my_closesocket(connections[0]->sock);
free(connections[0]);
connections[0] = NULL;
pack_array((void**)connections, MAX_PENDING_REQUESTS);
}
/* Accept the new connection */
{
struct sockaddr_in clientsin;
socklen_t size = sizeof(clientsin);
int sock = accept(serv_sock,
(struct sockaddr*)&clientsin, &size);
if(sock != -1)
{
for(i = 0; i < MAX_PENDING_REQUESTS; ++i)
if(connections[i] == NULL)
break;
connections[i] = malloc(sizeof(struct Client));
connections[i]->sock = sock;
connections[i]->state = 0;
}
}
}
else for(i = 0; i < MAX_PENDING_REQUESTS && connections[i] != NULL; ++i)
{
int s = connections[i]->sock;
if(FD_ISSET(s, &fds))
{
int *const state = &connections[i]->state;
int j;
/* Read stuff */
static char buffer[RECV_BUFFER_SIZE];
int len = recv(s, buffer, RECV_BUFFER_SIZE, 0);
/* Decode HTTP request (really just wait for "\r\n\r\n") */
for(j = 0; j < len; ++j)
{
if(buffer[j] == '\r')
{
if(*state == 0 || *state == 2)
++*state;
else
*state = 1;
}
else if(buffer[j] == '\n')
{
if(*state < 2)
*state = 2;
else
{
*state = 4;
break;
}
}
else
*state = 0;
}
if(*state == 4)
/* Print redirect */
send(s, response_data, response_size, 0);
/* Client closed the connection OR request complete */
if(len <= 0 || *state == 4)
{
my_closesocket(s);
free(connections[i]);
connections[i] = NULL;
pack_array((void**)connections, MAX_PENDING_REQUESTS);
}
}
}
}
free(response_data);
return 0;
}
