int verbose_init(int argc,char**argv){
a=(struct args*)malloc(sizeof(struct args));
a->focus=MF;
a->speed=SPEED;
a->delay=DELAY;
a->level=D_LEVEL;
a->focal=D_FOCAL;
a->file=0;
a->load=0;
a->width=D_WIDTH;
a->height=D_HEIGHT;
a->overlap=D_OVERLAP;
a->vwidth=D_VWIDTH;
a->vheight=D_VHEIGHT;
a->dummy=D_DUMMY;
a->shutter=1;
a->min=MIN_DEF;
a->max=MAX_DEF;
a->border=BORDER_DEF;
argp_parse(&argp,argc,argv,0,0,a);
slave_init("λ");
verbose(L_INFO,"α: %s",a->dummy?"dummy mode":"");
camera_action();
verbose(L_INFO,"ω:");
slave_stop();
}
void doSlave(int me){
rank=me;
receive_app_info();
slave_init();//开节点日志：1
task_rolling();
// wait_task();//等任务:2
// run_client();//运行客户程序:3
// update_slave_record();//更新记录状态:4
// send_back_result();//返回结果:5
}
int main(int argc, char **argv) {
slave_t slave;
io_service_t iosvc;
char *interface = NULL;
if (argc < 2) {
printf("usage: %s <interface>\n", argv[0]);
exit(0);
}
interface = argv[1];
srandom(time(NULL));
io_service_init(&iosvc);
if (!wait_for_sigterm_sigint(&iosvc)) {
LOG(LOG_LEVEL_FATAL, "Can't initiate SIGTERM awaiting: %s\n",
strerror(errno));
exit(1);
}
if (!slave_init(&slave, &iosvc, interface)) {
LOG_MSG(LOG_LEVEL_FATAL, "Can't initialize slave\n");
exit(1);
}
slave_run(&slave);
slave_deinit(&slave);
io_service_deinit(&iosvc);
return 0;
}
int main(void)
{
static unsigned int tmp = 0;
SET_OUTPUT(LED_R);
SET_OUTPUT(LED_G);
SET_OUTPUT(LED_B);
RESET_LED(LED_R);
RESET_LED(LED_G);
RESET_LED(LED_B);
#ifdef DCDCCTRL
SET_OUTPUT(DCDCCTRL);
RESET(DCDCCTRL);
#endif
battery_state = 0;
slave_init();
//uart_init();
timer_init();
mcan_init();
spi_init();
spi_adc_init();
relai_init();
adc_init();
sei();
if( (GPIOR0 & (1<<WDRF)) == (1<<WDRF) )
{
status("WDTRST ");
}
else if( (GPIOR0 & (1<<BORF)) == (1<<BORF) )
{
status("BORRST ");
}
else if( (GPIOR0 & (1<<EXTRF)) == (1<<EXTRF) )
{
status("START EX");
}
else if( (GPIOR0 & (1<<PORF)) == (1<<PORF) )
{
status("START PO");
}
else if( (GPIOR0 & (1<<JTRF)) == (1<<JTRF) )
{
status("START JT");
}
else
{
status("START ");
}
WDTCR = (1<<WDCE) | (1<<WDE);
WDTCR = (1<<WDE) | (1<<WDP2) | (1<<WDP1) | (1<<WDP0);
SET_LED(LED_G);
while (1)
{
__asm__ __volatile__ ("wdr");
if( battery_state & STATE_INTERMEDIATE )
{
intermediate_loop();
}
else if( battery_state & STATE_TRACTIVE )
{
tractive_loop();
}
else if( battery_state & STATE_CHARGING )
{
charge_loop();
}
else if( battery_state & STATE_BALANCING )
{
balancing_loop();
}
else
{
// standby mode
if( (tmp = mcan_check()) && !(battery_state & STATE_ERROR) )
{
switch(tmp)
{
case CAN_TRACTIVE_ENABLE: // CAN_TRACTIVE_ENABLE == 0x2F0
{
if( relai_volt < VCC_RELAI_MIN || vcc_volt < VCC_MIN )
{
status("NO VCC");
break;
}
// enable hv
intermediate_init();
dspace_heartbeat = 0;
battery_state |= STATE_TRACTIVE;
}
break;
case CAN_CHARGE_ENABLE: // CAN_CHARGE_ENABLE == 0x2FA
{
if( relai_volt < VCC_RELAI_MIN || vcc_volt < VCC_MIN )
{
status("NO VCC");
break;
}
// start charging
intermediate_init();
battery_state |= STATE_CHARGING;
}
break;
case CAN_BALANCING_ENABLE:
{
balancing_start();
battery_state |= STATE_BALANCING;
}
break;
}
}
}
slave_loop();
mcan_send_loop();
adc_loop();
}
return 0;
}
int
main (int argc, char **argv)
{
char *ch;
if (argc != 2) {
fputs("Invalid number of arguments\n", stderr);
fputs("usage: hspwrap EXEFILE\n", stderr);
exit(EXIT_FAILURE);
}
ch = getenv("HSP_BCAST_CHUNK_SIZE");
if (ch) {
sscanf(ch, "%zu", &bcast_chunk_size);
} else {
bcast_chunk_size = 4L << 20;
}
ch = getenv("HSP_INPUT_FORMAT");
if (!ch || ch[0] == '\0' || ch[0] == 'l') {
info("Input format: Lines\n");
input_fmt = 'l';
} else if (ch[0] == 'f') {
info("Input format: FASTA\n");
input_fmt = 'f';
} else {
fputs("Invalid input format specified\n", stderr);
exit(EXIT_FAILURE);
}
// Pre-fork process pool (even on master)
#ifndef TIMING_MODE
sleep(1);
pool_ctl = process_pool_fork();
trace("Process pool created.\n");
sleep(1);
#endif
// Initialize MPI
int rank, ranks;
if (MPI_Init(NULL, NULL) != MPI_SUCCESS) {
fprintf(stderr, "Error initialize MPI.\n");
return EXIT_FAILURE;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &ranks);
trace("MPI Initialized.\n");
// Initialize our state
timing_init(&timing);
if (rank) {
slave_init(rank, ranks-1, NUM_PROCS);
} else {
print_banner_slant(stderr);
master_init();
}
// Broadcast binary files first
if (rank) {
slave_broadcast_work_file("exefile");
} else {
master_broadcast_file(getenv("HSP_EXEFILE"));
}
// Distribute DB files
MPI_Barrier(MPI_COMM_WORLD);
timing_record(&timing.db_start);
char *dbdir = getenv("HSP_DBDIR");
char *dbfiles = strdup(getenv("HSP_DBFILES"));
char *fn, path[PATH_MAX];
for (fn = strtok(dbfiles, ":"); fn; fn = strtok(NULL, ":")) {
snprintf(path, sizeof(path), "%s/%s", dbdir, fn);
if (rank) {
timing.db_kbytes += slave_broadcast_shared_file(path)/1024;
} else {
timing.db_kbytes += master_broadcast_file(path)/1024;
}
}
free(dbfiles);
MPI_Barrier(MPI_COMM_WORLD);
timing_record(&timing.db_end);
#ifdef TIMING_MODE
if (!rank) {
timing_print(&timing);
}
MPI_Finalize();
return 0;
#endif
// FIXME: The order of things is generally wrong. Should be:
// Fork Forker, MPI_Init, PS Ctl, EXE/DB distro, forking, main loop
#if 0
// Now print some stats
if (rank) {
MPI_Barrier(MPI_COMM_WORLD);
printf("Rank %d Processes: %d", rank, ps_ctl->nprocesses);
printf(" Process ID: %d", getpid());
printf(" Files: %d (", ps_ctl->ft.nfiles);
for (i=0; i<ps_ctl->ft.nfiles; ++i) {
printf("%s, ", ps_ctl->ft.file[i].name);
}
puts(")");
} else {
printf("Ranks: %d\n\n", ranks);
MPI_Barrier(MPI_COMM_WORLD);
}
#endif
if (rank) {
slave_main(argv[1]);
} else {
master_main(ranks-1);
timing_print(&timing);
}
return 0;
}
BSP_S32 BSP_SLAVE_Init(BSP_VOID)
{
return slave_init();
}
int main(void)
{
usi_enable();
spiX_initslave(SPIMODE);
sei();
//Initialize slave
slave_init();
//Let settings catch up
_delay_ms(100);
//An initial packet, not sure what it's for, but the other code had it
prepare_packet("", 0);
spiX_put(0);
unsigned char input;
do{
//Wait for SS
while(!slave_selected());
//Wait for pending transfers
spiX_wait();
//Read first character from master
input = spiX_get();
//Is the master telling us to receive?
//If so, interpret the input and prepare a response packet
if(input == RECEIVE_CHAR)
{
//Retrieve the rest of the packet from master
receive_packet();
//Check integrity
if(!check_integrity())
{
prep_err();
continue;
}
//Lowercase are read operations
if(incoming_packet[1] > 96 && incoming_packet[1] < 127)
{
prep_response(incoming_packet[1]);
}
else
{
do_action(incoming_packet[1]);
}
}
//Is the master telling us that it's ready to receive?
else if(input == SEND_CHAR)
{
//Send the prepared packet
send_packet();
}
if(waiting_measure){
slave_run_measure();
waiting_measure = 0;
}
if(waiting_write){
slave_apply();
waiting_write = 0;
}
} while(1); // Loop forever...
}
