/*!
\brief Creates a group of 2D Table Editors packed into a GtkNotebook
\param button is a pointer to the widget the user click on, which has bound
to is a list of the TE Table ID's which we need to create on-screen
representations for
\returns TRUE on success, FALSE otherwise
*/
G_MODULE_EXPORT gboolean create_2d_table_editor_group(GtkWidget *button)
{
GladeXML *main_xml = NULL;
GladeXML *xml = NULL;
GtkWidget *widget = NULL;
GtkWidget *window = NULL;
GtkWidget *notebook = NULL;
GtkWidget *curve = NULL;
GtkWidget *x_parent = NULL;
GtkWidget *y_parent = NULL;
GtkWidget *x_table = NULL;
GtkWidget *y_table = NULL;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *dummy = NULL;
GtkWidget *gauge = NULL;
GtkWidget *parent = NULL;
GtkWidget *curve_parent = NULL;
CurveData *cdata = NULL;
GArray *x_entries = NULL;
GArray *y_entries = NULL;
GList *widget_list = NULL;
GList *curve_list = NULL;
GList *gauge_list = NULL;
gchar * tmpbuf = NULL;
gchar * filename = NULL;
gchar **vector = NULL;
GList ***ecu_widgets = NULL;
gint num_tabs = 0;
gint x_mult = 0;
gint y_mult = 0;
gint page = 0;
gint offset = 0;
gint i = 0;
gint j = 0;
gfloat tmpf = 0.0;
guint32 id = 0;
gint rows = 0;
gint table_num = 0;
Firmware_Details *firmware = NULL;
firmware = DATA_GET(global_data,"firmware");
ecu_widgets = DATA_GET(global_data,"ecu_widgets");
main_xml = (GladeXML *)DATA_GET(global_data,"main_xml");
if (!main_xml)
return FALSE;
xml = glade_xml_new(main_xml->filename,"table_editor_window",NULL);
window = glade_xml_get_widget(xml,"table_editor_window");
glade_xml_signal_autoconnect(xml);
g_signal_connect(G_OBJECT(window),"destroy_event",
G_CALLBACK(close_2d_editor),NULL);
g_signal_connect(G_OBJECT(window),"delete_event",
G_CALLBACK(close_2d_editor),NULL);
gtk_window_set_title(GTK_WINDOW(window),_("2D Table Group Editor"));
gtk_window_resize(GTK_WINDOW(window),800,530);
widget = glade_xml_get_widget(xml,"2d_close_button");
g_signal_connect_swapped(G_OBJECT(widget),"clicked",
G_CALLBACK(close_2d_editor),window);
widget = glade_xml_get_widget(xml,"get_data_button");
OBJ_SET(widget,"handler",GINT_TO_POINTER(READ_VE_CONST));
OBJ_SET_FULL(widget,"bind_to_list",g_strdup("get_data_buttons"),g_free);
bind_to_lists_f(widget,"get_data_buttons");
widget_list = g_list_prepend(widget_list,(gpointer)widget);
widget = glade_xml_get_widget(xml,"burn_data_button");
OBJ_SET(widget,"handler",GINT_TO_POINTER(BURN_FLASH));
OBJ_SET_FULL(widget,"bind_to_list",g_strdup("burners"),g_free);
bind_to_lists_f(widget,"burners");
widget_list = g_list_prepend(widget_list,(gpointer)widget);
/*
widget = glade_xml_get_widget(xml,"curve_editor_menuitem");
gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE);
*/
widget = glade_xml_get_widget(xml,"close_menuitem");
OBJ_SET(widget,"window",(gpointer)window);
widget = glade_xml_get_widget(xml,"te_layout_hbox1");
gtk_widget_destroy(widget);
widget = glade_xml_get_widget(xml,"te_layout_vbox");
tmpbuf = OBJ_GET(button,"te_tables");
vector = parse_keys_f(tmpbuf,&num_tabs,",");
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),GTK_POS_LEFT);
gtk_box_pack_start(GTK_BOX(widget),notebook,TRUE,TRUE,0);
for (j = 0;j < num_tabs;j++)
{
table_num = (gint)strtod(vector[j],NULL);
if (table_num >= firmware->total_te_tables)
{
warn_user_f("Requested to create 2D table editor window for an undefined (out of range) table ID");
return FALSE;
}
if (!firmware->te_params)
{
warn_user_f("No 2D table Editor tables (te_tables) defined in interrogation profile, yet told to create a graph for a table... BUG detected!");
continue;
}
if (!firmware->te_params[table_num])
{
warn_user_f("Requested to create a 2D table editor window for an undefined table!");
continue;
}
xml = glade_xml_new(main_xml->filename,"te_layout_hbox1",NULL);
widget = glade_xml_get_widget(xml,"te_layout_hbox1");
label = gtk_label_new(firmware->te_params[table_num]->title);
gtk_misc_set_alignment(GTK_MISC(label),0,0.5);
if (firmware->te_params[table_num]->bind_to_list)
{
OBJ_SET_FULL(widget,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free);
OBJ_SET(widget,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type));
bind_to_lists_f(widget,firmware->te_params[table_num]->bind_to_list);
widget_list = g_list_prepend(widget_list,(gpointer)widget);
OBJ_SET_FULL(label,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free);
OBJ_SET(label,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type));
bind_to_lists_f(label,firmware->te_params[table_num]->bind_to_list);
widget_list = g_list_prepend(widget_list,(gpointer)label);
}
if (firmware->te_params[table_num]->gauge ||
firmware->te_params[table_num]->c_gauge ||
firmware->te_params[table_num]->f_gauge)
{
parent = glade_xml_get_widget(xml,"te_gaugeframe");
gauge = mtx_gauge_face_new();
gauge_list = g_list_prepend(gauge_list,(gpointer)gauge);
OBJ_SET(window,"gauge",gauge);
if (firmware->te_params[table_num]->gauge_temp_dep)
{
if ((GINT)DATA_GET(global_data,"mtx_temp_units") == CELSIUS)
tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
else if ((GINT)DATA_GET(global_data,"mtx_temp_units") == KELVIN)
tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
else
tmpbuf = g_strdelimit(firmware->te_params[table_num]->f_gauge,"\\",'/');
}
else
tmpbuf = g_strdelimit(firmware->te_params[table_num]->gauge,"\\",'/');
filename = get_file(g_strconcat(GAUGES_DATA_DIR,PSEP,tmpbuf,NULL),NULL);
mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename);
lookup_current_value_f(firmware->te_params[table_num]->gauge_datasource, &tmpf);
mtx_gauge_face_set_value(MTX_GAUGE_FACE(gauge),tmpf);
g_free(filename);
id = create_rtv_value_change_watch_f(firmware->te_params[table_num]->gauge_datasource,FALSE,"update_misc_gauge",(gpointer)gauge);
OBJ_SET(gauge,"gauge_id",GINT_TO_POINTER(id));
gtk_container_add(GTK_CONTAINER(parent),gauge);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),widget,label);
curve_parent = glade_xml_get_widget(xml,"te_right_frame");
curve = mtx_curve_new();
curve_list = g_list_prepend(curve_list,(gpointer)curve);
mtx_curve_set_title(MTX_CURVE(curve),_(firmware->te_params[table_num]->title));
mtx_curve_set_x_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->x_axis_label));
mtx_curve_set_y_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->y_axis_label));
cdata = g_new0(CurveData, 1);
cdata->curve = curve;
cdata->axis = _X_;
cdata->source = firmware->te_params[table_num]->x_source;
id = create_rtv_value_change_watch_f(cdata->source,FALSE,"update_curve_marker",(gpointer)cdata);
mtx_curve_set_show_x_marker(MTX_CURVE(curve),TRUE);
OBJ_SET(curve,"cdata",(gpointer)cdata);
OBJ_SET(curve,"marker_id",GINT_TO_POINTER(id));
mtx_curve_set_auto_hide_vertexes(MTX_CURVE(curve),TRUE);
g_signal_connect(G_OBJECT(curve),"coords-changed",
G_CALLBACK(coords_changed), NULL);
g_signal_connect(G_OBJECT(curve),"vertex-proximity",
G_CALLBACK(vertex_proximity), NULL);
g_signal_connect(G_OBJECT(curve),"marker-proximity",
G_CALLBACK(marker_proximity), NULL);
label = glade_xml_get_widget(xml,"x_units");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_units);
label = glade_xml_get_widget(xml,"y_units");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_units);
label = glade_xml_get_widget(xml,"x_title");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_name);
label = glade_xml_get_widget(xml,"y_title");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_name);
rows = firmware->te_params[table_num]->bincount;
mtx_curve_set_empty_array(MTX_CURVE(curve),rows);
x_table = gtk_table_new(rows+1,1,FALSE);
y_table = gtk_table_new(rows+1,1,FALSE);
x_parent = glade_xml_get_widget(xml,"te_x_frame");
y_parent = glade_xml_get_widget(xml,"te_y_frame");
gtk_container_set_border_width(GTK_CONTAINER(x_table),5);
gtk_container_set_border_width(GTK_CONTAINER(y_table),5);
gtk_container_add(GTK_CONTAINER(x_parent),x_table);
gtk_container_add(GTK_CONTAINER(y_parent),y_table);
x_mult = get_multiplier_f(firmware->te_params[table_num]->x_size);
y_mult = get_multiplier_f(firmware->te_params[table_num]->y_size);
x_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
y_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
for (i=0;i<rows;i++)
{
/* X Column */
entry = gtk_entry_new();
OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT));
gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
g_array_insert_val(x_entries,i,entry);
OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_X_));
OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_lower)),g_free);
OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_upper)),g_free);
OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->x_fromecu_mult);
OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->x_fromecu_add);
OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->x_precision));
OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->x_size));
OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->x_page));
OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->x_temp_dep));
OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color));
if(firmware->te_params[table_num]->x_temp_dep)
{
OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free);
bind_to_lists_f(entry,"temperature");
}
offset = (i*x_mult) + firmware->te_params[table_num]->x_base;
OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(update_2d_curve),curve);
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(entry_changed_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_press_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_release_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"focus_out_event",
G_CALLBACK(focus_out_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"activate",
G_CALLBACK(std_entry_handler_f),NULL);
if (firmware->te_params[table_num]->reversed)
gtk_table_attach(GTK_TABLE(x_table),entry,
0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
else
gtk_table_attach(GTK_TABLE(x_table),entry,
0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
page = firmware->te_params[table_num]->x_page;
ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
widget_list = g_list_prepend(widget_list,(gpointer)entry);
update_widget(G_OBJECT(entry),NULL);
/* Y Column */
entry = gtk_entry_new();
OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT));
gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
g_array_insert_val(y_entries,i,entry);
OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_Y_));
OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_lower)),g_free);
OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_upper)),g_free);
OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->y_fromecu_mult);
OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->y_fromecu_add);
OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->y_precision));
OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->y_size));
OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->y_page));
OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->y_temp_dep));
OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color));
if(firmware->te_params[table_num]->y_temp_dep)
{
OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free);
bind_to_lists_f(entry,"temperature");
}
offset = (i*y_mult) + firmware->te_params[table_num]->y_base;
OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(update_2d_curve),curve);
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(entry_changed_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_press_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_release_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"focus_out_event",
G_CALLBACK(focus_out_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"activate",
G_CALLBACK(std_entry_handler_f),NULL);
if (firmware->te_params[table_num]->reversed)
gtk_table_attach(GTK_TABLE(y_table),entry,
0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
else
gtk_table_attach(GTK_TABLE(y_table),entry,
0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
page = firmware->te_params[table_num]->y_page;
ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
widget_list = g_list_prepend(widget_list,(gpointer)entry);
update_widget(G_OBJECT(entry),NULL);
}
/* Create the "LOCK" buttons */
dummy = gtk_toggle_button_new_with_label("Unlocked");
OBJ_SET(dummy,"axis",GINT_TO_POINTER(_X_));
g_signal_connect(G_OBJECT(dummy),"toggled",
G_CALLBACK(set_axis_locking),curve);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->x_lock);
gtk_table_attach(GTK_TABLE(x_table),dummy,
0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);
dummy = gtk_toggle_button_new_with_label("Unlocked");
OBJ_SET(dummy,"axis",GINT_TO_POINTER(_Y_));
g_signal_connect(G_OBJECT(dummy),"toggled",
G_CALLBACK(set_axis_locking),curve);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->y_lock);
gtk_table_attach(GTK_TABLE(y_table),dummy,
0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);
mtx_curve_set_x_precision(MTX_CURVE(curve),firmware->te_params[table_num]->x_precision);
mtx_curve_set_y_precision(MTX_CURVE(curve),firmware->te_params[table_num]->y_precision);
mtx_curve_set_hard_limits(MTX_CURVE(curve),
(gfloat)firmware->te_params[table_num]->x_raw_lower,
(gfloat)firmware->te_params[table_num]->x_raw_upper,
(gfloat)firmware->te_params[table_num]->y_raw_lower,
(gfloat)firmware->te_params[table_num]->y_raw_upper);
OBJ_SET(curve,"x_entries",x_entries);
OBJ_SET(curve,"y_entries",y_entries);
if (firmware->te_params[table_num]->bind_to_list)
g_list_foreach(get_list_f(firmware->te_params[table_num]->bind_to_list),alter_widget_state_f,NULL);
create_rtv_value_change_watch_f(cdata->source,TRUE,"update_curve_marker",(gpointer)cdata);
gtk_container_add(GTK_CONTAINER(curve_parent),curve);
}
OBJ_SET(window,"widget_list",widget_list);
OBJ_SET(window,"curve_list",curve_list);
OBJ_SET(window,"gauge_list",gauge_list);
gtk_widget_show_all(window);
return TRUE;
}
/*!
\brief single_table_export() is the export function to dump one Tables
to a "vex" file.
\param iochannel a pointer to the output channel
\param table_num, integer number of table to export
\see single_table_import
\returns TRUE on success, FALSE on failure
*/
G_MODULE_EXPORT void single_table_export(GIOChannel *iochannel, gint table_num)
{
struct tm *tm = NULL;
time_t *t = NULL;
gint i = 0;
gint j = 0;
gint table = -1;
gsize count = 0;
gint index = 0;
gint x_page = 0;
gint y_page = 0;
gint z_page = 0;
gint x_base = 0;
gint y_base = 0;
gint z_base = 0;
DataSize x_size = 0;
DataSize y_size = 0;
DataSize z_size = 0;
gint x_mult = 0;
gint y_mult = 0;
gint z_mult = 0;
gint x_bincount = 0;
gint y_bincount = 0;
GIOStatus status;
GString *output = NULL;
gint canID = 0;
Firmware_Details *firmware = NULL;
firmware = DATA_GET(global_data,"firmware");
canID = firmware->canID;
/* For Page 0.... */
output = g_string_sized_new(64); /*pre-allocate 64 chars */
/*printf("total tables %i\n",firmware->total_tables);*/
table = table_num;
x_page = firmware->table_params[table]->x_page;
y_page = firmware->table_params[table]->y_page;
z_page = firmware->table_params[table]->z_page;
x_base = firmware->table_params[table]->x_base;
y_base = firmware->table_params[table]->y_base;
z_base = firmware->table_params[table]->z_base;
x_size = firmware->table_params[table]->x_size;
y_size = firmware->table_params[table]->y_size;
z_size = firmware->table_params[table]->z_size;
x_mult = get_multiplier_f(x_size);
y_mult = get_multiplier_f(y_size);
z_mult = get_multiplier_f(z_size);
x_bincount = firmware->table_params[table]->x_bincount;
y_bincount = firmware->table_params[table]->y_bincount;
t = g_malloc(sizeof(time_t));
time(t);
tm = localtime(t);
g_free(t);
if (vex_comment == NULL)
vex_comment = g_strdup("No comment given");
g_string_append_printf(output, "EVEME 1.0\n");
g_string_append_printf(output, "UserRev: 1.00\n");
g_string_append_printf(output, "UserComment: Table %i; (%s) %s\n",table,firmware->table_params[table]->table_name,vex_comment);
g_string_append_printf(output, "Date: %i-%.2i-%i\n",1+(tm->tm_mon),tm->tm_mday,1900+(tm->tm_year));
g_string_append_printf(output, "Time: %.2i:%.2i\n",tm->tm_hour,tm->tm_min);
g_string_append_printf(output, "Page %i\n",z_page);
g_string_append_printf(output, "VE Table RPM Range [%2i]\n",x_bincount);
for (i=0;i<x_bincount;i++)
g_string_append_printf(output," [%3d] = %3d\n",i,ms_get_ecu_data(canID,x_page,x_base+(i*x_mult),x_size));
g_string_append_printf(output, "VE Table Load Range (MAP) [%2i]\n",y_bincount);
for (i=0;i<y_bincount;i++)
g_string_append_printf(output, " [%3d] = %3d\n",i,ms_get_ecu_data(canID,y_page,y_base+(i*y_mult),y_size));
g_string_append_printf(output, "VE Table [%3i][%3i]\n",x_bincount,y_bincount);
g_string_append_printf(output, " ");
for (i=0;i<x_bincount;i++)
{
g_string_append_printf(output, "[%3d]",i);
if (i < (x_bincount-1))
g_string_append_printf(output, " ");
}
g_string_append_printf(output, "\n");
index = 0;
for (i=0;i<x_bincount;i++)
{
g_string_append_printf(output, " [%3d] =",i);
for (j=0;j<y_bincount;j++)
{
if (j == 0)
g_string_append_printf (output, " %3d",ms_get_ecu_data(canID,z_page,z_base+(index*z_mult),z_size));
else
g_string_append_printf (output, " %3d",ms_get_ecu_data(canID,z_page,z_base+(index*z_mult),z_size));
index++;
}
g_string_append_printf(output,"\n");
}
status = g_io_channel_write_chars(
iochannel,output->str,output->len,&count,NULL);
if (status != G_IO_STATUS_NORMAL)
{
dbg_func_f(CRITICAL,g_strdup(__FILE__": all_table_export()\n\tError exporting VEX file\n"));
}
g_string_free(output,TRUE);
update_logbar_f("tools_view",NULL,_("VE-Table(s) Exported Successfully\n"),FALSE,FALSE,FALSE);
if (vex_comment)
g_free(vex_comment);
vex_comment = NULL;
return; /* return TRUE on success, FALSE on failure */
}
/*!
\brief ECU specifc that gets called to send a value to the ECU.
\param canID is the can Identifier
\param locID is the Location ID to where this value belongs
\param offset is the offset from the beginning of the page that this data
refers to.
\param size is an enumeration corresponding to how big this variable is
\param value is the value that should be sent to the ECU At page/offset
\param queue_update if true queues a gui update, used to prevent
a horrible stall when doing an ECU restore or batch load...
*/
G_MODULE_EXPORT void libreems_send_to_ecu(gint canID, gint locID, gint offset, DataSize size, gint value, gboolean queue_update)
{
static Firmware_Details *firmware = NULL;
OutputData *output = NULL;
guint8 *data = NULL;
guint16 u16 = 0;
gint16 s16 = 0;
guint32 u32 = 0;
gint32 s32 = 0;
ENTER();
if (!firmware)
firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");
g_return_if_fail(firmware);
g_return_if_fail(offset >= 0);
MTXDBG(SERIAL_WR,_("Sending locID %i, offset %i, value %i \n"),locID,offset,value);
switch (size)
{
case MTX_CHAR:
case MTX_S08:
case MTX_U08:
/*printf("8 bit var %i at offset %i\n",value,offset);*/
break;
case MTX_S16:
case MTX_U16:
/*printf("16 bit var %i at offset %i\n",value,offset);*/
break;
case MTX_S32:
case MTX_U32:
/*printf("32 bit var %i at offset %i\n",value,offset);*/
break;
default:
printf(_("libreems_send_to_ecu() ERROR!!! Size undefined for variable at canID %i, offset %i\n"),locID,offset);
}
output = initialize_outputdata_f();
DATA_SET(output->data,"location_id", GINT_TO_POINTER(locID));
DATA_SET(output->data,"payload_id", GINT_TO_POINTER(REQUEST_UPDATE_BLOCK_IN_RAM));
DATA_SET(output->data,"offset", GINT_TO_POINTER(offset));
DATA_SET(output->data,"size", GINT_TO_POINTER(size));
DATA_SET(output->data,"value", GINT_TO_POINTER(value));
DATA_SET(output->data,"length", GINT_TO_POINTER(get_multiplier_f(size)));
DATA_SET(output->data,"mode", GINT_TO_POINTER(MTX_SIMPLE_WRITE));
/* Get memory */
data = g_new0(guint8,get_multiplier_f(size));
switch (size)
{
case MTX_CHAR:
case MTX_U08:
data[0] = (guint8)value;
break;
case MTX_S08:
data[0] = (gint8)value;
break;
case MTX_U16:
if (firmware->bigendian)
u16 = GUINT16_TO_BE((guint16)value);
else
u16 = GUINT16_TO_LE((guint16)value);
data[0] = (guint8)u16;
data[1] = (guint8)((guint16)u16 >> 8);
break;
case MTX_S16:
if (firmware->bigendian)
s16 = GINT16_TO_BE((gint16)value);
else
s16 = GINT16_TO_LE((gint16)value);
data[0] = (guint8)s16;
data[1] = (guint8)((gint16)s16 >> 8);
break;
case MTX_S32:
if (firmware->bigendian)
s32 = GINT32_TO_BE((gint32)value);
else
s32 = GINT32_TO_LE((gint32)value);
data[0] = (guint8)s32;
data[1] = (guint8)((gint32)s32 >> 8);
data[2] = (guint8)((gint32)s32 >> 16);
data[3] = (guint8)((gint32)s32 >> 24);
break;
case MTX_U32:
if (firmware->bigendian)
u32 = GUINT32_TO_BE((guint32)value);
else
u32 = GUINT32_TO_LE((guint32)value);
data[0] = (guint8)u32;
data[1] = (guint8)((guint32)u32 >> 8);
data[2] = (guint8)((guint32)u32 >> 16);
data[3] = (guint8)((guint32)u32 >> 24);
break;
default:
break;
}
DATA_SET_FULL(output->data,"data",(gpointer)data, g_free);
/* Set it here otherwise there's a risk of a missed burn due to
* a potential race condition in the burn checker
*/
libreems_set_ecu_data(canID,locID,offset,size,value);
/* IF the packet fails, update_write_status will rollback properly */
output->queue_update = queue_update;
io_cmd_f(firmware->write_command,output);
EXIT();
return;
}
/*!
\brief feed_import_data_to_ecu() Forwards the data in the VEX file to the
ECU. NOTE this may have problems with firmware using multiple tables in
a page, as the VEX format 1.0 does NOT handle that condition.
\param vex (Vex_Import *) pointer to the Vex_Impot datastructure.
*/
G_MODULE_EXPORT void feed_import_data_to_ecu(Vex_Import *vex)
{
gint i = 0;
gchar *tmpbuf = NULL;
guint8 **ecu_data = NULL;
guint8 **ecu_data_backup = NULL;
void *data = NULL;
gchar * msgbuf = NULL;
guchar *ptr = NULL;
guint16 *ptr16 = NULL;
guint32 *ptr32 = NULL;
gint total = 0;
gint canID = 0;
gint page = -1;
gint base = 0;
DataSize size = 0;
gint mult = 0;
gint table = -1;
Firmware_Details *firmware = NULL;
firmware = DATA_GET(global_data,"firmware");
ecu_data = firmware->ecu_data;
ecu_data_backup = firmware->ecu_data_backup;
/* Since we assume the page is where the table is this can cause
* major problems with some firmwares that use two tables inside
* of one page....
*/
page = vex->page;
table = vex->table;
if ((table < 0) || (table >= firmware->total_tables))
{
dbg_func_f(CRITICAL,g_strdup_printf(__FILE__": feed_import_data_to_ecu()\n\ttable passed (%i) is out of range(%i)\n",table,firmware->total_tables));
return;
}
/* If dimensions do NOT match, ABORT!!! */
if (firmware->table_params[table]->x_bincount != vex->total_x_bins)
{
msgbuf = g_strdup_printf(_("VEX Import: number of RPM bins inside VEXfile and FIRMWARE DO NOT MATCH (%i!=%i), aborting!!!\n"),firmware->table_params[table]->x_bincount,vex->total_x_bins);
update_logbar_f("tools_view","warning",msgbuf,FALSE,FALSE,FALSE);
dbg_func_f(CRITICAL,g_strdup(msgbuf));
g_free(msgbuf);
return;
}
if (firmware->table_params[table]->y_bincount != vex->total_y_bins)
{
msgbuf = g_strdup_printf(_("VEX Import: number of LOAD bins inside VEXfile and FIRMWARE DO NOT MATCH (%i!=%i), aborting!!!\n"),firmware->table_params[table]->y_bincount,vex->total_y_bins);
update_logbar_f("tools_view","warning",msgbuf,FALSE,FALSE,FALSE);
dbg_func_f(CRITICAL,g_strdup(msgbuf));
g_free(msgbuf);
return;
}
/* Backup the ALL pages of data first... */
for (i=0;i<firmware->total_pages;i++)
{
if (!firmware->page_params[i]->dl_by_default)
continue;
memset((void *)ecu_data_backup[i], 0, firmware->page_params[i]->length);
memcpy(ecu_data_backup[i], ecu_data[i],firmware->page_params[i]->length);
}
canID = firmware->canID;
page = firmware->table_params[table]->x_page;
base = firmware->table_params[table]->x_base;
size = firmware->table_params[table]->x_size;
mult = get_multiplier_f(size);
if (firmware->chunk_support)
{
total = vex->total_x_bins;
data = g_malloc0(mult*total);;
if (mult == 1)
{
ptr = (guchar *)data;
for (i=0;i<total;i++)
ptr[i]=vex->x_bins[i];
}
if (mult == 2)
{
ptr16 = (guint16 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr16[i]=GINT16_TO_BE(vex->x_bins[i]);
else
ptr16[i]=GINT16_TO_LE(vex->x_bins[i]);
}
}
if (mult == 4)
{
ptr32 = (guint32 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr32[i]=GINT_TO_BE(vex->x_bins[i]);
else
ptr32[i]=GINT_TO_LE(vex->x_bins[i]);
}
}
ms_chunk_write(canID,page,base,(total*mult),data);
}
else
{
for (i=0;i<vex->total_x_bins;i++)
{
if (vex->x_bins[i] != ms_get_ecu_data_last(canID,page,base+(i*mult),size))
ms_send_to_ecu(canID,page,base+i,size, vex->x_bins[i], TRUE);
}
}
canID = firmware->canID;
page = firmware->table_params[table]->y_page;
base = firmware->table_params[table]->y_base;
size = firmware->table_params[table]->y_size;
mult = get_multiplier_f(size);
if (firmware->chunk_support)
{
total = vex->total_y_bins;
data = g_malloc0(mult*total);
if (mult == 1)
{
ptr = (guchar *)data;
for (i=0;i<total;i++)
ptr[i]=vex->y_bins[i];
}
if (mult == 2)
{
ptr16 = (guint16 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr16[i]=GINT16_TO_BE(vex->y_bins[i]);
else
ptr16[i]=GINT16_TO_LE(vex->y_bins[i]);
}
}
if (mult == 4)
{
ptr32 = (guint32 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr32[i]=GINT_TO_BE(vex->y_bins[i]);
else
ptr32[i]=GINT_TO_LE(vex->y_bins[i]);
}
}
ms_chunk_write(canID,page,base,(total*mult),data);
}
else
{
for (i=0;i<vex->total_y_bins;i++)
{
if (vex->y_bins[i] != ms_get_ecu_data_last(canID,page,base+i,size))
ms_send_to_ecu(canID,page,base+(i*mult),size,vex->y_bins[i], TRUE);
}
}
canID = firmware->canID;
page = firmware->table_params[table]->z_page;
base = firmware->table_params[table]->z_base;
size = firmware->table_params[table]->z_size;
mult = get_multiplier_f(size);
if (firmware->chunk_support)
{
total = (vex->total_y_bins)*(vex->total_x_bins);
data = g_malloc0(mult*total);
if (mult == 1)
{
ptr = (guchar *)data;
for (i=0;i<total;i++)
ptr[i]=vex->tbl_bins[i];
}
if (mult == 2)
{
ptr16 = (guint16 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr16[i]=GINT16_TO_BE(vex->tbl_bins[i]);
else
ptr16[i]=GINT16_TO_LE(vex->tbl_bins[i]);
}
}
if (mult == 4)
{
ptr32 = (guint32 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr32[i]=GINT_TO_BE(vex->tbl_bins[i]);
else
ptr32[i]=GINT_TO_LE(vex->tbl_bins[i]);
}
}
ms_chunk_write(canID,page,base,(total*mult),data);
}
else
{
for (i=0;i<((vex->total_y_bins)*(vex->total_x_bins));i++)
{
if (vex->tbl_bins[i] != ms_get_ecu_data_last(canID,page,base+i,size))
ms_send_to_ecu(canID,page,base+(i*mult),size,vex->tbl_bins[i], TRUE);
}
}
io_cmd_f(firmware->burn_all_command,NULL);
tmpbuf = g_strdup_printf(_("VEX Import: VEtable on page %i updated with data from the VEX file\n"),vex->page);
update_logbar_f("tools_view",NULL,tmpbuf,FALSE,FALSE,FALSE);
g_free(tmpbuf);
}
