void test_key_schedule_128bitkey(){
unsigned char keys[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char expected[] =
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x62, 0x63, 0x63, 0x63, 0x62, 0x63, 0x63, 0x63, 0x62, 0x63, 0x63, 0x63, 0x62, 0x63, 0x63, 0x63,
0x9b, 0x98, 0x98, 0xc9, 0xf9, 0xfb, 0xfb, 0xaa, 0x9b, 0x98, 0x98, 0xc9, 0xf9, 0xfb, 0xfb, 0xaa,
0x90, 0x97, 0x34, 0x50, 0x69, 0x6c, 0xcf, 0xfa, 0xf2, 0xf4, 0x57, 0x33, 0x0b, 0x0f, 0xac, 0x99,
0xee, 0x06, 0xda, 0x7b, 0x87, 0x6a, 0x15, 0x81, 0x75, 0x9e, 0x42, 0xb2, 0x7e, 0x91, 0xee, 0x2b,
0x7f, 0x2e, 0x2b, 0x88, 0xf8, 0x44, 0x3e, 0x09, 0x8d, 0xda, 0x7c, 0xbb, 0xf3, 0x4b, 0x92, 0x90,
0xec, 0x61, 0x4b, 0x85, 0x14, 0x25, 0x75, 0x8c, 0x99, 0xff, 0x09, 0x37, 0x6a, 0xb4, 0x9b, 0xa7,
0x21, 0x75, 0x17, 0x87, 0x35, 0x50, 0x62, 0x0b, 0xac, 0xaf, 0x6b, 0x3c, 0xc6, 0x1b, 0xf0, 0x9b,
0x0e, 0xf9, 0x03, 0x33, 0x3b, 0xa9, 0x61, 0x38, 0x97, 0x06, 0x0a, 0x04, 0x51, 0x1d, 0xfa, 0x9f,
0xb1, 0xd4, 0xd8, 0xe2, 0x8a, 0x7d, 0xb9, 0xda, 0x1d, 0x7b, 0xb3, 0xde, 0x4c, 0x66, 0x49, 0x41,
0xb4, 0xef, 0x5b, 0xcb, 0x3e, 0x92, 0xe2, 0x11, 0x23, 0xe9, 0x51, 0xcf, 0x6f, 0x8f, 0x18, 0x8e};
key_schedule(keys, 16);
print_keys(keys, 176);
printf("\n");
print_keys(expected, 176);
assert( bytencmp(keys, expected, 176) == 0 );
}
void AvlNode::print_keys(AvlIndex tree)
{
if (tree)
{
print_keys(AVLNODE(tree)->left);
PRINT(F(" "));
PRINTLN((int)AVLNODE(tree)->key);
print_keys(AVLNODE(tree)->right);
}
}
void
add_key(char *keyname){
if (nlsr->debugging)
{
printf("add_key called\n");
printf("Keyname : %s \n",keyname);
}
struct nlsr_key *key;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
int res;
hashtb_start(nlsr->keys, e);
res = hashtb_seek(e, keyname, strlen(keyname), 0);
if(res == HT_NEW_ENTRY )
{
key=e->data;
key->key_name=(char *)calloc(strlen(keyname)+1,sizeof(char));
memcpy(key->key_name,keyname,strlen(keyname)+1);
}
if (nlsr->debugging)
print_keys();
}
//------------------------------------------------------------------------------
int set(int argc, char** argv)
{
int ret;
// Check we're running from a Clink session.
extern int g_in_clink_context;
if (!g_in_clink_context)
{
puts("ERROR: The 'set' verb must be run from a process with Clink present");
return 1;
}
// Get the path where Clink's storing its settings.
get_config_dir(g_settings_path, sizeof_array(g_settings_path));
str_cat(g_settings_path, "/settings", sizeof_array(g_settings_path));
// Load Clink's settings.
g_settings = initialise_clink_settings();
if (g_settings == NULL)
{
printf("ERROR: Failed to load Clink's settings from '%s'.", g_settings_path);
return 1;
}
// List or set Clink's settings.
ret = 0;
switch (argc)
{
case 0:
case 1:
ret = print_keys();
break;
case 2:
if (_stricmp(argv[1], "--help") == 0 ||
_stricmp(argv[1], "-h") == 0)
{
ret = 1;
print_usage();
}
else
{
ret = print_value(argv[1]);
}
break;
default:
ret = set_value(argv[1], argv[2]);
if (!ret)
{
settings_save(g_settings, g_settings_path);
}
break;
}
settings_shutdown(g_settings);
return ret;
}
int main(int argc, char **argv) {
if (pif_error(argc < 2, "No command specified"))
return usage(-1);
if (pif_error(argc < 3, "No DB path specified"))
return usage(-1);
char *cmd = argv[1];
char *keyData[JFT_KEY_LIMIT];
JFDB *db;
JFT_Stem prefix = (JFT_Stem) {.data = (uint8_t *)keyData};
JFT_Symbol *stop = NULL;
JFT_Offset offset;
switch (cmd[0]) {
case 'm':
case 'n':
case 'k':
case 'f':
case 'l':
db = JFDB_open(argv[2], 0);
if (JFDB_pif_error(db, "Failed to open"))
return -1;
switch (cmd[0]) {
case 'm':
print_meta(db);
break;
case 'n':
offset = argc > 3 ? atoi(argv[3]) : db->tip.cp.offset;
offset = MAX(offset, sizeof(JFDB_Header));
print_info(db, &prefix, db->kmap.map + offset, &null);
break;
case 'k':
if (!prefix_opts(&prefix, &stop, argc - 2, argv + 2))
print_keys(db, &prefix, stop);
break;
case 'f':
if (!prefix_opts(&prefix, &stop, argc - 2, argv + 2))
print_find(db, &prefix, stop);
break;
case 'l':
load_input(db, stdin);
break;
}
if (JFDB_close(db))
return -1;
break;
case 'w':
if (pif_error(JFDB_wipe(argv[2]), "Failed to wipe"))
return -1;
break;
default:
usage(1);
break;
}
return 0;
}
static void
parse_file(krb5_context context, krb5_principal principal, int no_salt)
{
krb5_error_code ret;
size_t nkeys;
Key *keys;
ret = hdb_generate_key_set(context, principal, &keys, &nkeys, no_salt);
if (ret)
krb5_err(context, 1, ret, "hdb_generate_key_set");
print_keys(context, keys, nkeys);
hdb_free_keys(context, nkeys, keys);
}
int com_keys_print(char* arg) {
char* a = strtok(arg, " ");
if (a && strtok(NULL, " ") != (char*)NULL) {
printf("Too many arguments\n");
return -1;
}
mf_size_t size = parse_size_default(a, MF_1K);
if (size == MF_INVALID_SIZE) {
printf("Unknown argument: %s\n", a);
return -1;
}
print_keys(¤t_auth, size);
return 0;
}
int
main(int argc, char *argv[])
{
int c, nostop=0;
char *h;
int i_rc = 0;
cd_operation_t cd_op = NO_OP; /* operation to do in non-interactive mode */
psz_program = strrchr(argv[0],'/');
psz_program = psz_program ? psz_program+1 : argv[0];
memset(&cddb_opts, 0, sizeof(cddb_opts));
cdio_loglevel_default = CDIO_LOG_WARN;
/* parse options */
while ( 1 ) {
if (-1 == (c = getopt(argc, argv, "acCdehkplL:sSt:vx")))
break;
switch (c) {
case 'v':
b_verbose = true;
if (cdio_loglevel_default > CDIO_LOG_INFO)
cdio_loglevel_default = CDIO_LOG_INFO;
break;
case 'd':
debug = 1;
if (cdio_loglevel_default > CDIO_LOG_DEBUG)
cdio_loglevel_default = CDIO_LOG_DEBUG;
break;
case 'a':
auto_mode = 1;
break;
case 'L':
i_volume_level = atoi(optarg);
cd_op = SET_VOLUME;
b_interactive = false;
break;
case 't':
if (NULL != (h = strchr(optarg,'-'))) {
*h = 0;
start_track = atoi(optarg);
stop_track = atoi(h+1)+1;
if (0 == start_track) start_track = 1;
if (1 == stop_track) stop_track = CDIO_CDROM_LEADOUT_TRACK;
} else {
start_track = atoi(optarg);
stop_track = start_track+1;
one_track = 1;
}
b_interactive = false;
cd_op = PLAY_TRACK;
break;
case 'p':
b_interactive = false;
cd_op = PLAY_CD;
break;
case 'l':
b_interactive = false;
cd_op = LIST_TRACKS;
break;
case 'C':
b_interactive = false;
cd_op = CLOSE_CD;
break;
case 'c':
b_interactive = false;
cd_op = PS_LIST_TRACKS;
break;
case 's':
b_interactive = false;
cd_op = STOP_PLAYING;
break;
case 'S':
b_interactive = false;
cd_op = LIST_SUBCHANNEL;
break;
case 'e':
b_interactive = false;
cd_op = EJECT_CD;
break;
case 'k':
print_keys();
exit(1);
case 'h':
usage(psz_program);
exit(1);
default:
usage(psz_program);
exit(1);
}
}
if (argc > optind) {
psz_device = strdup(argv[optind]);
} else {
char **ppsz_cdda_drives=NULL;
char **ppsz_all_cd_drives = cdio_get_devices_ret(&driver_id);
if (!ppsz_all_cd_drives) {
fprintf(stderr, "Can't find a CD-ROM drive\n");
exit(2);
}
ppsz_cdda_drives = cdio_get_devices_with_cap(ppsz_all_cd_drives,
CDIO_FS_AUDIO, false);
if (!ppsz_cdda_drives || !ppsz_cdda_drives[0]) {
fprintf(stderr, "Can't find a CD-ROM drive with a CD-DA in it\n");
exit(3);
}
psz_device = strdup(ppsz_cdda_drives[0]);
cdio_free_device_list(ppsz_all_cd_drives);
cdio_free_device_list(ppsz_cdda_drives);
}
if (!b_interactive) {
b_sig = true;
nostop=1;
}
tty_raw();
signal(SIGINT,ctrlc);
signal(SIGQUIT,ctrlc);
signal(SIGTERM,ctrlc);
signal(SIGHUP,ctrlc);
signal(SIGWINCH, sigwinch);
if (CLOSE_CD != cd_op) {
/* open device */
if (b_verbose)
fprintf(stderr, "open %s... ", psz_device);
p_cdio = cdio_open (psz_device, driver_id);
if (!p_cdio && cd_op != EJECT_CD) {
cd_close(psz_device);
p_cdio = cdio_open (psz_device, driver_id);
}
if (p_cdio && b_verbose)
fprintf(stderr,"ok\n");
}
if (b_interactive) {
#ifdef HAVE_CDDB
cddb_log_set_handler (cddb_log_handler);
#else
;
#endif
} else {
b_sig = true;
nostop=1;
if (EJECT_CD == cd_op) {
i_rc = cd_eject() ? 0 : 1;
} else {
switch (cd_op) {
case PS_LIST_TRACKS:
case LIST_TRACKS:
case PLAY_TRACK:
read_toc(p_cdio);
default:
break;
}
if (p_cdio)
switch (cd_op) {
case STOP_PLAYING:
b_cd = true;
i_rc = cd_stop(p_cdio) ? 0 : 1;
break;
case EJECT_CD:
/* Should have been handled above. */
cd_eject();
break;
case LIST_TRACKS:
list_tracks();
break;
case PS_LIST_TRACKS:
ps_list_tracks();
break;
case PLAY_TRACK:
/* play just this one track */
if (b_record) {
printf("%s / %s\n", artist, title);
if (one_track)
printf("%s\n", cd_info[start_track].title);
}
i_rc = play_track(start_track, stop_track) ? 0 : 1;
break;
case PLAY_CD:
if (b_record)
printf("%s / %s\n", artist, title);
play_track(1,CDIO_CDROM_LEADOUT_TRACK);
break;
case SET_VOLUME:
i_rc = set_volume_level(p_cdio, i_volume_level);
break;
case LIST_SUBCHANNEL:
if (read_subchannel(p_cdio)) {
if (sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY) {
{
printf("track %2d - %02x:%02x (%02x:%02x abs) ",
sub.track, sub.rel_addr.m, sub.rel_addr.s,
sub.abs_addr.m, sub.abs_addr.s);
}
}
printf("drive state: %s\n",
mmc_audio_state2str(sub.audio_status));
} else {
i_rc = 1;
}
break;
case CLOSE_CD: /* Handled below */
case LIST_KEYS:
case TOGGLE_PAUSE:
case EXIT_PROGRAM:
case NO_OP:
break;
}
else if (CLOSE_CD == cd_op) {
i_rc = (DRIVER_OP_SUCCESS == cdio_close_tray(psz_device, NULL))
? 0 : 1;
} else {
fprintf(stderr,"no CD in drive (%s)\n", psz_device);
}
}
}
/* Play all tracks *unless* we have a play or paused status
already. */
read_subchannel(p_cdio);
if (sub.audio_status != CDIO_MMC_READ_SUB_ST_PAUSED &&
sub.audio_status != CDIO_MMC_READ_SUB_ST_PLAY)
play_track(1, CDIO_CDROM_LEADOUT_TRACK);
while ( !b_sig ) {
int key;
if (!b_cd) read_toc(p_cdio);
read_subchannel(p_cdio);
display_status(false);
if (1 == select_wait(b_cd ? 1 : 5)) {
switch (key = getch()) {
case '-':
decrease_volume_level(p_cdio);
break;
case '+':
increase_volume_level(p_cdio);
break;
case 'A':
case 'a':
auto_mode = !auto_mode;
break;
case 'X':
case 'x':
nostop=1;
/* fall through */
case 'Q':
case 'q':
b_sig = true;
break;
case 'E':
case 'e':
cd_eject();
break;
case 's':
cd_stop(p_cdio);
break;
case 'C':
case 'c':
cd_close(psz_device);
break;
case 'L':
case 'l':
b_all_tracks = !b_all_tracks;
if (b_all_tracks)
display_tracks();
else {
i_last_display_track = CDIO_INVALID_TRACK;
display_cdinfo(p_cdio, i_tracks, i_first_track);
}
break;
case 'K':
case 'k':
case 'h':
case 'H':
case '?':
list_keys();
break;
case ' ':
case 'P':
case 'p':
toggle_pause();
break;
case KEY_RIGHT:
if (b_cd &&
(sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY))
play_track(sub.track+1, CDIO_CDROM_LEADOUT_TRACK);
else
play_track(1,CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_LEFT:
if (b_cd &&
(sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY))
play_track(sub.track-1,CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_UP:
if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
skip(10);
break;
case KEY_DOWN:
if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
skip(-10);
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
play_track(key - '0', CDIO_CDROM_LEADOUT_TRACK);
break;
case '0':
play_track(10, CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_F(1):
case KEY_F(2):
case KEY_F(3):
case KEY_F(4):
case KEY_F(5):
case KEY_F(6):
case KEY_F(7):
case KEY_F(8):
case KEY_F(9):
case KEY_F(10):
case KEY_F(11):
case KEY_F(12):
case KEY_F(13):
case KEY_F(14):
case KEY_F(15):
case KEY_F(16):
case KEY_F(17):
case KEY_F(18):
case KEY_F(19):
case KEY_F(20):
play_track(key - KEY_F(1) + 11, CDIO_CDROM_LEADOUT_TRACK);
break;
}
}
}
if (!nostop) cd_stop(p_cdio);
tty_restore();
finish("bye", i_rc);
return 0; /* keep compiler happy */
}
int main(int argc, char * argv[]) {
COMPS_MRTree *tree, *tree2, *cloned1, *cloned2;
COMPS_HSList * keyslist;
char * keys[] = {"some key", "some Cray", "some", "anything"};
int x1 = 10;
int x2 = 11;
int x3 = 12;
int y1 = 20;
int y2 = 21;
int y3 = 22;
int z1 = 30;
int z2 = 31;
int z3 = 32;
int udata = 9;
void * data;
tree = comps_mrtree_create(&int_cloner, &int_cloner, &free);
printf(">> Building tree\n");
/* Root
*/
comps_mrtree_set(tree,"some key",(void*)&x1);
comps_mrtree_set(tree,"some key",(void*)&x2);
printf(
" Root \n"
" ['some key']-->10,11 \n"
" \n"
"");
comps_mrtree_set(tree,"some Cray",(void*)&y1);
comps_mrtree_set(tree,"some Cray",(void*)&y2);
printf(
" Root \n"
" ['some']-->|-['Cray']-->20,21\n"
" |-['key']-->10,11 \n"
"");
comps_mrtree_set(tree,"some",(void*)&z1);
comps_mrtree_set(tree,"some",(void*)&z3);
printf(
" Root \n"
" ['some']-->|-['Cray']-->20,21\n"
" | |-['key']-->10,11 \n"
" V \n"
" 30,32 \n"
"");
comps_mrtree_set(tree,"anything",(void*)&z2);
printf(
" Root \n"
" [anythink]['some']-->|-['Cray']-->20,21\n"
" | | |-['key']-->10,11 \n"
" V V \n"
" 31 30,32 \n"
"");
printf(">> Incrementing all values by %d\n", udata);
comps_mrtree_values_walk(tree, &udata, &inc);
print_data4keys(tree, keys, 4);
data = comps_mrtree_get(tree, "sAme Cray");
print_intp_data(data, "sAme Cray");
printf("------------\n");
printf(">> Getting all keys for tree:\n");
keyslist = comps_mrtree_keys(tree);
print_keys(keyslist);
comps_hslist_destroy(&keyslist);
printf("------------\n");
printf(">> Adding %d to 'some key'\n", x3);
comps_mrtree_set(tree,"some key",(void*)&x3);
data = comps_mrtree_get(tree, "some key");
print_intp_data(data, "some key (modified)");
printf("------------\n");
printf(">> Removing 'some Cray'\n");
comps_mrtree_unset(tree, "some Cray");
print_data4keys(tree, keys, 4);
printf("------------\n");
printf(">> Clonning tree\n");
cloned1 = comps_mrtree_clone(tree);
printf(">> Incrementing all values in clonned tree by %d\n", udata);
comps_mrtree_values_walk(cloned1, &udata, &inc);
printf(">> Original tree data:\n");
data = comps_mrtree_get(cloned1, "some key");
print_data4keys(tree, keys, 4);
printf("\n");
printf(">> Cloned tree data:\n");
print_data4keys(cloned1, keys, 4);
printf("------------\n");
printf("\n");
printf(">> Clonning from clone\n");
cloned2 = comps_mrtree_clone(cloned1);
printf(">> Incrementing all values in clonned2 tree by %d\n", udata);
printf(">> Data for original clone\n");
comps_mrtree_values_walk(cloned1, &udata, &inc);
print_data4keys(cloned1, keys, 4);
printf("\n");
printf(">> Data for cloned clone\n");
comps_mrtree_values_walk(cloned1, &udata, &inc);
print_data4keys(cloned1, keys, 4);
comps_mrtree_destroy(cloned1);
comps_mrtree_destroy(cloned2);
printf("------------\n");
printf(">> Removing 'some'\n");
comps_mrtree_unset(tree, "some");
data = comps_mrtree_get(tree, "some key");
print_intp_data(data, "some key");
data = comps_mrtree_get(tree, "some");
print_intp_data(data, "some");
printf("------------\n");
printf(">> Adding %d to key 'anyones' shortened to len 6 [anyone]\n", x3);
comps_mrtree_set_n(tree,"anyones", 6,(void*)&x3);
data = comps_mrtree_get(tree, "anyones");
print_intp_data(data, "anyones");
data = comps_mrtree_get(tree, "anyone");
print_intp_data(data, "anyone");
tree2 = comps_mrtree_create(&int_cloner, &int_cloner, &free);
printf(">> Building tree2\n");
comps_mrtree_set(tree2,"foo",(void*)&x1);
//comps_mrtree_set(tree2,"bar",(void*)&x2);
printf(
" Root \n"
" ['foo']['bar'] \n"
" | | \n"
" V V \n"
" 109 100 \n"
"");
udata = 99;
//comps_mrtree_values_walk(tree2, &udata, &inc);
data = comps_mrtree_get(tree2, "foo");
print_intp_data(data, "foo");
data = comps_mrtree_get(tree2, "bar");
print_intp_data(data, "bar");
printf(">> Adding tree2 to tree1 (tree1 = tree1 + tree2)\n");
comps_mrtree_unite(tree, tree2);
printf("Keylist\n");
printf(">> Getting all keys for tree:\n");
keyslist = comps_mrtree_keys(tree);
print_keys(keyslist);
comps_hslist_destroy(&keyslist);
data = comps_mrtree_get(tree, "foo");
print_intp_data(data, "foo");
data = comps_mrtree_get(tree, "bar");
print_intp_data(data, "bar");
comps_mrtree_destroy(tree);
comps_mrtree_destroy(tree2);
return 0;
}
int main(int argc, char* argv[]) {
int nbytes;
int status;
unsigned int previous, ch;
unsigned int temp_extruder = 0, temp_bed = 0;
// rename TODO
unsigned int key_mask=0;
unsigned int jog_distance = DEFAULT_JOG_DISTANCE;
unsigned int jog_speed = DEFAULT_JOG_SPEED;
unsigned int temp_target = DEFAULT_TEMP_TARGET;
unsigned int feedrate = DEFAULT_FEEDRATE;
// Explain?
float delta_e = 0.001666669999999968 * (float)feedrate;;
// TODO heater on/off keys
// TODO consider a struct to hold state, then we can declare it once
// and pass a single pointer around to various functions!!!
// TODO float? need to?
int posX=0, posY=0, posZ=0;
float posE=0.0;
int extruding=0;
time_t last_temp = time(NULL);
time_t last_extrude = time(NULL);
int pipe_gcode = 0, pipe_feedback = 0;
//stream_gcode = fdopen(pipe_gcode[1], "w");
FILE *stream_gcode = NULL, *stream_feedback = NULL;
// User options
char *serial_port = NULL;
char *cmd = NULL; // Command string to execute austerus-core
//size_t line_feedback_len = PIPE_LINE_BUFFER_LEN;
//char *line_feedback = NULL;
char line_feedback[LINE_FEEDBACK_LEN];
// Allocate inital size of input line buffer
//pipe_buffer = (char *) malloc (pipe_buffer_len + 1);
// Read command line options
int option_index = 0, opt=0;
static struct option loptions[] = {
{"help", no_argument, 0, 'h'},
{"port", required_argument, 0, 'p'},
{"baud", required_argument, 0, 'b'},
{"verbose", no_argument, 0, 'v'}
};
// Generate the command line for austerus-core
asprintf(&cmd, "/usr/bin/env AG_ACKCOUNT=1 PATH=$PWD:$PATH");
while(opt >= 0) {
opt = getopt_long(argc, argv, "hp:b:v", loptions,
&option_index);
switch (opt) {
case 'h':
usage();
return EXIT_SUCCESS;
case 'p':
serial_port = optarg;
asprintf(&cmd, "%s AG_SERIALPORT=%s", cmd,
optarg);
break;
case 'b':
asprintf(&cmd, "%s AG_BAUDRATE=%ld", cmd,
strtol(optarg, NULL, 10));
break;
case 'v':
asprintf(&cmd, "%s AG_VERBOSE=1", cmd);
break;
}
}
if (!serial_port & !getenv("AG_SERIALPORT")) {
fprintf(stderr, "A serial port must be specified\n");
return EXIT_FAILURE;
}
asprintf(&cmd, "%s austerus-core", cmd);
// Open the gcode output stream to austerus-core
popen2(cmd, &pipe_gcode, &pipe_feedback);
free(cmd);
// Make feedback pipe non-blocking
fcntl(pipe_feedback, F_SETFL, O_NONBLOCK);
stream_gcode = fdopen(pipe_gcode, "w");
stream_feedback = fdopen(pipe_feedback, "r");
if (!stream_gcode) {
fprintf(stderr, "unable to open output stream\n");
return EXIT_FAILURE;
}
if (!stream_feedback) {
fprintf(stderr, "unable to open feedback stream\n");
return EXIT_FAILURE;
}
// Start curses mode
initscr();
// Line buffering disabled
raw();
// We get F1, F2 etc
keypad(stdscr, TRUE);
// Don't echo() while we do getch
noecho();
// Hide cursor
curs_set(0);
// Timeout so we can run extruder and check for feedback
timeout(CURSES_TIMEOUT);
// draw initial screen
mvprintw(0, 0, "austerusG %s", VERSION);
mvprintw(0, 30, "- +");
print_fkeys(PANEL_POS_NUMBERS_X, PANEL_POS_NUMBERS_Y);
print_extruder_keys(key_mask);
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
print_temperature(temp_extruder, temp_target);
print_feedrate(feedrate);
print_jog_distance(jog_distance);
print_jog_speed(jog_speed);
print_fan(0);
mvprintw(LINES - 1, 0, "Status: Idle");
refresh();
// start of print reset
fprintf(stream_gcode, "M110\n");
// set absolute positioning
fprintf(stream_gcode, "G90\n");
// set to mm
fprintf(stream_gcode, "G21\n");
// reset coordinates to zero
fprintf(stream_gcode, "G92 X0 Y0 Z0 E0\n");
fflush(stream_gcode);
while (1) {
// Wait for user input
ch = getch();
// Handle any two key sequences
switch (previous) {
case KEY_HOME:
if (home_axis(stream_gcode, ch)) {
key_mask = key_mask & !BIT_H;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
}
break;
case KEY_END:
if (end_axis(stream_gcode, ch)) {
key_mask = key_mask & !BIT_END;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
}
break;
}
// Handle single key press
switch (ch) {
case '1':
// Decrease target temperature
if (temp_target > 0) {
temp_target = temp_target - 1;
fprintf(stream_gcode, "M104 S%d\n", temp_target);
fflush(stream_gcode);
print_temperature(temp_extruder, temp_target);
}
break;
case '2':
// Increase target temperature
temp_target = temp_target + 1;
fprintf(stream_gcode, "M104 S%d\n", temp_target);
fflush(stream_gcode);
print_temperature(temp_extruder, temp_target);
break;
case '3':
// Decrease feedrate
if (feedrate >= 1) {
feedrate -= 1;
delta_e = 0.001666669999999968 * (float)feedrate;
print_feedrate(feedrate);
}
break;
case '4':
// Increase feedrate
feedrate += 1;
delta_e = 0.001666669999999968 * (float)feedrate;
print_feedrate(feedrate);
break;
case '5':
// Decrease jog distance
if (jog_distance > 10) {
fprintf(stream_gcode, "M104 %d\n", temp_target);
fflush(stream_gcode);
jog_distance = jog_distance - 10;
print_jog_distance(jog_distance);
}
break;
case '6':
// Increase jog distance
jog_distance = jog_distance + 10;
print_jog_distance(jog_distance);
break;
case '7':
// Decrease jog speed
if (jog_speed > 10) {
jog_speed = jog_speed - 100;
print_jog_speed(jog_speed);
}
break;
case '8':
// Increase jog speed
jog_speed = jog_speed + 100;
print_jog_speed(jog_speed);
break;
case 'e':
extruding = 1;
key_mask = (key_mask | BIT_E) & ~(BIT_D | BIT_R);
print_extruder_keys(key_mask);
break;
case 'd':
extruding = 0;
key_mask = (key_mask | BIT_D) & ~(BIT_E | BIT_R);
print_extruder_keys(key_mask);
break;
case 'r':
extruding = -1;
key_mask = (key_mask | BIT_R) & ~(BIT_D | BIT_E);
print_extruder_keys(key_mask);
break;
case KEY_LEFT:
// Jog X axis minus
// TODO merits of G0 or G1 moves?
posX -= jog_distance;
fprintf(
stream_gcode, "G1 X%d Y%d Z%d F%d\n",
posX, posY, posZ, jog_speed
);
fflush(stream_gcode);
key_mask = key_mask | BIT_MX;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
break;
case KEY_RIGHT:
// Jog X axis plus
posX += jog_distance;
fprintf(
stream_gcode, "G1 X%d Y%d Z%d F%d\n",
posX, posY, posZ, jog_speed
);
fflush(stream_gcode);
key_mask = key_mask | BIT_PX;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
break;
case KEY_UP:
// Jog Y axis plus
posY += jog_distance;
fprintf(
stream_gcode, "G1 X%d Y%d Z%d F%d\n",
posX, posY, posZ, jog_speed
);
fflush(stream_gcode);
key_mask = key_mask | BIT_PY;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
break;
case KEY_DOWN:
// Jog Y axis minus
posY -= jog_distance;
fprintf(
stream_gcode, "G1 X%d Y%d Z%d F%d\n",
posX, posY, posZ, jog_speed
);
fflush(stream_gcode);
key_mask = key_mask | BIT_MY;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
break;
case KEY_PPAGE:
// Jog Z axis up
posZ += jog_distance;
fprintf(
stream_gcode, "G1 X%d Y%d Z%d F%d\n",
posX, posY, posZ, jog_speed
);
fflush(stream_gcode);
key_mask = key_mask | BIT_PZ;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
break;
case KEY_NPAGE:
// Jog Z axis down
posZ -= jog_distance;
fprintf(
stream_gcode, "G1 X%d Y%d Z%d F%d\n",
posX, posY, posZ, jog_speed
);
fflush(stream_gcode);
key_mask = key_mask | BIT_MZ;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
break;
case KEY_HOME:
// Start of two key move to home command
key_mask = key_mask | BIT_H;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
previous = ch;
break;
case KEY_END:
// Start of two key move to end command
key_mask = key_mask | BIT_END;
print_keys(PANEL_POS_KEYS_X, PANEL_POS_KEYS_Y, key_mask);
previous = ch;
break;
case 'f':
case 'F':
// Fan on
fprintf(stream_gcode, "M106\n");
fflush(stream_gcode);
print_fan(1);
break;
case 'g':
case 'G':
// Fan off
fprintf(stream_gcode, "M107\n");
fflush(stream_gcode);
print_fan(0);
break;
case 'q':
case KEY_ESC:
// Shutdown printer
fprintf(stream_gcode, "M112\n");
// Exit core
fprintf(stream_gcode, "#ag:exit\n\n");
fflush(stream_gcode);
endwin();
pclose(stream_gcode);
pclose(stream_feedback);
close(pipe_gcode);
close(pipe_feedback);
//if (line_feedback)
// free(line_feedback);
wait(&status);
printf("core exit = %d\n", status);
return EXIT_SUCCESS;
}
// TODO check core alive?
if (time(NULL) - last_temp > TEMP_PERIOD)
{
do {
nbytes = nonblock_getline(line_feedback, stream_feedback);
//nbytes = getline(&line_feedback, &line_feedback_len, stream_feedback);
//fprintf(stream_gcode, "NB %d %s\n", nbytes);
//fflush(stream_gcode);
if (nbytes > 0) {
mvprintw(LINES - 3, 0, "nb %d", nbytes);
sscanf(line_feedback, "ok T:%d B:%d", &temp_extruder, &temp_bed);
//
if (nbytes > 66) {
line_feedback[63] = '.';
line_feedback[64] = '.';
line_feedback[65] = '.';
line_feedback[66] = '\0';
}
mvprintw(LINES - 2, 0, "Response: %s", line_feedback);
print_temperature(temp_extruder, temp_target);
}
} while (nbytes != -1);
last_temp = time(NULL);
fprintf(stream_gcode, "M105\n");
fflush(stream_gcode);
// tODO this needs it's own clock too!
// tODO arrow keys etc
if (key_mask | BIT_D) {
key_mask = key_mask & ~BIT_D;
print_extruder_keys(key_mask);
}
// We can make one mask #def? from all keys we want cleared
// and use it for check andf clear!
}
if (time(NULL) - last_extrude > EXTRUDE_PERIOD)
{
last_extrude = time(NULL);
// This needs to be on an indepentent time check so it can be controlled!! TODO
if (extruding > 0) {
posE += delta_e;
fprintf(stream_gcode, "G1 E%.2f F%d\n", posE, feedrate);
fflush(stream_gcode);
} else if (extruding < 0) {
posE -= delta_e;
fprintf(stream_gcode, "G1 E%.2f F%d\n", posE, feedrate);
fflush(stream_gcode);
}
// tODO arrow keys etc
if (key_mask | BIT_D) {
key_mask = key_mask & ~BIT_D;
print_extruder_keys(key_mask);
}
// We can make one mask #def? from all keys we want cleared
// and use it for check andf clear!
}
refresh();
// TODO check core is still alive
}
}
void main (int argc, char** argv)
{
int Message_counter ; /* counter for message packing */
int My_tid ; /* my task id */
/* show start up message */
printf ("\n-=> Fractal Terrain Engine version 2.1 release 2 <=-\n\n") ;
/* read the config files */
read_config (argc,argv) ;
/* set up the pixel buffer and it's variables */
Pixel_buffer_width=User_view.X_size/Number_of_workers;
Pixel_buffer_size=
Pixel_buffer_width*User_view.Y_size*3*sizeof(unsigned char) ;
Pixel_buffer=(unsigned char *) malloc(Pixel_buffer_size) ;
/* set up worker tids array */
Worker_tids=(int *)malloc(Number_of_workers*sizeof(int)) ;
/* set up the image buffer */
Image_buffer=(unsigned char *) malloc
((User_view.X_size*User_view.Y_size*3*sizeof(unsigned char))) ;
/* start up pvm */
if ((My_tid = pvm_mytid()) < 0)
{
exit(1);
}
/* start up the workers */
pvm_spawn(WORKER_NAME,(char**)0,PvmTaskDefault,"",
Number_of_workers,Worker_tids) ;
printf ("INFO:Spawned %i Workers\n",Number_of_workers) ;
/* tell the worker what values to use for the terrain function */
pvm_initsend(PvmDataDefault) ;
pvm_pkdouble(&H,1,1) ;
pvm_pkdouble(&Lacunarity,1,1);
pvm_pkdouble(&Octaves,1,1);
pvm_pkdouble(&Offset,1,1) ;
pvm_pkfloat(&Ambient_light,1,1) ;
pvm_pkfloat(&Fog.Red,1,1) ;
pvm_pkfloat(&Fog.Green,1,1);
pvm_pkfloat(&Fog.Blue,1,1) ;
pvm_pkfloat(&Sky.Red,1,1) ;
pvm_pkfloat(&Sky.Green,1,1) ;
pvm_pkfloat(&Sky.Blue,1,1) ;
pvm_pkfloat(&Horizon.Red,1,1) ;
pvm_pkfloat(&Horizon.Green,1,1) ;
pvm_pkfloat(&Horizon.Blue,1,1) ;
pvm_pkdouble(Colour_boundaries,NUMBER_OF_TERRAIN_COLOURS,1) ;
for ( Message_counter = 0 ;
Message_counter<NUMBER_OF_TERRAIN_COLOURS ;
Message_counter++ )
{
pvm_pkfloat(&Terrain_colours[Message_counter].Red,1,1) ;
pvm_pkfloat(&Terrain_colours[Message_counter].Green,1,1) ;
pvm_pkfloat(&Terrain_colours[Message_counter].Blue,1,1) ;
}
pvm_pkdouble(&Fog_start,1,1) ;
pvm_pkdouble(&Fog_end,1,1) ;
/* tell the worker what values to use for the display */
pvm_pkdouble(&Ray_step,1,1) ;
pvm_pkdouble(&X_view_angle,1,1) ;
pvm_pkdouble(&Y_view_angle,1,1) ;
pvm_pkint(&Pixel_buffer_width,1,1) ;
pvm_pkint(&User_view.Y_size,1,1) ;
pvm_pkdouble(&X_ray_angle,1,1) ;
pvm_pkdouble(&Y_ray_angle,1,1) ;
/* send the message to all the workers */
pvm_mcast (Worker_tids,Number_of_workers,INFO) ;
/* set up light source */
normalize_3d(Light_source) ;
/* set the light source */
Light_source[0]=0.1 ;
Light_source[1]=0.4 ;
Light_source[2]=0.3 ;
/* tell the worker what values to use for the light source */
pvm_initsend(PvmDataDefault) ;
pvm_pkdouble(Light_source,3,1) ;
pvm_mcast (Worker_tids,Number_of_workers,NEW_LIGHT_SOURCE) ;
/* set up the users view point */
Height=1.0 ;
User.X=0 ;
User.Y=0 ;
User.Z=Height ;
User.X_angle=0.0 ;
User.Y_angle=0.0 ;
User.Z_angle=0.0 ;
/* set up window */
open_window() ;
print_keys() ;
/* */
/* set up the keyboard,Reshape and display routines */
/* */
auxKeyFunc(AUX_Q,kill_workers) ;
auxKeyFunc(AUX_q,kill_workers) ;
auxKeyFunc(AUX_ESCAPE,kill_workers) ;
auxKeyFunc(AUX_LEFT,left) ;
auxKeyFunc(AUX_RIGHT,right) ;
auxKeyFunc(AUX_UP,forwards) ;
auxKeyFunc(AUX_DOWN,backwards) ;
auxKeyFunc(AUX_a,up) ;
auxKeyFunc(AUX_A,up) ;
auxKeyFunc(AUX_Z,down) ;
auxKeyFunc(AUX_z,down) ;
auxKeyFunc(AUX_J,save_image) ;
auxKeyFunc(AUX_j,save_image) ;
auxMainLoop(display_loop) ;
}
