int Curl_debug(struct SessionHandle *data, curl_infotype type,
char *ptr, size_t size, char *host)
{
int rc;
if(data->set.printhost && host) {
char buffer[160];
const char *t=NULL;
switch (type) {
case CURLINFO_HEADER_IN:
case CURLINFO_DATA_IN:
t = "from";
break;
case CURLINFO_HEADER_OUT:
case CURLINFO_DATA_OUT:
t = "to";
break;
default:
break;
}
if(t) {
snprintf(buffer, sizeof(buffer), "[Data %s %s]", t, host);
rc = showit(data, CURLINFO_TEXT, buffer, strlen(buffer));
if(rc)
return rc;
}
}
rc = showit(data, type, ptr, size);
return rc;
}
int Curl_debug(struct SessionHandle *data, curl_infotype type,
char *ptr, size_t size,
struct connectdata *conn)
{
int rc;
if(data->set.printhost && conn && conn->host.dispname) {
char buffer[160];
const char *t=NULL;
const char *w="Data";
switch (type) {
case CURLINFO_HEADER_IN:
w = "Header";
case CURLINFO_DATA_IN:
t = "from";
break;
case CURLINFO_HEADER_OUT:
w = "Header";
case CURLINFO_DATA_OUT:
t = "to";
break;
default:
break;
}
if(t) {
snprintf(buffer, sizeof(buffer), "[%s %s %s]", w, t,
conn->host.dispname);
rc = showit(data, CURLINFO_TEXT, buffer, strlen(buffer));
if(rc)
return rc;
}
}
rc = showit(data, type, ptr, size);
return rc;
}
static
void
explode(int row, int col)
{
chtype bold;
erase();
MvPrintw(row, col, "-");
showit();
init_pair(1, get_colour(&bold), my_bg);
(void) attrset(COLOR_PAIR(1) | bold);
MvPrintw(row - 1, col - 1, " - ");
MvPrintw(row + 0, col - 1, "-+-");
MvPrintw(row + 1, col - 1, " - ");
showit();
init_pair(1, get_colour(&bold), my_bg);
(void) attrset(COLOR_PAIR(1) | bold);
MvPrintw(row - 2, col - 2, " --- ");
MvPrintw(row - 1, col - 2, "-+++-");
MvPrintw(row + 0, col - 2, "-+#+-");
MvPrintw(row + 1, col - 2, "-+++-");
MvPrintw(row + 2, col - 2, " --- ");
showit();
init_pair(1, get_colour(&bold), my_bg);
(void) attrset(COLOR_PAIR(1) | bold);
MvPrintw(row - 2, col - 2, " +++ ");
MvPrintw(row - 1, col - 2, "++#++");
MvPrintw(row + 0, col - 2, "+# #+");
MvPrintw(row + 1, col - 2, "++#++");
MvPrintw(row + 2, col - 2, " +++ ");
showit();
init_pair(1, get_colour(&bold), my_bg);
(void) attrset(COLOR_PAIR(1) | bold);
MvPrintw(row - 2, col - 2, " # ");
MvPrintw(row - 1, col - 2, "## ##");
MvPrintw(row + 0, col - 2, "# #");
MvPrintw(row + 1, col - 2, "## ##");
MvPrintw(row + 2, col - 2, " # ");
showit();
init_pair(1, get_colour(&bold), my_bg);
(void) attrset(COLOR_PAIR(1) | bold);
MvPrintw(row - 2, col - 2, " # # ");
MvPrintw(row - 1, col - 2, "# #");
MvPrintw(row + 0, col - 2, " ");
MvPrintw(row + 1, col - 2, "# #");
MvPrintw(row + 2, col - 2, " # # ");
showit();
}
int main(void) {
void showit(char*);
int i = 0;
printf("Adr etext:%8x\tAdr edata:%8x \t Adr end :%8x \n\n", &etext, &edata, &end);
SHW_ADR("main", main);
SHW_ADR("showit", showit);
SHW_ADR("cptr", cptr);
SHW_ADR("buffer1", buffer1);
SHW_ADR("i", i);
strcpy(buffer1, "A demonstration\n");
write(1, buffer1, strlen(buffer1) + 1);
for (; i < 1; ++i) {
showit(cptr);
}
return 0;
}
int main(int argc, char **argv)
{
FILE *tmpfd;
char makeMacro[ BUFSIZ ];
char makefileMacro[ BUFSIZ ];
program = argv[0];
init();
SetOpts(argc, argv);
Imakefile = FindImakefile(Imakefile);
CheckImakefileC(ImakefileC);
if (Makefile)
tmpMakefile = Makefile;
else {
tmpMakefile = Strdup(tmpMakefile);
(void) mkstemp(tmpMakefile);
}
AddMakeArg("-f");
AddMakeArg( tmpMakefile );
sprintf(makeMacro, "MAKE=%s", program);
AddMakeArg( makeMacro );
sprintf(makefileMacro, "MAKEFILE=%s", Imakefile);
AddMakeArg( makefileMacro );
if ((tmpfd = fopen(tmpMakefile, "w+")) == NULL)
LogFatal("Cannot create temporary file %s.", tmpMakefile);
cleanedImakefile = CleanCppInput(Imakefile);
cppit(cleanedImakefile, Template, ImakefileC, tmpfd, tmpMakefile);
if (show) {
if (Makefile == NULL)
showit(tmpfd);
} else
makeit();
wrapup();
exit(0);
}
static void
preview(DepositControls *controls,
DepositArgs *args)
{
GwyDataField *dfield, *lfield, *zlfield, *zdfield;
gint xres, yres, oxres, oyres;
gint add, i, ii, m, k;
gdouble size, width;
gint xdata[10000];
gint ydata[10000];
gdouble disizes[10000];
gdouble rdisizes[10000];
gdouble rx[10000];
gdouble ry[10000];
gdouble rz[10000];
gdouble ax[10000];
gdouble ay[10000];
gdouble az[10000];
gdouble vx[10000];
gdouble vy[10000];
gdouble vz[10000];
gdouble fx[10000];
gdouble fy[10000];
gdouble fz[10000];
gint xpos, ypos, ndata, too_close;
gdouble disize, mdisize;
gdouble xreal, yreal, oxreal, oyreal;
gdouble diff;
gdouble mass = 1;
gint presetval;
gint nloc, maxloc = 1;
gint max = 5000000;
gdouble rxv, ryv, rzv, timestep = 3e-7; //5e-7
deposit_dialog_update_values(controls, args);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
gwy_container_set_object_by_name(controls->mydata, "/0/data", gwy_data_field_duplicate(controls->old_dfield));
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
if (controls->in_init)
{
gwy_data_field_data_changed(dfield);
while (gtk_events_pending())
gtk_main_iteration();
return;
}
oxres = gwy_data_field_get_xres(dfield);
oyres = gwy_data_field_get_yres(dfield);
oxreal = gwy_data_field_get_xreal(dfield);
oyreal = gwy_data_field_get_yreal(dfield);
diff = oxreal/oxres/10;
size = args->size*5e-9;
// width = args->width*5e-9 + 2*size; //increased manually to fill boundaries
width = 2*size;
add = gwy_data_field_rtoi(dfield, size + width);
mdisize = gwy_data_field_rtoi(dfield, size);
xres = oxres + 2*add;
yres = oyres + 2*add;
xreal = oxreal + 2*(size+width);
yreal = oyreal + 2*(size+width);
// printf("For field of size %g and particle nominak %g, real %g (%g), the final size will change from %d to %d\n",
// gwy_data_field_get_xreal(dfield), args->size, size, disize, oxres, xres);
/*make copy of datafield, with mirrored boundaries*/
lfield = gwy_data_field_new(xres, yres,
gwy_data_field_itor(dfield, xres),
gwy_data_field_jtor(dfield, yres),
TRUE);
gwy_data_field_area_copy(dfield, lfield, 0, 0, oxres, oyres, add, add);
gwy_data_field_invert(dfield, 1, 0, 0);
gwy_data_field_area_copy(dfield, lfield, 0, oyres-add-1, oxres, add, add, 0);
gwy_data_field_area_copy(dfield, lfield, 0, 0, oxres, add, add, yres-add-1);
gwy_data_field_invert(dfield, 1, 0, 0);
gwy_data_field_invert(dfield, 0, 1, 0);
gwy_data_field_area_copy(dfield, lfield, oxres-add-1, 0, add, oyres, 0, add);
gwy_data_field_area_copy(dfield, lfield, 0, 0, add, oyres, xres-add-1, add);
gwy_data_field_invert(dfield, 0, 1, 0);
gwy_data_field_invert(dfield, 1, 1, 0);
gwy_data_field_area_copy(dfield, lfield, oxres-add-1, oyres-add-1, add, add, 0, 0);
gwy_data_field_area_copy(dfield, lfield, 0, 0, add, add, xres-add-1, yres-add-1);
gwy_data_field_area_copy(dfield, lfield, oxres-add-1, 0, add, add, 0, yres-add-1);
gwy_data_field_area_copy(dfield, lfield, 0, oyres-add-1, add, add, xres-add-1, 0);
gwy_data_field_invert(dfield, 1, 1, 0);
zlfield = gwy_data_field_duplicate(lfield);
zdfield = gwy_data_field_duplicate(dfield);
/*determine number of spheres necessary for given coverage*/
for (i=0; i<10000; i++)
{
ax[i] = ay[i] = az[i] = vx[i] = vy[i] = vz[i] = 0;
}
srand ( time(NULL) );
ndata = 0;
/* for test only */
/*
disize = mdisize;
xpos = oxres/2 - 2*disize;
ypos = oyres/2;
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres;
ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres;
rz[ndata] = 2.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata];
ndata++;
xpos = oxres/2 + 2*disize;
ypos = oyres/2;
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres;
ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres;
rz[ndata] = 2.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata];
ndata++;
*/
/*end of test*/
i = 0;
presetval = args->coverage*10;
while (ndata < presetval && i<max)
{
//disize = mdisize*(0.8+(double)(rand()%20)/40.0);
disize = mdisize;
xpos = disize+(rand()%(xres-2*(gint)(disize+1))) + 1;
ypos = disize+(rand()%(yres-2*(gint)(disize+1))) + 1;
i++;
{
too_close = 0;
/*sync real to integer positions*/
for (k=0; k<ndata; k++)
{
if (((xpos-xdata[k])*(xpos-xdata[k]) + (ypos-ydata[k])*(ypos-ydata[k]))<(4*disize*disize))
{
too_close = 1;
break;
}
}
if (too_close) continue;
if (ndata>=10000) {
break;
}
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres;
ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres;
//printf("surface at %g, particle size %g\n", gwy_data_field_get_val(lfield, xpos, ypos), rdisizes[ndata]);
rz[ndata] = 1.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata]; //2
ndata++;
}
};
// if (i==max) printf("Maximum reached, only %d particles depositd instead of %d\n", ndata, presetval);
// else printf("%d particles depositd\n", ndata);
/*refresh shown data and integer positions (necessary in md calculation)*/
gwy_data_field_copy(zlfield, lfield, 0);
showit(lfield, zdfield, rdisizes, rx, ry, rz, xdata, ydata, ndata,
oxres, oxreal, oyres, oyreal, add, xres, yres);
gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0);
gwy_data_field_data_changed(dfield);
for (i=0; i<(20*args->revise); i++)
{
// printf("###### step %d of %d ##########\n", i, (gint)(20*args->revise));
/*try to add some particles if necessary, do this only for first half of molecular dynamics*/
if (ndata<presetval && i<(10*args->revise)) {
ii = 0;
nloc = 0;
while (ndata < presetval && ii<(max/1000) && nloc<maxloc)
{
disize = mdisize;
xpos = disize+(rand()%(xres-2*(gint)(disize+1))) + 1;
ypos = disize+(rand()%(yres-2*(gint)(disize+1))) + 1;
ii++;
{
too_close = 0;
rxv = ((gdouble)xpos*oxreal/(gdouble)oxres);
ryv = ((gdouble)ypos*oyreal/(gdouble)oyres);
rzv = gwy_data_field_get_val(zlfield, xpos, ypos) + 5*size;
for (k=0; k<ndata; k++)
{
if (((rxv-rx[k])*(rxv-rx[k])
+ (ryv-ry[k])*(ryv-ry[k])
+ (rzv-rz[k])*(rzv-rz[k]))<(4.0*size*size))
{
too_close = 1;
break;
}
}
if (too_close) continue;
if (ndata>=10000) {
// printf("Maximum reached!\n");
break;
}
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = rxv;
ry[ndata] = ryv;
rz[ndata] = rzv;
vz[ndata] = -0.01;
ndata++;
nloc++;
}
};
// if (ii==(max/100)) printf("Maximum reached, only %d particles now present instead of %d\n", ndata, presetval);
// else printf("%d particles now at surface\n", ndata);
}
/*test succesive LJ steps on substrate (no relaxation)*/
for (k=0; k<ndata; k++)
{
fx[k] = fy[k] = fz[k] = 0;
/*calculate forces for all particles on substrate*/
if (gwy_data_field_rtoi(lfield, rx[k])<0
|| gwy_data_field_rtoj(lfield, ry[k])<0
|| gwy_data_field_rtoi(lfield, rx[k])>=xres
|| gwy_data_field_rtoj(lfield, ry[k])>=yres)
continue;
for (m=0; m<ndata; m++)
{
if (m==k) continue;
// printf("(%g %g %g) on (%g %g %g)\n", rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]);
fx[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k]+diff, ry[k], rz[k], gwy_data_field_itor(dfield, disizes[k]))
-get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k]-diff, ry[k], rz[k], gwy_data_field_itor(dfield, disizes[k])))/2/diff;
fy[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k]+diff, rz[k], gwy_data_field_itor(dfield, disizes[k]))
-get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k]-diff, rz[k], gwy_data_field_itor(dfield, disizes[k])))/2/diff;
fz[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]+diff, gwy_data_field_itor(dfield, disizes[k]))
-get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]-diff, gwy_data_field_itor(dfield, disizes[k])))/2/diff;
}
fx[k] -= (integrate_lj_substrate(zlfield, rx[k]+diff, ry[k], rz[k], rdisizes[k])
- integrate_lj_substrate(zlfield, rx[k]-diff, ry[k], rz[k], rdisizes[k]))/2/diff;
fy[k] -= (integrate_lj_substrate(zlfield, rx[k], ry[k]-diff, rz[k], rdisizes[k])
- integrate_lj_substrate(zlfield, rx[k], ry[k]+diff, rz[k], rdisizes[k]))/2/diff;
fz[k] -= (integrate_lj_substrate(zlfield, rx[k], ry[k], rz[k]+diff, rdisizes[k])
- integrate_lj_substrate(zlfield, rx[k], ry[k], rz[k]-diff, rdisizes[k]))/2/diff;
}
for (k=0; k<ndata; k++)
{
if (gwy_data_field_rtoi(lfield, rx[k])<0
|| gwy_data_field_rtoj(lfield, ry[k])<0
|| gwy_data_field_rtoi(lfield, rx[k])>=xres
|| gwy_data_field_rtoj(lfield, ry[k])>=yres)
continue;
/*move all particles*/
rx[k] += vx[k]*timestep + 0.5*ax[k]*timestep*timestep;
vx[k] += 0.5*ax[k]*timestep;
ax[k] = fx[k]/mass;
vx[k] += 0.5*ax[k]*timestep;
vx[k] *= 0.9;
if (fabs(vx[k])>0.01) vx[k] = 0; //0.2
ry[k] += vy[k]*timestep + 0.5*ay[k]*timestep*timestep;
vy[k] += 0.5*ay[k]*timestep;
ay[k] = fy[k]/mass;
vy[k] += 0.5*ay[k]*timestep;
vy[k] *= 0.9;
if (fabs(vy[k])>0.01) vy[k] = 0; //0.2
rz[k] += vz[k]*timestep + 0.5*az[k]*timestep*timestep;
vz[k] += 0.5*az[k]*timestep;
az[k] = fz[k]/mass;
vz[k] += 0.5*az[k]*timestep;
vz[k] *= 0.9;
if (fabs(vz[k])>0.01) vz[k] = 0;
if (rx[k]<=gwy_data_field_itor(dfield, disizes[k])) rx[k] = gwy_data_field_itor(dfield, disizes[k]);
if (ry[k]<=gwy_data_field_itor(dfield, disizes[k])) ry[k] = gwy_data_field_itor(dfield, disizes[k]);
if (rx[k]>=(xreal-gwy_data_field_itor(dfield, disizes[k]))) rx[k] = xreal-gwy_data_field_itor(dfield, disizes[k]);
if (ry[k]>=(yreal-gwy_data_field_itor(dfield, disizes[k]))) ry[k] = yreal-gwy_data_field_itor(dfield, disizes[k]);
}
gwy_data_field_copy(zlfield, lfield, 0);
showit(lfield, zdfield, rdisizes, rx, ry, rz, xdata, ydata, ndata,
oxres, oxreal, oyres, oyreal, add, xres, yres);
gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0);
gwy_data_field_data_changed(dfield);
while (gtk_events_pending())
gtk_main_iteration();
}
gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0);
gwy_data_field_data_changed(dfield);
args->computed = TRUE;
gwy_object_unref(lfield);
gwy_object_unref(zlfield);
gwy_object_unref(zdfield);
}
// Find the device, and set up to read it periodically, then send
// the data out stdout so another process can pick it up and do
// something reasonable with it.
//
int main(int argc, char **argv)
{
char *usage = {"usage: %s -u -n\n"};
int libusbDebug = 0; //This will turn on the DEBUG for libusb
int noisy = 0; //This will print the packets as they come in
libusb_device **devs;
int r, err, c;
ssize_t cnt;
while ((c = getopt (argc, argv, "unh")) != -1)
switch (c){
case 'u':
libusbDebug = 1;
break;
case 'n':
noisy = 1;
break;
case 'h':
fprintf(stderr, usage, argv[0]);
case '?':
exit(1);
default:
exit(1);
}
fprintf(stderr,"%s Starting ... ",argv[0]);
fprintf(stderr,"libusbDebug = %d, noisy = %d\n", libusbDebug, noisy);
// The Pi linker can give you fits. If you get a linker error on
// the next line, set LD_LIBRARY_PATH to /usr/local/lib
fprintf(stderr,"This is not an error!! Checking linker, %s\n", libusb_strerror(0));
if (signal(SIGINT, sig_handler) == SIG_ERR)
fprintf(stderr,"Couldn't set up signal handler\n");
err = libusb_init(NULL);
if (err < 0){
fprintf(stderr,"Couldn't init usblib, %s\n", libusb_strerror(err));
exit(1);
}
// This is where you can get debug output from libusb.
// just set it to LIBUSB_LOG_LEVEL_DEBUG
if (libusbDebug)
libusb_set_debug(NULL, LIBUSB_LOG_LEVEL_DEBUG);
else
libusb_set_debug(NULL, LIBUSB_LOG_LEVEL_INFO);
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0){
fprintf(stderr,"Couldn't get device list, %s\n", libusb_strerror(err));
exit(1);
}
// go get the device; the device handle is saved in weatherStation struct.
if (!findDevice(devs)){
fprintf(stderr,"Couldn't find the device\n");
exit(1);
}
// Now I've found the weather station and can start to try stuff
// So, I'll get the device descriptor
struct libusb_device_descriptor deviceDesc;
err = libusb_get_device_descriptor(weatherStation.device, &deviceDesc);
if (err){
fprintf(stderr,"Couldn't get device descriptor, %s\n", libusb_strerror(err));
exit(1);
}
fprintf(stderr,"got the device descriptor back\n");
// Open the device and save the handle in the weatherStation struct
err = libusb_open(weatherStation.device, &weatherStation.handle);
if (err){
fprintf(stderr,"Open failed, %s\n", libusb_strerror(err));
closeUpAndLeave(); }
fprintf(stderr,"I was able to open it\n");
// Now that it's opened, I can free the list of all devices
libusb_free_device_list(devs, 1); // Documentation says to get rid of the list
// Once I have the device I need
fprintf(stderr,"Released the device list\n");
err = libusb_set_auto_detach_kernel_driver(weatherStation.handle, 1);
if(err){
fprintf(stderr,"Some problem with detach %s\n", libusb_strerror(err));
closeUpAndLeave();
}
int activeConfig;
err =libusb_get_configuration(weatherStation.handle, &activeConfig);
if (err){
fprintf(stderr,"Can't get current active configuration, %s\n", libusb_strerror(err));;
closeUpAndLeave();
}
fprintf(stderr,"Currently active configuration is %d\n", activeConfig);
if(activeConfig != 1){
err = libusb_set_configuration (weatherStation.handle, 1);
if (err){
fprintf(stderr,"Cannot set configuration, %s\n", libusb_strerror(err));;
closeUpAndLeave();
}
fprintf(stderr,"Just did the set configuration\n");
}
err = libusb_claim_interface(weatherStation.handle, 0); //claim interface 0 (the first) of device (mine had just 1)
if(err) {
fprintf(stderr,"Cannot claim interface, %s\n", libusb_strerror(err));
closeUpAndLeave();
}
fprintf(stderr,"Claimed Interface\n");
// I don't want to just hang up and read the reports as fast as I can, so
// I'll space them out a bit. It's weather, and it doesn't change very fast.
sleep(1);
fprintf(stderr,"Setting the device 'idle' before starting reads\n");
err = libusb_control_transfer(weatherStation.handle,
0x21, 0x0a, 0, 0, 0, 0, 1000);
sleep(1);
int tickcounter= 0;
fprintf(stderr,"Starting reads\n");
while(1){
sleep(1);
if(tickcounter++ % 10 == 0){
getit(1, noisy);
}
if(tickcounter % 30 == 0){
getit(2, noisy);
}
if (tickcounter % 15 == 0){
showit();
}
}
}
int foo(int bar)
{
switch (bar)
{
case 0:
{
showit(0);
}
c++;
break;
case 1:
{
showit(bar);
break;
}
case 2:
{
break;
}
case 3:
{
int a = bar * 3;
showit(a);
}
c++;
break;
case 4:
{
foo(bar - 1);
{
showit(0);
}
}
case 10:
{
switch (gl_bug)
{
case 'a':
{
gl_foo = true;
break;
}
case 'b':
case 'c':
{
gl_foo = false;
break;
}
default:
{
// nothing
break;
}
}
break;
}
default:
{
break;
}
}
return(-1);
}
