/****************************************************************************\
Option handler provided when calling ParseCmdLine member function of CGetOptions
\****************************************************************************/
bool ProcessOption(int ch, char *optarg, void* user_ctx)
{
bool bDone = false;
do {
struct USER_SETTINGS* pUsrSet = (struct USER_SETTINGS*)user_ctx;
if(pUsrSet == NULL) {
break;
}
#define ON(msg, fn) case msg: bDone = fn(ch, optarg, pUsrSet); break;
switch(ch) {
ON('h', OnUsage);
ON('c', OnBlockCount);
ON('s', OnBlockSize);
ON('r', OnRunTime);
default:
printf("Try '--help' for more information.\n");
bDone = true;
break;
}
#undef ON
} while(false);
return bDone;
}
void
makeTarget(
char *s,
BOOL firstTarg,
BUILDBLOCK **block
)
{
BUILDLIST *build;
MAKEOBJECT *object;
if (!*block)
*block = makeNewBuildBlock();
if (firstTarg) {
build = makeNewBldListElement();
build->buildBlock = *block;
} else
build = makeBuildList(*block);
if ((object = findTarget(s))) {
if (ON(object->flags2, F2_DOUBLECOLON) != ON(currentFlags, F2_DOUBLECOLON))
makeError(currentLine, MIXED_SEPARATORS);
appendItem((STRINGLIST**)&(object->buildList), (STRINGLIST*)build);
FREE(s);
} else {
build->next = NULL;
object = makeNewObject();
object->name = s;
object->buildList = build;
object->flags2 = currentFlags;
prependItem((STRINGLIST**)targetTable+hash(s, MAXTARGET, (BOOL)TRUE),
(STRINGLIST*)object);
}
}
//# MENU cpld
void cpld_flash() {
SETUPgout(EN_1V8);
ON(EN_1V8);
delay(1000000); /* wait until cpld boot */
cpu_clock_set(204);
lcdPrintln("Program CPLD");
bytes=0;
lcdPrint(IntToStr(bytes,5,F_LONG));
lcdPrint(" bytes...");
lcdNl();
#define WAIT_LOOP_DELAY (6000000)
#define ALL_LEDS (PIN_LED1|PIN_LED2|PIN_LED3)
int i;
int error;
refill_cpld_buffer_fs();
error = cpld_jtag_program(sizeof(cpld_xsvf_buffer),
cpld_xsvf_buffer,
refill_cpld_buffer_fs);
if(error) {
lcdPrintln("Programming failed!");
lcdPrintln(IntToStr(error,5,0));
lcdDisplay();
/* LED3 (Red) steady on error */
ON(LED4);
while (1);
};
lcdPrintln("Success.");
lcdDisplay();
OFF(EN_1V8);
};
static echs_event_t
__xmas(void *UNUSED(clo))
{
DEFSTATE(XMAS);
DEFSTATE(BOXD);
echs_event_t e;
switch (state) {
case BEFORE_XMAS:
e.when = (echs_instant_t){y, 12U, 25U};
e.what = ON(XMAS);
state = ON_XMAS;
break;
case ON_XMAS:
e.when = (echs_instant_t){y, 12U, 26U};
e.what = OFF(XMAS);
state = BEFORE_BOXD;
break;
case BEFORE_BOXD:
e.when = (echs_instant_t){y, 12U, 26U};
e.what = ON(BOXD);
state = ON_BOXD;
break;
case ON_BOXD:
e.when = (echs_instant_t){y, 12U, 27U};
e.what = OFF(BOXD);
state = BEFORE_XMAS;
y++;
break;
default:
abort();
}
return e;
}
//# MENU cpld
void cpld_menu(){
getInputWaitRelease();
SETUPgout(EN_1V8);
ON(EN_1V8);
delayNop(1000000); /* wait until cpld boot */
cpu_clock_set(204);
lcdClear();
lcdPrintln("CPLD");
lcdNl();
lcdNl();
bytes=0;
lcdPrint(IntToStr(bytes,5,F_LONG));
lcdPrint(" bytes...");
lcdNl();
#define WAIT_LOOP_DELAY (6000000)
#define ALL_LEDS (PIN_LED1|PIN_LED2|PIN_LED3)
int i;
int error;
FRESULT res;
res=f_open(&file, "cpld.xsv", FA_OPEN_EXISTING|FA_READ);
if(res!=FR_OK){
lcdPrintln("FOPEN ERROR");
lcdPrintln(f_get_rc_string(res));
lcdDisplay();
getInputWait();
return;
};
refill_cpld_buffer_fs();
error = cpld_jtag_program(sizeof(cpld_xsvf_buffer),
cpld_xsvf_buffer,
refill_cpld_buffer_fs);
if(error){
lcdPrintln("Programming failed!");
lcdPrintln(IntToStr(error,5,0));
lcdDisplay();
/* LED3 (Red) steady on error */
ON(LED3);
while (1);
};
lcdPrintln("Success.");
lcdDisplay();
for (res=0;res<10;res++){
/* blink LED1, LED2, and LED3 on success */
TOGGLE(LED1);
TOGGLE(LED2);
TOGGLE(LED3);
for (i = 0; i < WAIT_LOOP_DELAY; i++) /* Wait a bit. */
__asm__("nop");
};
/* XXX: Maybe power toggle needed to start CPLD? */
OFF(EN_1V8);
};
static int simple(void) {
ne_buffer *s = ne_buffer_create();
ON(s == NULL);
ne_buffer_zappend(s, "abcde");
ONCMP(s->data, "abcde");
ON(ne_buffer_size(s) != 5);
ne_buffer_destroy(s);
return OK;
}
void Buzzer::target_not_found()
{
ON();
wait(0.1);
OFF();
wait(0.1);
ON();
wait(0.2);
OFF();
}
static int buf_concat(void)
{
ne_buffer *s = ne_buffer_create();
ON(s == NULL);
ne_buffer_concat(s, "a", "b", "c", "d", "e", "f", "g", NULL);
ONCMP(s->data, "abcdefg");
ON(ne_buffer_size(s) != 7);
ne_buffer_destroy(s);
return OK;
}
//# MENU spectrum
void spectrum_menu()
{
lcdClear();
lcdDisplay();
getInputWaitRelease();
// RF initialization from ppack.c:
dac_init(false);
cpu_clock_set(204); // WARP SPEED! :-)
hackrf_clock_init();
rf_path_pin_setup();
/* Configure external clock in */
scu_pinmux(SCU_PINMUX_GP_CLKIN, SCU_CLK_IN | SCU_CONF_FUNCTION1);
sgpio_configure_pin_functions();
ON(EN_VDD);
ON(EN_1V8);
OFF(MIC_AMP_DIS);
delayms(500); // doesn't work without
cpu_clock_set(204); // WARP SPEED! :-)
si5351_init();
portapack_init();
while(1)
{
switch(getInput())
{
case BTN_UP:
displayMode=MODE_WATERFALL;
break;
case BTN_DOWN:
displayMode=MODE_SPECTRUM;
break;
case BTN_LEFT:
freq -= 2000000;
ssp1_set_mode_max2837();
set_freq(freq);
break;
case BTN_RIGHT:
freq += 2000000;
ssp1_set_mode_max2837();
set_freq(freq);
break;
case BTN_ENTER:
//FIXME: unset the callback, reset the clockspeed, tidy up
nvic_disable_irq(NVIC_DMA_IRQ);
OFF(EN_VDD);
OFF(EN_1V8);
ON(MIC_AMP_DIS);
systick_set_clocksource(0);
systick_set_reload(12e6/SYSTICKSPEED/1000);
return;
}
}
}
static int buf_concat3(void)
{
ne_buffer *s = ne_buffer_create();
ON(s == NULL);
ne_buffer_zappend(s, "foobar");
ne_buffer_concat(s, "norman", NULL);
ONCMP(s->data, "foobarnorman");
ON(ne_buffer_size(s) != 12);
ne_buffer_destroy(s);
return OK;
}
static int buf_concat2(void)
{
#define RES "alphabetagammadeltaepsilonetatheta"
ne_buffer *s = ne_buffer_create();
ON(s == NULL);
ne_buffer_concat(s, "alpha", "beta", "gamma", "delta", "epsilon",
"eta", "theta", NULL);
ONCMP(s->data, RES);
ON(ne_buffer_size(s) != strlen(RES));
ne_buffer_destroy(s);
return OK;
}
//# MENU Apack
void ppack_menu() {
lcdClear();
lcdPrintln("PPack port");
lcdPrintln("");
lcdPrintln("up=enable");
lcdDisplay();
dac_init(false);
cpu_clock_set(204); // WARP SPEED! :-)
hackrf_clock_init();
rf_path_pin_setup();
/* Configure external clock in */
scu_pinmux(SCU_PINMUX_GP_CLKIN, SCU_CLK_IN | SCU_CONF_FUNCTION1);
sgpio_configure_pin_functions();
ON(EN_VDD);
ON(EN_1V8);
OFF(MIC_AMP_DIS);
complex_s8_t * samples;
while(1){
switch(getInputRaw()){
case BTN_UP:
// ON(MIXER_EN); // hackrf does this
cpu_clock_set(204); // WARP SPEED! :-)
si5351_init();
portapack_init();
getInputWaitRelease();
break;
case BTN_DOWN:
lcdPrintln("file");
writeFile("samples.8", (char*)0x20000000,(uintptr_t)s8ram-0x20000000);
break;
case BTN_LEFT:
lcdPrintln("reset");
s8ram=(complex_s8_t*)0x20000000;
break;
case BTN_RIGHT:
break;
case BTN_ENTER:
return;
};
TOGGLE(LED2);
delayms(40);
lcdPrint(IntToStr((uintptr_t)s8ram,8,F_HEX));
lcdPrint(" ");
lcdPrintln(IntToStr(sctr,7,F_LONG));
lcdDisplay();
};
};
/* this makes sure that there aren't too many more normal servers to backup servers.
If there are, it promotes a random potential browser */
RTSMB_STATIC void rtsmb_srv_browse_ensure_backup_ratio (void)
{
int i, num_total = 0, num_backup = 0, num_potentials = 0, backup_server = -1;
for (i = 0; i < prtsmb_srv_ctx->server_table_size; i++)
{
if (prtsmb_srv_ctx->server_table[i].type)
{
num_total ++;
if (ON (prtsmb_srv_ctx->server_table[i].type, SV_TYPE_BACKUP_BROWSER))
{
num_backup ++;
}
else if (ON (prtsmb_srv_ctx->server_table[i].type, SV_TYPE_POTENTIAL_BROWSER))
{
num_potentials ++;
}
}
}
if (num_backup * RTSMB_SRV_BROWSE_NORMALS_TO_BACKUPS < num_total)
{
/* not enough backups, we need to promote someone */
int target = tc_rand () % num_potentials;
for (i = 0; i < prtsmb_srv_ctx->server_table_size; i++)
{
if (prtsmb_srv_ctx->server_table[i].type)
{
if (OFF (prtsmb_srv_ctx->server_table[i].type, SV_TYPE_BACKUP_BROWSER) &&
ON (prtsmb_srv_ctx->server_table[i].type, SV_TYPE_POTENTIAL_BROWSER))
{
if (target == 0)
{
backup_server = i;
break;
}
else
{
target --;
}
}
}
}
}
if (backup_server >= 0)
{
rtsmb_srv_browse_send_become_backup (prtsmb_srv_ctx->server_table[backup_server].name);
}
}
void Send_Byte(char byte){
// отправляем байт последовательно по битам , при этом кликая каждый бит и дергая защелку каждый байт
for (char i=0;i<8;i++){
if ((byte&0x80)==0x00) ON(SHIFT_data);
else OFF(SHIFT_data);
byte<<=1;
ON(SHIFT_clk);
OFF(SHIFT_clk);
}
OFF(SHIFT_latch);
ON(SHIFT_latch);
OFF(SHIFT_latch);
}
/**
* PWM timer commutation event interrupt handler
*/
void tim1_trg_com_irq_handler(void)
{
TIM_ClearITPendingBit(TIM1, TIM_IT_COM);
ON(LED_BLUE);
TIM_SetCompare1(TIM1, pwm_val);
TIM_SetCompare2(TIM1, pwm_val);
TIM_SetCompare3(TIM1, pwm_val);
TIM_SetCompare4(TIM1, pwm_offset);
PWM__SCHEME();
ON(LED_BLUE);
}
void Buzzer::boot()
{
ON();
wait(0.1);
OFF();
wait(0.1);
ON();
wait(0.1);
OFF();
wait(0.1);
ON();
wait(0.2);
OFF();
}
//# MENU led
void led_menu(){
getInputWaitRelease();
uint8_t leds=0;
uint8_t adc=0;
while(1){
lcdClear();
lcdPrintln("LED:");
lcdPrintln("");
lcdPrintln("U Toggle LEDs");
lcdPrintln("D Toggle ADC");
lcdPrintln("");
lcdDisplay();
switch(getInput()){
case BTN_UP:
adc=0;
leds=1-leds;
SETUPgout(LED4);
if(leds){
ON(LED1);
ON(LED2);
ON(LED3);
ON(LED4);
}else{
OFF(LED1);
OFF(LED2);
OFF(LED3);
OFF(LED4);
};
break;
case BTN_DOWN:
adc=1;
SETUPadc(LED4);
break;
case BTN_ENTER:
SETUPgout(LED1);
SETUPgout(LED2);
SETUPgout(LED3);
SETUPgout(LED4);
return;
};
if(adc){
lcdPrint("LED4: ");
lcdPrint(IntToStr(adc_get_single(ADC0,ADC_CR_CH6)*2*330/1023,4,F_LONG));
lcdNl();
lcdDisplay();
};
getInputWaitRelease();
};
};
void __cdecl
makeMessage(
unsigned msg,
...)
{
va_list args;
FILE *stream = stdout;
va_start(args, msg);
if (msg != USER_MESSAGE && ON(gFlags, F1_CRYPTIC_OUTPUT)) {
return;
}
displayBanner();
if (msg >= FATAL_ERROR_MESSAGE && msg <= COPYRIGHT_MESSAGE_2) {
stream = stderr;
}
if (msg == COPYRIGHT_MESSAGE_1) {
putc('\n', stream);
}
vfprintf(stream, get_err(msg), args);
if ((msg < COMMANDS_MESSAGE || msg > STOP_MESSAGE) && msg != MESG_LAST) {
putc('\n', stream);
}
fflush(stream);
}
static int alter(void) {
ne_buffer *s = ne_buffer_create();
char *d;
ON(s == NULL);
ne_buffer_zappend(s, "abcdefg");
d = s->data;
ON(d == NULL);
d[2] = '\0';
ne_buffer_altered(s);
ONCMP(s->data, "ab");
ON(ne_buffer_size(s) != 2);
ne_buffer_zappend(s, "hijkl");
ONCMP(s->data, "abhijkl");
ne_buffer_destroy(s);
return OK;
}
int main(void) {
cpuClockInit(); /* CPU Clock is now 104 MHz */
ssp_clock_init();
systickInit();
SETUPgout(EN_VDD);
SETUPgout(MIXER_EN);
SETUPgout(MIC_AMP_DIS);
SETUPgout(LED1);
SETUPgout(LED2);
SETUPgout(LED3);
SETUPgout(LED4);
inputInit();
lcdInit();
lcdFill(0xff);
lcdPrintln("Flash-App");
lcdNl();
lcdDisplay();
cpld_flash();
cpu_clock_set(50);
full_msc();
while(1) {
delayNop(2000000);
ON(LED4);
delayNop(2000000);
OFF(LED4);
}
return 0;
}
void ChamberLED::setState(bool state){
if(state){
ON();
}else{
OFF();
}
}
//
// Activation for automatic management of led (flashing or instance)
//
void led::activateLED()
{
Active = 1;
ON();
if(Type == Instance)
NextEventTime = s.Timer1.time_ms + (INSTANCEDELAY);
}
void
assignBuildCommands()
{
BOOL okToFreeList = TRUE;
BOOL fFirstTarg = (BOOL)TRUE;
STRINGLIST *p;
const char *which = NULL;
if (ON(actionFlags, A_RULE)) // no macros found yet for inference rules
rules->buildCommands = list;
else if (ON(actionFlags, A_SILENT) ||
ON(actionFlags, A_IGNORE) ||
ON(actionFlags, A_PRECIOUS) ||
ON(actionFlags, A_SUFFIX)
) {
if (list) {
if (ON(actionFlags, A_SILENT))
which = silent;
else if (ON(actionFlags, A_IGNORE))
which = ignore;
else if (ON(actionFlags, A_PRECIOUS))
which = precious;
else if (ON(actionFlags, A_SUFFIX))
which = suffixes;
makeError(currentLine, CMDS_ON_PSEUDO, which);
}
} else {
block->buildCommands = list;
block->buildMacros = macros;
block->flags = currentFlags;
while ((p = targetList)) { // make a struct for each targ
if (doSpecial(p->text)) // in list, freeing list when
makeError(currentLine, MIXED_TARGETS);
makeTarget(p->text, fFirstTarg, &block); // done, don't free name
if (!makeTargets) { // field -- it's still in use
makeTargets = p; // if no targs given on cmdlin
okToFreeList = FALSE; // put first target(s) from
} // mkfile in makeTargets list
targetList = p->next; // (makeTargets defined in
if (okToFreeList) // nmake.c)
FREE_STRINGLIST(p);
if (fFirstTarg)
fFirstTarg = (BOOL)FALSE;
}
}
targetList = NULL;
list = NULL;
macros = NULL;
block = NULL;
actionFlags = 0;
}
static int append(void)
{
ne_buffer *s = ne_buffer_create();
ON(s == NULL);
ne_buffer_append(s, "a", 1);
ne_buffer_append(s, "b", 1);
ne_buffer_append(s, "c", 1);
ONCMP(s->data, "abc");
ON(ne_buffer_size(s) != 3);
ne_buffer_zappend(s, "hello");
ONCMP(s->data, "abchello");
ne_buffer_czappend(s, "world");
ONCMP(s->data, "abchelloworld");
ON(ne_buffer_size(s) != 13);
ne_buffer_destroy(s);
return OK;
}
void applyConfig(){
if(GLOBAL(lcdcontrast)>0)
lcdSetContrast(GLOBAL(lcdcontrast));
if(GLOBAL(develmode))
enableConfig(CFG_TYPE_DEVEL,1);
if(isNight())
ON(LCD_BL_EN);
else
OFF(LCD_BL_EN);
if(GLOBAL(vdd_fix))
ON(EN_VDD);
else
OFF(EN_VDD);
lcdSetRotation(GLOBAL(lcdmirror));
keySetRotation(GLOBAL(lcdmirror));
}
void drift_ship(void) {
uint8_t d_x = 1;
uint8_t d_y = 1;
for (uint8_t i = 0; i < NUM_STARS; i++) {
stars[i].x += d_x;
stars[i].y += d_y;
}
ON(LED4);
}
hw2stack& hw2stack::doOperator(std::string operation) {
unsigned int i;
std::string temp1;
std::string temp2;
std::string temp3;
std::string output;
std::stack<std::string> tempstack;
std::stack<std::string> tempstack2;
i=0;
while (i<=operation.length()) {
if (i==operation.length())
break;
if (i==operation.length()-1){
temp1=operation[i];
if (this->getBlock(temp1).isontable() || this->getBlock(temp1).getoriginalindex()!=this->getBlock(temp1).isonindex()) {
i++;
continue;
}
output=getBlock(temp1).getName();
operators.push(output);
i++;
}
else {
temp1=operation[i];
temp2=operation[i+1];
output=getBlock(temp1).getName()+getBlock(temp2).getName();
operators.push(output);
i++;
}
}
i=operation.length()-1;
while (i>=0) {
if (i==-1)
break;
if (i==operation.length()-1){
temp1=operation[i];
if (this->getBlock(temp1).isontable() || this->getBlock(temp1).getoriginalindex()!=this->getBlock(temp1).isonindex()) {
i--;
continue;
}
ONTABLE(getBlock(temp1));
i--;
}
else {
temp1=operation[i];
temp2=operation[i+1];
ON(getBlock(temp1),getBlock(temp2));
i--;
}
}
return *this;
}
static void Get_bool_resource(XrmDatabase db, char *myName, char *myClass,
char *resource, char *fallback, int *result)
{
char resValue[MAX_CHARS];
Get_resource(db, myName, myClass, resource, fallback, resValue,
sizeof resValue);
*result = (ON(resValue) != 0);
}
long int
ar_scan (const char *archive, ar_member_func_t function, const void *varg)
{
char *p;
const char *arg = varg;
static struct dsc$descriptor_s libdesc =
{ 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
unsigned long func = LBR$C_READ;
unsigned long type = LBR$C_TYP_UNK;
unsigned long index = 1;
int status;
status = lbr$ini_control (&VMS_lib_idx, &func, &type, 0);
if (! (status & 1))
{
ON (error, NILF, _("lbr$ini_control() failed with status = %d"), status);
return -2;
}
/* there is no such descriptor with "const char *dsc$a_pointer" */
libdesc.dsc$a_pointer = (char *)archive;
libdesc.dsc$w_length = strlen (archive);
status = lbr$open (&VMS_lib_idx, &libdesc, 0, 0, 0, 0, 0);
if (! (status & 1))
{
OSS (error, NILF, _("unable to open library '%s' to lookup member '%s'"),
archive, arg);
return -1;
}
VMS_saved_memname = arg;
/* For comparison, delete .obj from arg name. */
p = strrchr (VMS_saved_memname, '.');
if (p)
*p = '\0';
VMS_function = function;
VMS_member_date = (time_t) -1;
lbr$get_index (&VMS_lib_idx, &index, VMS_get_member_info, 0);
/* Undo the damage. */
if (p)
*p = '.';
lbr$close (&VMS_lib_idx);
return VMS_member_date > 0 ? VMS_member_date : 0;
}
void
addItemToList()
{
STRINGLIST *p; // from lexer
STRINGLIST *NewList;
if (name) {
SET(actionFlags, A_TARGET);
startNameList();
name = NULL;
}
if (ON(actionFlags, A_TARGET)) {
if (isRule(buf)) {
if (ON(actionFlags, A_RULE))
makeError(currentLine, TOO_MANY_RULE_NAMES);
makeError(currentLine, MIXED_RULES);
}
}
p = makeNewStrListElement();
if (ON(actionFlags, A_STRING)) { // we collect macros
p->text = string; // for dependents &
string = NULL; // build lines for
} else // non-implicit rules
p->text = makeString(buf);
NewList = p; // build lines for
if (OFF(actionFlags, A_RULE) // rules get expanded
|| ON(actionFlags, A_TARGET)) // after entire make-
{
findMacroValues(p->text, ¯os, NULL, NULL, 0, 0, 0); // file parsed
}
if (ON(actionFlags, A_TARGET)) {
p = macros;
expandFileNames("$", &NewList, ¯os);
expandFileNames("*?", &NewList, NULL);
while ((macros = p)) {
p = p->next;
FREE_STRINGLIST(macros);
}
}
appendItem(&list, NewList);
}
