int calculate_track_dr(const char *filename, struct track_info *t, int number) {
struct stream_context sc;
struct dr_meter meter;
int err;
meter_init(&meter);
err = sc_open(&sc, filename);
if (err < 0) { return print_av_error("sc_open", err); }
if (debug) {
printf("DEBUG: Codec: %s\n", avcodec_get_name(sc_get_codec_id(&sc)));
}
int stream_index = err = av_find_best_stream(
sc.format_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
if (err < 0) { print_av_error("av_find_best_stream", err); goto cleanup; }
err = sc_start_stream(&sc, stream_index);
if (err < 0) { print_av_error("sc_start_stream", err); goto cleanup; }
t->artist = strdup(sc_get_metadata(&sc, "artist"));
t->album = strdup(sc_get_metadata(&sc, "album"));
t->tracknumber = strdup(sc_get_metadata(&sc, "track"));
t->title = strdup(sc_get_metadata(&sc, "title"));
AVCodecParameters *codecpar = sc_get_codec_parameters(&sc);
err = meter_start(&meter, codecpar->channels, codecpar->sample_rate, codecpar->format);
if (err) { goto cleanup; }
size_t fragment = 0;
int throbbler_stage = 0;
while (!sc_eof(&sc)) {
err = sc_get_next_frame(&sc);
if (err < 0) {
print_av_error("sc_get_next_frame", err);
goto cleanup;
}
err = meter_feed(&meter, sc_get_buf(&sc), sc_get_samples(&sc));
if (err) { goto cleanup; }
if (fragment < meter.fragment) {
fragment = meter.fragment;
if ((throbbler_stage % 4) == 0) {
fprintf(stderr, "\033[1K\033[1G"
"Analyzing track %i... "
"%c %2zu:%02zu ",
number,
throbbler[throbbler_stage / 4],
(fragment * 3) / 60,
(fragment * 3) % 60);
}
throbbler_stage += 1;
throbbler_stage %= 16;
}
}
fprintf(stderr, "\033[1K\033[1G");
meter_finish(&meter, t);
cleanup:
meter_free(&meter);
sc_close(&sc);
if (err < 0) {
return err;
}
return 0;
}
int do_calculate_dr(const char *filename) {
struct stream_context sc;
struct dr_meter meter;
int err;
meter_init(&meter);
err = sc_open(&sc, filename);
if (err < 0) { return print_av_error("sc_open", err); }
int stream_index = err = av_find_best_stream(
sc.format_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
if (err < 0) { print_av_error("av_find_best_stream", err); goto cleanup; }
err = sc_start_stream(&sc, stream_index);
if (err < 0) { print_av_error("sc_start_stream", err); goto cleanup; }
// Print out the stream info
AVCodecContext *codec_ctx = sc_get_codec(&sc);
char codecinfobuf[256];
avcodec_string(codecinfobuf, sizeof(codecinfobuf), codec_ctx, 0);
fprintf(stderr, "%.256s\n", codecinfobuf);
err = meter_start(&meter, codec_ctx->channels, codec_ctx->sample_rate, codec_ctx->sample_fmt);
if (err) { goto cleanup; }
fprintf(stderr, "Collecting fragments information...\n");
size_t fragment = 0;
int throbbler_stage = 0;
while (!sc_eof(&sc)) {
err = sc_get_next_frame(&sc);
if (err < 0) {
print_av_error("sc_get_next_frame", err);
goto cleanup;
}
err = meter_feed(&meter, sc.buf, sc.buf_size);
if (err) { goto cleanup; }
if (fragment < meter.fragment) {
fragment = meter.fragment;
if ((throbbler_stage % 4) == 0) {
fprintf(stderr, "\033[1K\033[1G %c %2i:%02i ",
throbbler[throbbler_stage / 4],
(fragment * 3) / 60,
(fragment * 3) % 60);
}
throbbler_stage += 1;
throbbler_stage %= 16;
}
}
meter_finish(&meter);
cleanup:
meter_free(&meter);
sc_close(&sc);
if (err < 0) {
return err;
}
return 0;
}
int
main(int argc, char *argv[])
{
int port = 2344;
const char *config = "sys161.conf";
const char *kernel = NULL;
int usetcp=0;
char *argstr = NULL;
int j, opt;
size_t argsize=0;
int debugwait=0;
int pass_signals=0;
#ifdef USE_TRACE
int profiling=0;
#endif
int use_second_console=0;
const char *second_console = NULL;
unsigned ncpus;
/* This must come absolutely first so msg() can be used. */
console_earlyinit();
if (sizeof(u_int32_t)!=4) {
/*
* Just in case.
*/
msg("sys161 requires sizeof(u_int32_t)==4");
die();
}
while ((opt = mygetopt(argc, argv, "c:f:p:Pst:wk:"))!=-1) {
switch (opt) {
case 'c': config = myoptarg; break;
case 'f':
#ifdef USE_TRACE
set_tracefile(myoptarg);
#endif
break;
case 'p': port = atoi(myoptarg); usetcp=1; break;
case 'P':
#ifdef USE_TRACE
profiling = 1;
#endif
break;
case 's': pass_signals = 1; break;
case 't':
#ifdef USE_TRACE
set_traceflags(myoptarg);
#endif
break;
case 'w': debugwait = 1; break;
case 'k':
use_second_console = 1;
second_console = myoptarg;
break;
default: usage(); break;
}
}
if (myoptind==argc) {
usage();
}
kernel = argv[myoptind++];
for (j=myoptind; j<argc; j++) {
argsize += strlen(argv[j])+1;
}
argstr = malloc(argsize+1);
if (!argstr) {
msg("malloc failed");
die();
}
*argstr = 0;
for (j=myoptind; j<argc; j++) {
strcat(argstr, argv[j]);
if (j<argc-1) strcat(argstr, " ");
}
/* This must come before bus_config in case a network card needs it */
mkdir(".sockets", 0700);
console_init(pass_signals, use_second_console, second_console);
clock_init();
ncpus = bus_config(config);
initstats(ncpus);
cpu_init(ncpus);
if (usetcp) {
gdb_inet_init(port);
}
else {
unlink(".sockets/gdb");
gdb_unix_init(".sockets/gdb");
}
unlink(".sockets/meter");
meter_init(".sockets/meter");
load_kernel(kernel, argstr);
msg("System/161 %s, compiled %s %s", VERSION, __DATE__, __TIME__);
#ifdef USE_TRACE
print_traceflags();
if (profiling) {
prof_setup();
}
#endif
if (debugwait) {
stoploop();
}
run();
#ifdef USE_TRACE
if (profiling) {
prof_write();
}
#endif
bus_cleanup();
console_cleanup();
clock_cleanup();
return 0;
}
gint init(void* arg) {
gint x;
gint y;
DISCOVERED* d;
char *res;
char wisdom_directory[1024];
char wisdom_file[1024];
fprintf(stderr,"init\n");
audio_get_cards(0);
audio_get_cards(1);
cursor_arrow=gdk_cursor_new(GDK_ARROW);
cursor_watch=gdk_cursor_new(GDK_WATCH);
GdkWindow *gdk_splash_window = gtk_widget_get_window(splash_window);
gdk_window_set_cursor(gdk_splash_window,cursor_watch);
init_radio();
// check if wisdom file exists
res=getcwd(wisdom_directory, sizeof(wisdom_directory));
strcpy(&wisdom_directory[strlen(wisdom_directory)],"/");
strcpy(wisdom_file,wisdom_directory);
strcpy(&wisdom_file[strlen(wisdom_file)],"wdspWisdom");
splash_status("Checking FFTW Wisdom file ...");
if(access(wisdom_file,F_OK)<0) {
int rc=sem_init(&wisdom_sem, 0, 0);
rc=pthread_create(&wisdom_thread_id, NULL, wisdom_thread, (void *)wisdom_directory);
while(sem_trywait(&wisdom_sem)<0) {
splash_status(wisdom_get_status());
while (gtk_events_pending ())
gtk_main_iteration ();
usleep(100000); // 100ms
}
}
while(!start) {
gdk_window_set_cursor(gdk_splash_window,cursor_watch);
selected_device=0;
devices=0;
splash_status("Old Protocol ... Discovering Devices");
old_discovery();
splash_status("New Protocol ... Discovering Devices");
new_discovery();
#ifdef LIMESDR
splash_status("LimeSDR ... Discovering Devices");
lime_discovery();
#endif
splash_status("Discovery");
if(devices==0) {
gdk_window_set_cursor(gdk_splash_window,cursor_arrow);
fprintf(stderr,"No devices found!\n");
GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
discovery_dialog = gtk_message_dialog_new (GTK_WINDOW(splash_window),
flags,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK_CANCEL,
"No devices found! Retry Discovery?");
gtk_widget_override_font(discovery_dialog, pango_font_description_from_string("FreeMono 18"));
gint result=gtk_dialog_run (GTK_DIALOG (discovery_dialog));
gtk_widget_destroy(discovery_dialog);
if(result==GTK_RESPONSE_CANCEL) {
_exit(0);
}
} else {
fprintf(stderr,"%s: found %d devices.\n", (char *)arg, devices);
gdk_window_set_cursor(gdk_splash_window,cursor_arrow);
GtkDialogFlags flags=GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
discovery_dialog = gtk_dialog_new_with_buttons ("Discovered",
GTK_WINDOW(splash_window),
flags,
#ifdef GPIO
"Configure GPIO",
GTK_RESPONSE_YES,
#endif
"Discover",
GTK_RESPONSE_REJECT,
"Exit",
GTK_RESPONSE_CLOSE,
NULL);
gtk_widget_override_font(discovery_dialog, pango_font_description_from_string("FreeMono 18"));
GtkWidget *content;
content=gtk_dialog_get_content_area(GTK_DIALOG(discovery_dialog));
GtkWidget *grid=gtk_grid_new();
gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE);
gtk_grid_set_row_spacing (GTK_GRID(grid),10);
int i;
char version[16];
char text[128];
for(i=0;i<devices;i++) {
d=&discovered[i];
fprintf(stderr,"%p protocol=%d name=%s\n",d,d->protocol,d->name);
if(d->protocol==ORIGINAL_PROTOCOL) {
sprintf(version,"%d.%d",
d->software_version/10,
d->software_version%10);
} else {
sprintf(version,"%d.%d.%d",
d->software_version/100,
(d->software_version%100)/10,
d->software_version%10);
}
switch(d->protocol) {
case ORIGINAL_PROTOCOL:
case NEW_PROTOCOL:
sprintf(text,"%s (%s %s) %s (%02X:%02X:%02X:%02X:%02X:%02X) on %s\n",
d->name,
d->protocol==ORIGINAL_PROTOCOL?"old":"new",
version,
inet_ntoa(d->info.network.address.sin_addr),
d->info.network.mac_address[0],
d->info.network.mac_address[1],
d->info.network.mac_address[2],
d->info.network.mac_address[3],
d->info.network.mac_address[4],
d->info.network.mac_address[5],
d->info.network.interface_name);
break;
#ifdef LIMESDR
case LIMESDR_PROTOCOL:
/*
sprintf(text,"%s (%s %s)\n",
d->name,
"lime",
version);
*/
sprintf(text,"%s\n",
d->name);
break;
#endif
}
GtkWidget *label=gtk_label_new(text);
gtk_widget_override_font(label, pango_font_description_from_string("FreeMono 12"));
gtk_widget_show(label);
gtk_grid_attach(GTK_GRID(grid),label,0,i,3,1);
GtkWidget *start_button=gtk_button_new_with_label("Start");
gtk_widget_override_font(start_button, pango_font_description_from_string("FreeMono 18"));
gtk_widget_show(start_button);
gtk_grid_attach(GTK_GRID(grid),start_button,3,i,1,1);
g_signal_connect(start_button,"pressed",G_CALLBACK(start_cb),(gpointer)d);
// if not available then cannot start it
if(d->status!=STATE_AVAILABLE) {
gtk_button_set_label(GTK_BUTTON(start_button),"In Use");
gtk_widget_set_sensitive(start_button, FALSE);
}
// if not on the same subnet then cannot start it
if((d->info.network.interface_address.sin_addr.s_addr&d->info.network.interface_netmask.sin_addr.s_addr) != (d->info.network.address.sin_addr.s_addr&d->info.network.interface_netmask.sin_addr.s_addr)) {
gtk_button_set_label(GTK_BUTTON(start_button),"Subnet!");
gtk_widget_set_sensitive(start_button, FALSE);
}
}
gtk_container_add (GTK_CONTAINER (content), grid);
gtk_widget_show_all(discovery_dialog);
gint result=gtk_dialog_run(GTK_DIALOG(discovery_dialog));
if(result==GTK_RESPONSE_CLOSE) {
_exit(0);
}
if(!start) {
gtk_widget_destroy(discovery_dialog);
}
#ifdef GPIO
if(result==GTK_RESPONSE_YES) {
configure_gpio(splash_window);
}
#endif
}
}
gdk_window_set_cursor(gdk_splash_window,cursor_watch);
splash_status("Initializing wdsp ...");
fprintf(stderr,"selected radio=%p device=%d\n",radio,radio->device);
protocol=radio->protocol;
device=radio->device;
switch(radio->protocol) {
case ORIGINAL_PROTOCOL:
case NEW_PROTOCOL:
sprintf(property_path,"%02X-%02X-%02X-%02X-%02X-%02X.props",
radio->info.network.mac_address[0],
radio->info.network.mac_address[1],
radio->info.network.mac_address[2],
radio->info.network.mac_address[3],
radio->info.network.mac_address[4],
radio->info.network.mac_address[5]);
break;
#ifdef LIMESDR
case LIMESDR_PROTOCOL:
sprintf(property_path,"limesdr.props");
break;
#endif
}
radioRestoreState();
fprintf(stderr,"malloc samples\n");
if(radio->protocol==NEW_PROTOCOL) {
samples=malloc(display_width*sizeof(float)*2*4); // 192 -> 48
} else {
samples=malloc(display_width*sizeof(float)*2);
}
//splash_status("Initializing wdsp ...");
fprintf(stderr,"wdsp_init\n");
wdsp_init(0,display_width,radio->protocol);
switch(radio->protocol) {
case ORIGINAL_PROTOCOL:
splash_status("Initializing old protocol ...");
fprintf(stderr,"old_protocol_init\n");
old_protocol_init(0,display_width);
break;
case NEW_PROTOCOL:
splash_status("Initializing new protocol ...");
fprintf(stderr,"new_protocol_init\n");
new_protocol_init(0,display_width);
break;
#ifdef LIMESDR
case LIMESDR_PROTOCOL:
splash_status("Initializing lime protocol ...");
lime_protocol_init(0,display_width);
break;
#endif
}
fprintf(stderr,"gpio_init\n");
splash_status("Initializing GPIO ...");
#ifdef GPIO
if(gpio_init()<0) {
}
#endif
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "pihpsdr");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
g_signal_connect (window, "delete-event", G_CALLBACK (main_delete), NULL);
fixed=gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
y=0;
fprintf(stderr,"vfo_height=%d\n",VFO_HEIGHT);
vfo = vfo_init(VFO_WIDTH,VFO_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),vfo,0,0);
rit_control = rit_init(RIT_WIDTH,MENU_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),rit_control,VFO_WIDTH,y);
fprintf(stderr,"menu_height=%d\n",MENU_HEIGHT);
//menu = menu_init(MENU_WIDTH,MENU_HEIGHT,window);
menu = new_menu_init(MENU_WIDTH-RIT_WIDTH,MENU_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),menu,VFO_WIDTH+((MENU_WIDTH/3)*2),y);
fprintf(stderr,"meter_height=%d\n",METER_HEIGHT);
meter = meter_init(METER_WIDTH,METER_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),meter,VFO_WIDTH+MENU_WIDTH,y);
y+=VFO_HEIGHT;
if(display_panadapter) {
int height=PANADAPTER_HEIGHT;
if(!display_waterfall) {
height+=WATERFALL_HEIGHT;
if(!display_sliders) {
height+=SLIDERS_HEIGHT;
}
if(!display_toolbar) {
height+=TOOLBAR_HEIGHT;
}
} else {
if(!display_sliders) {
height+=SLIDERS_HEIGHT/2;
}
}
fprintf(stderr,"panadapter_height=%d\n",height);
panadapter = panadapter_init(display_width,height);
gtk_fixed_put(GTK_FIXED(fixed),panadapter,0,VFO_HEIGHT);
y+=height;
}
if(display_waterfall) {
int height=WATERFALL_HEIGHT;
if(!display_panadapter) {
height+=PANADAPTER_HEIGHT;
}
if(!display_sliders) {
if(display_panadapter) {
height+=SLIDERS_HEIGHT/2;
} else {
height+=SLIDERS_HEIGHT;
}
}
if(!display_toolbar) {
height+=TOOLBAR_HEIGHT;
}
fprintf(stderr,"waterfall_height=%d\n",height);
waterfall = waterfall_init(display_width,height);
gtk_fixed_put(GTK_FIXED(fixed),waterfall,0,y);
y+=height;
}
#ifdef PSK
int psk_height=PSK_WATERFALL_HEIGHT;
if(!display_sliders) {
psk_height+=SLIDERS_HEIGHT/2;
}
if(!display_toolbar) {
psk_height+=TOOLBAR_HEIGHT/2;
}
psk_waterfall = psk_waterfall_init(display_width,psk_height);
gtk_fixed_put(GTK_FIXED(fixed),psk_waterfall,0,VFO_HEIGHT);
psk = init_psk();
gtk_fixed_put(GTK_FIXED(fixed),psk,0,VFO_HEIGHT+psk_height);
#endif
if(display_sliders) {
fprintf(stderr,"sliders_height=%d\n",SLIDERS_HEIGHT);
sliders = sliders_init(display_width,SLIDERS_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),sliders,0,y);
y+=SLIDERS_HEIGHT;
}
if(display_toolbar) {
fprintf(stderr,"toolbar_height=%d\n",TOOLBAR_HEIGHT);
toolbar = toolbar_init(display_width,TOOLBAR_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),toolbar,0,y);
y+=TOOLBAR_HEIGHT;
}
splash_close();
gtk_widget_show_all (window);
if(full_screen) {
gtk_window_fullscreen(GTK_WINDOW(window));
}
GdkWindow *gdk_window = gtk_widget_get_window(window);
gdk_window_set_cursor(gdk_window,cursor_arrow);
// start the receiver
SetChannelState(CHANNEL_RX0,1,1);
//update_timer_id=gdk_threads_add_timeout(1000/updates_per_second, update, NULL);
update_timer_id=gdk_threads_add_timeout_full(G_PRIORITY_HIGH_IDLE,1000/updates_per_second, update, NULL, NULL);
// save every 30 seconds
save_timer_id=gdk_threads_add_timeout(30000, save_cb, NULL);
if(protocol!=NEW_PROTOCOL) {
setFrequency(getFrequency());
}
#ifdef PSK
if(mode==modePSK) {
show_psk();
} else {
show_waterfall();
}
#endif
g_idle_add(vfo_update,(gpointer)NULL);
return 0;
}
void task_stopcharge(void * pvParameters)
{
static int num=0;
//read_meter_ALL
float stop_valueL=0;
float stop_valueR=0;
float basic_valueL=0;
float basic_valueR=0;
portTickType xLastWakeTime;
xLastWakeTime = xTaskGetTickCount();
P1R(1);
P2R(1);
meter_init();
#ifdef debug
printf("meter\r\n");
#endif
if(!read_meter_ALL(meter_num_L,1000)) {
PORTL.status=broken;
P1Y(1);
refresh_win0();
printf("first read left meter error\r\n");
}
if(!read_meter_ALL(meter_num_R,1000)) {
PORTR.status=broken;
P2Y(1);
refresh_win0();
printf("first read right meter error\r\n");
}
while(1) {
num++;
if(isstop==stopL.stop) {
P1GN;
if(!read_meter_ALL(meter_num_L,500)) { //充电过程中电表读取失败的处理，下同
PORTL.status=broken;
P1Y(1);
P1G(0);
close_port(&PORTL.port);
stopL.stop=stopnone;
refresh_win0();
goto Broken;
#ifdef debug
printf("read meter left error\r\n");
#endif
}
if(isbasic==stopL.basic) {
if(electric==stopL.charge_way) {
basic_valueL=KWHL;
stop_valueL=KWHL+stopL.value;
#ifdef debug
printf("stop_valueL:%f",stop_valueL);
#endif
}
if(money==stopL.charge_way) {
basic_valueL=KWHL;
stop_valueL=KWHL+(float)stopL.value/price;
#ifdef debug
printf("stop_valueL:%f\r\n",stop_valueL);
#endif
}
if(automate==stopL.charge_way) {
basic_valueL=KWHL;
#ifdef debug
printf("aautomate:%f\r\n",stop_valueL);
#endif
}
// get_ele_data(portL);
stopL.basic=nonebasic;
}
useL.value=KWHL-basic_valueL;
useL.money=useL.value*price;
// printf("valueL:%f",useL.value);
useL.value*=10;
useL.money*=10;
if((stopL.charge_way==money)||(stopL.charge_way==electric)) {
if(KWHL>=stop_valueL) {
close_port(&stopL.port);
PORTL.status=available;
stop_valueL=0;
refresh_win0();
memset(&useL,0,sizeof(useinfo));
memset(&stopL,0,sizeof(stop_charging));
}
}
if(stopL.charge_way==automate) {
if(electricityL<=threshold) { //电流低于阈值时停止充电
close_port(&stopL.port);
PORTL.status=available;
refresh_win0();
memset(&useL,0,sizeof(useinfo));
memset(&stopL,0,sizeof(stop_charging));
}
}
}
if(isstop==stopR.stop) {
P2GN;
if(!read_meter_ALL(meter_num_R,500)) {
close_port(&PORTR.port);
PORTR.status=broken;
P2Y(1);
P2G(0);
stopR.stop=stopnone;
refresh_win0();
goto Broken;
#ifdef debug
printf("read meter rigth error\r\n");
#endif
}
if(isbasic==stopR.basic) {
if(electric==stopR.charge_way) {
basic_valueR=KWHR;
stop_valueR=KWHR+stopR.value;
#ifdef debug
printf("stop_valueR:%f\r\n",stop_valueR);
#endif
}
if(money==stopR.charge_way) {
basic_valueR=KWHR;
stop_valueR=KWHR+(float)stopR.value/price;
#ifdef debug
printf("stop_valueR:%f\r\n",stop_valueR);
#endif
}
if(automate==stopR.charge_way) {
basic_valueR=KWHR;
#ifdef debug
printf("aautomate:%f\r\n",stop_valueR);
#endif
}
// get_ele_data(portR);
stopR.basic=nonebasic;
}
useR.value=KWHR-basic_valueR;
useR.money=useR.value*price;
// printf("valueR:%f",useR.value);
useR.value*=10;
useR.money*=10;
if((stopR.charge_way==money)||(stopR.charge_way==electric)) {
if(KWHR>=stop_valueR) {
close_port(&stopR.port);
PORTR.status=available;
stop_valueR=0;
refresh_win0();
memset(&useR,0,sizeof(useinfo));
memset(&stopR,0,sizeof(stop_charging));
#ifdef debug
printf("dianliang jine\r\n");
#endif
}
}
if(stopR.charge_way==automate) {
if(electricityR<=threshold) { //电流低于阈值时停止充电
close_port(&stopR.port);
PORTR.status=available;
stop_valueR=0;
refresh_win0();
memset(&useR,0,sizeof(useinfo));
memset(&stopR,0,sizeof(stop_charging));
#ifdef debug
printf("auto\r\n");
#endif
}
}
}
Broken:
if(broken==PORTL.status) {
if(read_meter_ALL(meter_num_L,300)) {
PORTL.status=available;
P1Y(0);
refresh_win0();
}
}
if(broken==PORTR.status) {
if(read_meter_ALL(meter_num_R,300)) {
PORTR.status=available;
P2Y(0);
refresh_win0();
}
}
vTaskDelayUntil( &xLastWakeTime, ( 100 / portTICK_RATE_MS ) );
}
}
