// Start playback.
void sess_play(sp_track *t)
{
if (g_session.state != SESS_ONLINE) {
log_append("Not connected");
return;
}
if (!t || !sp_track_is_available(t) || !sp_track_is_loaded(t)) {
log_append("Track not available");
return;
}
sess_stop();
g_session.current_track = t;
log_append("Playing \"%s\"...", sp_track_name(t));
sp_error err = sp_session_player_load(g_session.spotify, t);
if (err != SP_ERROR_OK)
panic("sp_session_player_load() failed: %s", sp_error_message(err));
err = sp_session_player_play(g_session.spotify, true);
if (err != SP_ERROR_OK)
panic("sp_session_player_play() failed: %s", sp_error_message(err));
g_session.playing = true;
// Redraw track info and progress.
ui_dirty(UI_TRACKINFO);
ui_dirty(UI_TRACKPROGRESS);
ui_update_post(0);
}
void sess_connect()
{
assert(g_session.username && g_session.password);
sess_disconnect();
if (!(g_session.dsfy = despotify_init_client(sess_callback, NULL, true, true)))
panic("despotify_init_client(...) failed");
play_state = PAUSE;
pthread_create(&thread, NULL, &thread_loop, g_session.dsfy);
// Login with credentials set by sess_username/sess_password.
if (!despotify_authenticate(g_session.dsfy, g_session.username, g_session.password)) {
g_session.state = SESS_ERROR;
log_append(despotify_get_error(g_session.dsfy));
despotify_exit(g_session.dsfy);
// Switch to log view.
ui_show(UI_SET_LOG);
}
else {
g_session.state = SESS_ONLINE;
log_append("Logged in as %s@%s:%d (%s)",
g_session.dsfy->user_info->username,
g_session.dsfy->user_info->server_host,
g_session.dsfy->user_info->server_port,
g_session.dsfy->user_info->country);
// Switch to browser view.
ui_show(UI_SET_BROWSER);
}
// Redraw status info.
ui_dirty(UI_FOOTER);
}
void sess_search(const char *query)
{
if (g_session.state != SESS_ONLINE) {
log_append("Not connected");
return;
}
log_append("Searching for: <%s>", query);
struct ds_search_result *sr = despotify_search(g_session.dsfy, (char*)query, 100);
if (!sr) {
log_append(despotify_get_error(g_session.dsfy));
return;
}
log_append("Got %d/%d tracks", sr->playlist->num_tracks, sr->total_tracks);
sess_search_t *prev = g_session.search;
sess_search_t *search = malloc(sizeof(sess_search_t));
search->res = sr;
search->next = prev;
g_session.search = search;
++g_session.search_len;
sidebar_reset();
}
static void engine_done_cb (OreganoEngine *engine, Simulation *s)
{
if (s->progress_timeout_id != 0) {
g_source_remove (s->progress_timeout_id);
s->progress_timeout_id = 0;
// Make sure that the progress bar is completed, just for good looks.
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (s->progress), 1.0);
}
gtk_widget_destroy (GTK_WIDGET (s->dialog));
s->dialog = NULL;
plot_show (s->engine);
if (oregano_engine_has_warnings (s->engine)) {
schematic_view_log_show (s->sv, FALSE);
log_append (s->logstore, _ ("Simulation"),
_ ("Finished with warnings:")); // FIXME add actual warnings
} else {
log_append (s->logstore, _ ("Simulation"), _ ("Finished."));
}
sheet_clear_op_values (schematic_view_get_sheet (s->sv));
// I don't need the engine anymore. The plot window owns its reference to
// the engine
g_object_unref (s->engine);
s->engine = NULL;
}
void sess_search(const char *query)
{
if (g_session.state != SESS_ONLINE) {
log_append("Not connected");
return;
}
log_append("Searching for: <%s>", query);
sp_search *res = sp_search_create(g_session.spotify, query,
0, 200, // tracks
0, 0, // albums
0, 0, // artists
sess_cb_search_complete_cb, NULL);
if (!res)
panic("sp_search_create() failed");
sess_search_t *prev = g_session.search;
sess_search_t *search = malloc(sizeof(sess_search_t));
search->res = res;
search->next = prev;
g_session.search = search;
++g_session.search_len;
sidebar_reset();
}
/**
* @brief Mems gyroscope Demo application.
* @param None
* @retval None
*/
void Routine_MEMS(void)
{
/* Read Gyro Angular data */
Demo_GyroReadAngRate(Buffer);
Buffer[0] = (int8_t)Buffer[0] - (int8_t)Gyro[0];
Buffer[1] = (int8_t)Buffer[1] - (int8_t)Gyro[1];
/* Update autoreload and capture compare registers value*/
Xval = ABS((int8_t)(Buffer[0]));
Yval = ABS((int8_t)(Buffer[1]));
if ( Xval>Yval)
{
if ((int16_t)Buffer[0] > 40)
{
/* Clear the LCD */
/* LCD_Clear(LCD_COLOR_WHITE);
LCD_SetTextColor(LCD_COLOR_MAGENTA);
LCD_DrawFullRect(100, 40, 40, 120);
LCD_FillTriangle(50, 190, 120, 160, 160, 310); */
log_append("docea_monitoring accel_state down\n");
// Delay(50);
}
if ((int16_t)Buffer[0] < -40)
{
/* Clear the LCD */
/* LCD_Clear(LCD_COLOR_WHITE);
LCD_SetTextColor(LCD_COLOR_RED);
LCD_DrawFullRect(100, 160, 40, 120);
LCD_FillTriangle(50, 190, 120, 160, 160, 10); */
log_append("docea_monitoring accel_state up\n");
// Delay(50);
}
}
else
{
if ((int16_t)Buffer[1] < -40)
{
/* Clear the LCD */
/* LCD_Clear(LCD_COLOR_WHITE);
LCD_SetTextColor(LCD_COLOR_GREEN);
LCD_DrawFullRect(120, 140, 100, 40);
LCD_FillTriangle(120, 120, 5, 60, 260, 160); */
log_append("docea_monitoring accel_state left\n");
// Delay(50);
}
if ((int16_t)Buffer[1] > 40)
{
/* Clear the LCD */
/* LCD_Clear(LCD_COLOR_WHITE);
LCD_SetTextColor(LCD_COLOR_BLUE);
LCD_DrawFullRect(20, 140, 100, 40);
LCD_FillTriangle(120, 120, 235, 60, 260, 160); */
log_append("docea_monitoring accel_state right\n");
// Delay(50);
}
}
}
void simulation_show (GtkWidget *widget, SchematicView *sv)
{
GtkWidget *w;
GtkBuilder *gui;
GError *e = NULL;
Simulation *s;
Schematic *sm;
g_return_if_fail (sv != NULL);
sm = schematic_view_get_schematic (sv);
s = schematic_get_simulation (sm);
if ((gui = gtk_builder_new ()) == NULL) {
log_append (s->logstore, _ ("Simulation"),
_ ("Could not create simulation dialog - Builder creation failed."));
return;
}
gtk_builder_set_translation_domain (gui, NULL);
// Only allow one instance of the dialog box per schematic.
if (s->dialog) {
gdk_window_raise (gtk_widget_get_window (GTK_WIDGET (s->dialog)));
return;
}
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/simulation.ui", &e) <= 0) {
log_append_error (s->logstore, _ ("Simulation"), _ ("Could not create simulation dialog"),
e);
g_clear_error (&e);
return;
}
w = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel"));
if (!w) {
log_append (s->logstore, _ ("Simulation"),
_ ("Could not create simulation dialog - .ui file lacks widget "
"called \"toplevel\"."));
return;
}
s->dialog = GTK_DIALOG (w);
g_signal_connect (G_OBJECT (w), "delete_event", G_CALLBACK (delete_event_cb), s);
w = GTK_WIDGET (gtk_builder_get_object (gui, "progressbar"));
s->progress = GTK_PROGRESS_BAR (w);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (s->progress), 0.0);
w = GTK_WIDGET (gtk_builder_get_object (gui, "progress_label"));
s->progress_label = GTK_LABEL (w);
g_signal_connect (G_OBJECT (s->dialog), "response", G_CALLBACK (cancel_cb), s);
gtk_widget_show_all (GTK_WIDGET (s->dialog));
s->sv = sv;
simulate_cmd (s);
}
// called from telemetry module at interrupt level to buffer new log data
void log_telemetry(char* data, int len)
{
if (lb_in_use == 1)
{
lb1_end_index = log_append(logbuf1, lb1_end_index, data, len);
}
else
{
lb2_end_index = log_append(logbuf2, lb2_end_index, data, len);
}
}
void CLIENT_TIME_STATS::log_append_net(int new_state) {
switch(new_state) {
case CONNECTED_STATE_NOT_CONNECTED:
log_append("net_not_connected", gstate.now);
break;
case CONNECTED_STATE_CONNECTED:
log_append("net_connected", gstate.now);
break;
case CONNECTED_STATE_UNKNOWN:
log_append("net_unknown", gstate.now);
break;
}
}
static void sess_cb_logged_in(sp_session *sess, sp_error err)
{
if (err == SP_ERROR_OK) {
g_session.state = SESS_ONLINE;
log_append("Logged in as \"%s\"", sp_user_display_name(sp_session_user(sess)));
ui_dirty(UI_FOOTER);
ui_show(UI_SET_BROWSER);
}
else {
g_session.state = SESS_ERROR;
log_append(sp_error_message(err));
ui_dirty(UI_FOOTER);
ui_show(UI_SET_LOG);
}
}
/**
* Get the list of voltmeters (test clamps).
*
* In normal mode, this does not include the
* the type of measurement (normal, magnitude,
* phase, real, imaginary or dB) and it is used
* in DC and Fourier analysis.
*
* In AC mode, each element includes the type
* of measurement (normal, magnitude, phase,
* real, imaginary or dB) and it is used in
* AC analysis.
*/
gint get_voltmeters_list(GList **voltmeters, Schematic *sm, GError *e, gboolean with_type)
{
GSList *siter, *node_list = NULL;
if (with_type)
node_list = netlist_helper_get_voltmeters_list (sm, &e, TRUE);
else
node_list = netlist_helper_get_voltmeters_list (sm, &e, FALSE);
if (e) {
log_append_error (schematic_get_log_store (sm), _ ("SimulationSettings"),
_ ("Failed to create netlist"), e);
g_clear_error (&e);
return -1;
}
if (node_list == NULL) {
log_append (schematic_get_log_store (sm), _ ("SimulationSettings"),
_ ("No node in the schematic!"));
return -2;
}
*voltmeters = NULL;
for (siter = node_list; siter; siter = siter->next) {
gchar *tmp;
if (with_type)
tmp = g_strdup (siter->data);
else
tmp = g_strdup_printf ("V(%d)", atoi (siter->data));
*voltmeters = g_list_prepend (*voltmeters, tmp);
}
return 0;
}
static int myread(Log_t *logp, int fd, u8 * buf, size_t count, const char *prefix)
{
ssize_t r = 1;
size_t r2 = 0;
while(r2 != count && r != 0) {
r = read(fd, buf + r2, count - r2);
if(r == -1) {
if(errno != EINTR) {
close(fd);
perror(prefix);
return -1;
}
} else
r2 += r;
}
if(r2 != count) {
close(fd);
log_append(logp, LOGFL_NORMAL, LOG_WARNING, "%s: Unexpected end of file", prefix);
return -1;
}
return 0;
}
/**
* Get the list of sources (indipendent voltage)
*/
gint get_voltage_sources_list(GList **sources, Schematic *sm, GError *e, gboolean ac_only)
{
GSList *siter, *node_list = NULL;
node_list = netlist_helper_get_voltage_sources_list (sm, &e, ac_only);
if (e) {
log_append_error (schematic_get_log_store (sm), _ ("SimulationSettings"),
_ ("Failed to create netlist"), e);
g_clear_error (&e);
return -1;
}
if (node_list == NULL) {
log_append (schematic_get_log_store (sm), _ ("SimulationSettings"),
_ ("No node in the schematic!"));
return -2;
}
*sources = NULL;
for (siter = node_list; siter; siter = siter->next) {
gchar *tmp;
tmp = g_strdup_printf ("V%d", atoi (siter->data));
*sources = g_list_prepend (*sources, tmp);
}
return 0;
}
// Start playback.
void sess_play(struct ds_track *t)
{
if (g_session.state != SESS_ONLINE) {
log_append("Not connected");
return;
}
if (despotify_play(g_session.dsfy, t, true)) {
g_session.playing = true;
g_session.paused = false;
log_append("Playing %s", t->title);
thread_play();
}
else
log_append("Playback failed");
}
static inline void _handle_file_access_after(const char *func, const char *absfile,
struct status_t *status, struct stat *st)
{
char *logfile, filterdir2 [PATH_MAX], *tfilterdir;
if ((status != NULL) && (status->inode != st->st_ino ||
status->size != st->st_size || status->mtime != st->st_mtime ||
status->ctime != st->st_ctime)) {
logfile = wlog;
LOG("%s(\"%s\"): inode was modified", func, absfile);
} else {
logfile = rlog;
LOG("%s(\"%s\"): inode was not modified", func, absfile);
}
if (logfile == NULL || logfile[0] == '\0') return;
if (filterdir[0] != '\0') {
/* We ignore access inside the collon seperated directory list
$FLWRAPPER_BASE, to keep the log smaller and reduce post
processing time. -ReneR */
strcpy (filterdir2, filterdir); /* due to strtok - sigh */
tfilterdir = strtok(filterdir2, ":");
for ( ; tfilterdir ; tfilterdir = strtok(NULL, ":") )
{
if ( !strncmp(absfile, tfilterdir, strlen(tfilterdir)) ) {
LOG("%s(\"%s\"): skipped due to filterdir \"%s\"", func, absfile, tfilterdir);
return;
}
}
}
LOG("%s(\"%s\"): logging to \"%s\"", func, absfile, logfile);
log_append(logfile, "%s.%s:\t%s\n", cmdname, func, absfile);
}
int main(int argc, char *argv[])
{
(void) argc;
(void) argv;
struct log *l;
l = log_new("/tmp/log_test.txt", LOG_ALL);
assert(l);
log_clear(l);
log_set_level(l, LOG_INFO);
log_debug(l, "module-1", "debug message\n");
log_set_level(l, LOG_DEBUG);
log_debug(l, "module-1", "debug message\n");
log_info(l, "module-2", "info message\n");
log_warning(l, NULL, "warning message\n");
log_error(l, "module-1","error message\n");
log_printf(l, LOG_WARNING, "module-3", "more warnings - ");
log_append(l, "%s\n", "\"this string is appended\"");
fprintf(stdout, "log_print():\n");
log_print(l, STDOUT_FILENO);
log_delete(l);
return 0;
}
void sess_init()
{
if (!despotify_init())
panic("despotify_init() failed");
audio_device = audio_init();
log_append("Initialized audio output");
}
/** Begin writing an entry to the log.
*
* This acquires the log and output buffer locks, so only calls to log_* functions should
* be used until calling log_end.
*/
void log_begin(log_facility_t fac, log_level_t level)
{
spinlock_lock(&log_lock);
spinlock_lock(&kio_lock);
log_current_start = (log_start + log_used) % LOG_LENGTH;
log_current_len = 0;
/* Write header of the log entry, the length will be written in log_end() */
log_append((uint8_t *) &log_current_len, sizeof(size_t));
log_append((uint8_t *) &log_counter, sizeof(uint32_t));
uint32_t fac32 = fac;
uint32_t lvl32 = level;
log_append((uint8_t *) &fac32, sizeof(uint32_t));
log_append((uint8_t *) &lvl32, sizeof(uint32_t));
log_counter++;
}
static void sess_cb_search_complete_cb(sp_search *res, void *data)
{
(void)data;
log_append("Search result: %d/%d", sp_search_num_tracks(res), sp_search_total_tracks(res));
ui_dirty(UI_SIDEBAR);
ui_dirty(UI_TRACKLIST);
ui_update_post(0);
}
// Toggle playback pause.
void sess_pause()
{
if (!g_session.playing) {
log_append("Not pausing since nothing is playing");
return;
}
if (g_session.paused) {
thread_play();
log_append("Resumed playback");
g_session.paused = false;
}
else {
thread_pause();
log_append("Paused playback");
g_session.paused = true;
}
}
void sigill_handler(int ignore_this) {
sigill_error = 1;
if( sigill_logobj ) {
log_append(sigill_logobj, LOGFL_NODUPS, LOG_WARNING,
"SIGILL signal caught in mem_chunk()");
} else {
fprintf(stderr,
"** WARNING ** SIGILL signal caught in mem_chunk()\n");
}
}
// Stop playback.
void sess_stop()
{
thread_pause();
if (g_session.state != SESS_ONLINE)
return;
g_session.playing = false;
despotify_stop(g_session.dsfy);
log_append("Stopped playback");
}
// Toggle playback pause.
void sess_pause()
{
if (g_session.state != SESS_ONLINE || !g_session.playing || !g_session.current_track || !sp_track_is_loaded(g_session.current_track))
return;
g_session.paused = !g_session.paused;
sp_error err = sp_session_player_play(g_session.spotify, !g_session.paused);
if (err != SP_ERROR_OK)
panic("sp_session_player_play() failed: %s", sp_error_message(err));
if (g_session.paused) {
log_append("Paused");
}
else {
// Continue updating track progress.
ui_dirty(UI_TRACKPROGRESS);
log_append("Resuming");
}
}
static void* thread_loop(void* arg)
{
struct despotify_session* ds = arg;
struct ds_pcm_data pcm;
pthread_mutex_init(&thread_mutex, NULL);
pthread_cond_init(&thread_cond, NULL);
bool loop = true;
while (loop) {
switch (play_state) {
case PAUSE:
pthread_mutex_lock(&thread_mutex);
log_append("thread_loop(): PAUSE, sleeping");
pthread_cond_wait(&thread_cond, &thread_mutex);
log_append("thread_loop(): PAUSE, woke up");
pthread_mutex_unlock(&thread_mutex);
break;
case PLAY: {
int rc = despotify_get_pcm(ds, &pcm);
if (rc == 0)
audio_play_pcm(audio_device, &pcm);
else {
log_append("despotify_get_pcm() failed");
//wrapper_wprintf(L"despotify_get_pcm() returned error %d\n", rc);
}
break;
}
case EXIT:
loop = false;
break;
}
}
pthread_cond_destroy(&thread_cond);
pthread_mutex_destroy(&thread_mutex);
return NULL;
}
static void sess_cb_logged_out(sp_session *sess)
{
(void)sess;
g_session.state = SESS_OFFLINE;
log_append("Logged out");
ui_dirty(UI_FOOTER);
ui_update_post(0);
if (g_session.exiting)
sess_cleanup();
}
void command_process(char *str)
{
char cmd[16];
if (sscanf(str, "%15s", cmd) == 1) {
for (int i = 0; g_commands[i].name; ++i) {
if (!strcmp(cmd, g_commands[i].name)) {
g_commands[i].cmd_cb();
return;
}
}
log_append("Unknown command: '%s'", cmd);
}
}
static void engine_aborted_cb (OreganoEngine *engine, Simulation *s)
{
if (s->progress_timeout_id != 0) {
g_source_remove (s->progress_timeout_id);
s->progress_timeout_id = 0;
}
// g_clear_object (&(s->dialog));
gtk_widget_destroy (GTK_WIDGET (s->dialog));
s->dialog = NULL;
log_append (s->logstore, _ ("Simulation"), _ ("Aborted. See lines below for details."));
schematic_view_log_show (s->sv, TRUE);
}
static int log_printf_str_write(const char *str, size_t size, void *data)
{
size_t offset = 0;
size_t chars = 0;
while (offset < size) {
kio_push_char(str_decode(str, &offset, size));
chars++;
}
log_append((const uint8_t *)str, size);
return chars;
}
bool http_request_headers_finalize(http_request_t * const request) {
header_list_t * header_list = request->headers;
if (header_list) {
char * method = http_request_header_get(request, ":method");
if (!method) {
log_append(request->log, LOG_ERROR, "Missing :method header");
return NULL;
}
request->method = strdup(method);
char * scheme = http_request_header_get(request, ":scheme");
if (!scheme) {
log_append(request->log, LOG_ERROR, "Missing :scheme header");
return NULL;
}
request->scheme = strdup(scheme);
if (!parse_path(request)) {
return NULL;
}
parse_authority(request);
parse_parameters(request->params, request->query_string);
header_list_remove_pseudo_headers(header_list);
} else {
request->headers = header_list_init(NULL);
}
return request;
}
int main()
{
log_t l;
log_init(&l);
int i;
log_append(&l,"Iddd am a genius");
log_append(&l,"2");
log_append(&l, "ab 1");
log_append(&l, "a 2");
log_append(&l, "abc 3");
log_append(&l, "ab 4");
log_append(&l, "a 5");
printf("search: %s\n",log_search(&l,"a"));
printf("pop: %s\n",log_pop(&l));
printf("search: %s\n",log_search(&l,"a"));
printf("search: %s\n",log_search(&l,"ab"));
printf("pop: %s\n",log_pop(&l));
printf("search: %s\n",log_search(&l,"ab"));
printf("search: %s\n",log_search(&l,"abc"));
for(i=0;i<1024*1024*100;++i){
log_append(&l,"I am a genius");
}
printf("size: %ul \n",log_size(&l));
printf("search: %s\n",log_search(&l,"I am"));
for(i=0;i<1024*1024;++i){
log_pop(&l);
}
printf("size: %u \n",log_size(&l));
printf("search: %s\n",log_search(&l,"I am"));
log_destroy(&l);
return 0;
}
