Пример #1
0
int kickoff() {
	initVideo();	
	putStr("Hello World! - Team Virtua!!!\n");
	
 	installDescriptorTables();
	installTimer();
	installKeyboard();	
    initializePaging();    
	putStr("Hello, paging world! - Team Virtua !!!\n");	

	enableInterrupts();	

	
	// u32 end_addr = (u32)&end;
	// u32 *ptr = (u32 *)end_addr;		
	
	// while(1) {
		// putStr("End Address : ");
		// putHex(end_addr);
		// putStr(" ");
		// putHex((u32)ptr);
		// putStr(" : ");
		// putNum(*ptr);
		// putStr("\n");
		// ptr++;	
	// }
			
    putStr("Gotcha!!!\n");

    for (;;);
	return 0;	
}
void da_setupScale()
{
  high(pinCh0);
  high(pinCh1);

  pause(5);

  float vA = ad_volts(0);
  float vB = ad_volts(1);

  //print("%f %f\n", vA, vB);

  if( (vA > 3.1 && vA < 3.5 && vB > 3.1 && vB < 3.5))
  {
    for(int i = 0; i < 39; i++)
    {
      vA += ad_volts(0);
      vB += ad_volts(1);
    }
    vA /= 40;
    vB /= 40;

    vA = 3.3 / vA;
    vB = 3.3 / vB;

    int addr = _abvolts_EE_start_;

    ee_putStr("abvolts", 8, addr);
    addr += 8;

    ee_putFloat32(vA, addr);
    addr += 4;

    ee_putFloat32(vB, addr);
    addr += 4;

    low(pinCh0);
    low(pinCh1);

    input(pinCh0);
    input(pinCh1);

    putStr("Ch0 scalar = ");
    putFloat(vA);
    putStr("\nCh1 scalar = ");
    putFloat(vB);
    putChar('\n');
    putChar('\n');

    abvolts_scale[0] = vA;
    abvolts_scale[1] = vB;
  }
  else
  {
    putStr("Error! Something went wrong. Check your circuit and power source.");
  }
}
Пример #3
0
//
// Print the help menu
//
static void helpFn(uint8_t argc, char *argv[]) {
	const command_t *command = commands;

	while(command->commandStr != NULL) {
		putStr(command->commandStr);
		putStr(" - ");
		putStr(command->helpStr);
		putStr("\n");
		command++;
	}
	
}
Пример #4
0
int attr2str(spConfigAttribute *attr,str *string)
{
	int i;
	char buffer[32];
	ENTRY;
	//write name
	for(i=0;i<(int)strlen(attr->name);++i)
	{
		switch(attr->name[i])
		{
			case '"':case '#': case ']':
			case '/':case '<': case '\\':
				putStr(string,'\\');
			default:
				putStr(string,attr->name[i]);
		}
	}
	//write = and value
	if(attr->type&0xf)	//an actual attr, not a child/created attr
	{
		putStr(string,'=');
		
		switch(attr->type&0xf)
		{
			case SP_CONFIG_VALUE_INT:
				snprintf(buffer,32,"%i",attr->value.i);
				for(i=0;i<(int)strlen(buffer);++i)
					putStr(string,buffer[i]);
				break;
			case SP_CONFIG_VALUE_FLOAT:
				snprintf(buffer,32,"%f",attr->value.d);
				for(i=0;i<(int)strlen(buffer);++i)
					putStr(string,buffer[i]);
				break;
			case SP_CONFIG_VALUE_STRING:
				putStr(string,'"');
				for(i=0;i<(int)strlen(attr->value.string);++i)
				{
					switch(attr->value.string[i])
					{
						case '"':case '[': case '\\':
						case '#':case '/': case '>':
							putStr(string,'\\');
						default:
							putStr(string,buffer[i]);				
					}
				}
				putStr(string,'"');
				break;
		}
	}
	
	return(0);
}
Пример #5
0
void printTempWithCh(uint8_t ch) {
	uint32_t adcVal = 0;

	enableADCWithCh(ch);

	for(uint16_t count = 0; count < ADC_COUNT; count++){
		adcVal += readADC();
	}

	adcVal /= ADC_COUNT;

	putStr("T = ");
	printTemp(adcVal);
	putStr(" C\n");
}
Пример #6
0
void
INFwfile::putComment(char *str)
{
	putEnd();
	putChar(';');
  putStr(str);
}
Пример #7
0
int getNChars_4lua(lua_State *L)
{
	int n = getNumber(L);
	putStr(L, getNChars(n));
	
	return 1;
}
Пример #8
0
void
INFwfile::putKey(char *str)
{
	putEnd();
	putStr(str);
	putChar('=');
}
Пример #9
0
int text2str(char*text,str*string)
{
	int i;
	ENTRY;
	for(i=0;i<(int)strlen(text);++i)
	{
		switch(text[i])
		{
			case '<':case '[': case '#':
			case '/':case '\\':
				putStr(string,'\\');
			default:
				putStr(string,text[i]);
		}
	}
	return(0);
}
Пример #10
0
void
INFwfile::putSection(char *str)
{
	putEnd();
	putChar('[');
  putStr(str);
	putChar(']');
}
int main(void)
{
    unsigned long tmr1;
    int retVal;

    hardwareInit();
    systemInit();
    pnetNodeNumber = readNodeSw();
    if (pnetNodeNumber == 0x0F)
    {
        sysStat |= ST_DEBUG_MODE;
        rs485TransmitEna();
        putStr("\n\r DB CCS Child\r\n Ver ");   // DEB, not for PROD
        putStr(verStr);
        putStr(", MLA\n\r");
        menuDisplay();
        putPrompt();      
    }
    rs485TransmitDisa();

    while (1)
    {
        pnetNodeNumber = readNodeSw();
        if (pnetNodeNumber == 0xF) sysStat |= ST_DEBUG_MODE;
        else sysStat &= ~ST_DEBUG_MODE;
        serialParse();
        adcRHumid(ADC_SILENT);
        serialParse();
        adcTemper(ADC_SILENT);
        adcTemperSecondary(ADC_SILENT);

        retVal = adcFloodSensor(ADC_SILENT);
        if (retVal == 1) sysStat |= ST_LIQUID_DETECTED;
        else if (retVal == 0) sysStat &= ~ST_LIQUID_DETECTED;

        if (sysStat & ST_DEBUG_MODE) LED_GREEN = 1;

        if (tmr1++ > 5000)
        {
            tmr1 = 0;
            childStateMach(CANCEL);     // This is a crude timeout.  Not sure how to improve it.  We will
            rs485TransmitDisa();        // occasionally lose valid messages.  But we need to break out of junky ones.
        }
    }      // EO while (1)
}
Пример #12
0
int getNCharsPrompt_4lua(lua_State *L)
{
	char *str = (char *)getStr(L);
	int n = getNumber(L);

	putStr(L, getNCharsPrompt(n, str));
	
	return 1;
}
Пример #13
0
/*---------------------------------------------------------------------------
  This function reads the entire file pointed to by handle into buffer.
   int fatRead(FileHandle *handle, uint8_t *buffer, uint32_t bufferSize)
  Where:
   FileHandle *handle  - Pointer to an open file handle
   uint8_t *buffer     - Pointer to a buffer to store the file
   uint32_t bufferSize - The size of the buffer
  Returns: -1 for error or the file size for success
---------------------------------------------------------------------------*/
int fatRead(FileHandle *handle, uint8_t *buffer, uint32_t bufferSize)
{
    if(bufferSize >= handle->FileSize){
        uint32_t clusterId = handle->startingCluster;
        uint32_t read = 0;
        uint32_t i;
        while(clusterId < FAT32_LAST_CLUSTER){
            putStr("file name = ");
            for(i =0; i < 11; i++){
              uart_putc(handle->fileName[i]);
            }
            putStr(", cluster = ");
            hexstring(clusterId);
            uart_putc('\n');
            read += readCluster(clusterId, buffer+read);
            clusterId = nextFatEntry(clusterId);
        }
        return handle->FileSize;
    }
    return -1;
} // End fatRead()
Пример #14
0
static Int putStrEsc ( Int n, Int n_buf, Int count, Char* buf, Char* str ) 
{
   Char alt[2];
   vg_assert(n_buf > 0);
   vg_assert(count >= 0 && count < n_buf);
   vg_assert(n >= 0 && n < n_buf);
   for (; *str != 0; str++) {
      vg_assert(count >= 0);
      if (count <= 0)
         goto done;
      switch (*str) {
         case '&': 
            if (count < 5) goto done;
            n = putStr( n, n_buf, buf, "&amp;"); 
            count -= 5;
            break;
         case '<': 
            if (count < 4) goto done;
            n = putStr( n, n_buf, buf, "&lt;"); 
            count -= 4;
            break;
         case '>': 
            if (count < 4) goto done;
            n = putStr( n, n_buf, buf, "&gt;"); 
            count -= 4;
            break;
         default:
            if (count < 1) goto done;
            alt[0] = *str;
            alt[1] = 0;
            n = putStr( n, n_buf, buf, alt );
            count -= 1;
            break;
      }
   }
  done:
   vg_assert(count >= 0); /* should not go -ve in loop */
   vg_assert(n >= 0 && n < n_buf);
   return n;
}
Пример #15
0
int main(int argc, char* argv[]) {
  SDL_Event e; // Un eveniment care s-a intamplat. Folosit pentru a detecta inchiderea programului
  char quit;
  Mix_Music *backgroundMusic;
  int option;

  if(!init()) { // Daca nu s-a petrecut nici o eroare la initializare
    quit = 0;
    hideCursor(); // Cursorul dispare
    //system("color 37"); // Seteaza culoarea de fundal
    fillBackgroundCollor(BG_CYAN + WHITE);
    if(!DEBUG) {
      putStr((getConsoleWidth() - 13) / 2, getConsoleHeight() / 2, "Se incarca...");
      Sleep(2500);
      putStr((getConsoleWidth() - 10) / 2, getConsoleHeight() / 2 + 1, "Degeaba...");
      Sleep(500);
    }
    clearScreen();
    backgroundMusic = Mix_LoadMUS(BACKGROUND_MUSIC_PATH);
    if(backgroundMusic == NULL)
      error("Nu s-a putut accesa fisierul cu melodia de fundal.");
    else
      Mix_PlayMusic(backgroundMusic, -1);
    option = buildMenu();
    if(option == 2)
      quit = 1;
    while(!quit) {
      while(SDL_PollEvent(&e) != 0) {
        if(e.type == SDL_QUIT)
          quit = 1;
      }
      if(getKey(VK_ESCAPE))
        quit = 1;
      Sleep(SLEEPCONST);
    }
    freeData();
  }
  return 0;
}
/**
 * @example     Hybrid_Demo.cpp
 *
 * Use PropWare's PropWare::Printer interface for easy formatting of text, but use Simple's serial driver. This
 * combination allows for easy object-oriented programming while still using the Parallax-authored serial driver.
 *
 * @include PropWare_Simple_Hybrid/CMakeLists.txt
 */
int main () {
    SimplePrinter           mySimpleCompatiblePrinter;
    const PropWare::Printer myPrinter(&mySimpleCompatiblePrinter);

    putStr("Hello from the Simple function!\n");
    myPrinter.puts("Hello from PropWare's Printer!\n");
    myPrinter.print("Hello from yet another Printer function!\n");
    myPrinter.printf("All methods have their own merits. Choose one that works well for you.\n");
    myPrinter.println("Printer::println() can be handy if you just want to print a single string");
    myPrinter << "For lovers of C++ streams, you can even use the << operator!\n";

    return 0;
}
Пример #17
0
void putHex(u32 hex) {
	u8 num[8];
	int i = 0;
	putStr("0x");
	if(hex == 0) putChar('0');
	while(hex > 0) {
		u32 rem = hex % 16;
		if(rem < 10) num[i++] = '0' + rem;
		else num[i++] = 'A' + rem - 10;
		hex /= 16;
	}
	while(--i >= 0) {
		putChar(num[i]);
	}
}
Пример #18
0
int main(void)
{
    char test[16] = "Hello WorldC";
    char pstr[100];
    char ip[10] = "127.0.0.1";
    char port[6] = "12345";
    int command;
    initCon(ip,port);
    command = getSerAc();
    printf("%d\n",command);
    getStr(pstr,100);
    printf("%s\n",pstr);
    command = getSerAc();
    printf("%d\n",command);
    putStr(test);
    return 0;
}
Пример #19
0
RTFwfile::RTFwfile(const char *fname) : DCwfile(fname, ftxt)
{
  if (Ferr
   || (fname == NULL))
    return;


  LinePos = 0;
	AutoCR = true;

	Meta = 'I';  // Internal is default
	metanamewid = 5;
	metanumwid = 3;
	metanum = 0;
	*metaname = '\0';

  putStr("{\\rtf1 ");
}
Пример #20
0
void consoleProcess() {
	uint32_t inBytes = fifoSize(&rxFifo);
	if(inBytes > 0) {
		uint32_t newLine = 0;
		for(int32_t index = 0; index < inBytes; index++){
			if(fifoPeek(&rxFifo, index) == '\n') {
				newLine = index + 1;
				break;
			}
		}

		if(newLine > sizeof(cmdBuff)) {
			newLine = sizeof(cmdBuff) - 1;
		}

		if(newLine) {
			uint8_t *pBuf = (uint8_t *)cmdBuff;
			while(newLine--){
				*pBuf++ = fifoPop(&rxFifo);
			}

			*(pBuf - 1) = 0; // String terminator

			const command_t *command = commands;
			while(command->commandStr != NULL) {
				if(strcmp(command->commandStr, cmdBuff) == 0) {
					command->fn(0, NULL);
					break;
				}
				command++;
			}

			if(command->commandStr == NULL) {
				putStr("Unknown command\n");
				helpFn(1, NULL);
			}
			
		}
	}
}
Пример #21
0
status_t BnNativeService::onTransact(uint32_t code,const Parcel & data,Parcel *reply,uint32_t flags)
{
	switch(code)
	{
	case PUT:
	{
		CHECK_INTERFACE(INativeSerice,data,reply);
		
		const char *name=data.readCString();
		
		putStr(name);
		
	    return NO_ERROR;

	}
	case PUT_STR:
	{
	    return NO_ERROR;
	}
	default:
		return BBinder::onTransact(code,data,reply,flags);
	}
}
int main() 
{
    int rc;
    int firstx ;
    int firsty ;
    int x ;
    int y ;
    int state ;
    
    TimeLimit4D = 2000;
    Callback4D = errCallback;
    // abort on detected 4D Serial error
    Error_Abort4D = 1 ;
    comspeed = 9600;
    //WORD *x = 0x001A;
    //char *s = sys_GetModel(&x);
    //x  = &0x001A;
    rc = OpenComm(SERIALPORT, comspeed);
    if (rc != 0)
    {
        printf("Error %d Opening: %s - %s\n", errno, SERIALPORT, strerror(errno));
        exit(EXIT_FAILURE);
    }

	gfx_Cls() ;
	putStr("Touch Tests\n") ;
	printf("Touch Tests.\n") ;
	putStr("Please ensure Touch is only\ndetected in the Blue area") ;
	printf("Detecting touch in Region\n") ;
	touch_Set(TOUCH_ENABLE) ;
	touch_DetectRegion(100,100, 200, 200) ;
	gfx_RectangleFilled(100,100, 200, 200, BLUE) ;
	do {} while (touch_Get(TOUCH_STATUS) != TOUCH_PRESSED);
	touch_Set(TOUCH_REGIONDEFAULT) ;
	gfx_Cls() ;
	putStr("Draw.. Drawing stops\nwhen touch released\n") ;
	printf("Drawing\n") ;

	while(touch_Get(TOUCH_STATUS) != TOUCH_PRESSED)
	{      // we"ll wait for a touch
	}
	firstx = touch_Get(TOUCH_GETX);                          // so we can get the first point
	firsty = touch_Get(TOUCH_GETY);
	while(state != TOUCH_RELEASED)
	{
		state = touch_Get(TOUCH_STATUS);                       // look for any touch activity
		x = touch_Get(TOUCH_GETX);                             // grab the x
		y = touch_Get(TOUCH_GETY);                             // and the y coordinates of the touch
		if (state == TOUCH_PRESSED)                               // if there"s a press
		{
			firstx = x;
			firsty = y;
		}
		if (state == TOUCH_MOVING)                                // if there"s movement
		{
			gfx_Line(firstx, firsty, x, y, BLUE);                 // but lines are much better
			firstx = x;
			firsty = y;
		}
	}
	putStr("Done!\n") ;
	touch_Set(TOUCH_DISABLE);
    	
    return (EXIT_SUCCESS);
}
void kernelMain(void) {
    putStr("\nstarting kernel\n");

    initGdt();
    initTss();
    initIdt();

    putStr("mapping the first 2M with va = pa\n");

    for (uint32_t p = 0; p < 0x200000; p += 4096) {
        vmm_map(p,p);
    }

    CHECK((getcr0() & 0x80000000) == 0);

    putStr("about to enable paging\n");
    vmm_on();

    CHECK((getcr0() & 0x80000000) != 0);

    CHECK (vmm_pa(0xf0000000) == 0xffffffff);

    uint32_t pa = vmm_frame();
    vmm_map(0xf0000000, pa);

    CHECK (vmm_pa(0xf0000000) != 0xffffffff);
    CHECK ((vmm_pa(0xf0000123) & 0xfff) == 0x123);

    CHECK(vmm_dirty(0xf0000000) == 0); 
    CHECK(vmm_accessed(0xf0000000) == 0); 

    CHECK(peek(0xf0000000) == 0);
    CHECK(vmm_dirty(0xf0000000) == 0); 
    CHECK(vmm_accessed(0xf0000000) == 1); 

    poke(0xf0000000, 0x12345678);
    CHECK(peek(0xf0000000) == 0x12345678);
    CHECK(vmm_dirty(0xf0000000) == 1); 
    CHECK(vmm_accessed(0xf0000000) == 1); 

    CHECK(vmm_dirty(0xe0000000) == 0); 
    CHECK(vmm_accessed(0xe0000000) == 0); 

    CHECK(vmm_pa(0x40000000) == 0xffffffff);

    vmm_map(0xe0000000, pa);
    CHECK(peek(0xe0000000) == 0x12345678);

    CHECK(vmm_dirty(0xe0000000) == 0); 
    CHECK(vmm_accessed(0xe0000000) == 1); 

    CHECK(peek(0x44444444) == 0);
    CHECK(vmm_dirty(0x44444000) == 0); 
    CHECK(vmm_accessed(0x44443000) == 0); 
    CHECK(vmm_accessed(0x44444000) == 1); 
    CHECK(vmm_accessed(0x44445000) == 0); 

    poke(0x88888888,0x88888888);
    CHECK(peek(0x88888888) == 0x88888888);

    vmm_map(0xccccc000, vmm_pa(0x88888000));
    CHECK(peek(0xccccc888) == 0x88888888);

    CHECK (vmm_pa(0xccccc666) == vmm_pa(0x88888666));

    vmm_unmap(0xccccc000);
    CHECK(peek(0xccccc888) == 0);
    CHECK(peek(0x88888888) == 0x88888888);

    shutdown();
}
Пример #24
0
namespace
{

std::string upcase(std::string s)
{
    std::transform(begin(s), end(s), begin(s), [](char c) { return static_cast<char>(std::toupper(c)); });
    return s;
}
}

TEST_CASE("io_monad", "")
{
    SECTION("bind")
    {
        IO<U> io = putStr("Tell me your name!\n")
                       .bind(getLine)
                       .bind([](std::string str) { return putStr("Hi " + str + "\n"); });
        io.run();
    }

    SECTION("fmap")
    {
        IO<U> io = putStr("Tell me your name!\n")
                       .bind(getLine)
                       .fmap(upcase)
                       .bind([](std::string str) { return putStr("Hi " + str + "\n"); });
        io.run();
    }
}
Пример #25
0
/*---------------------------------------------------------------------------
  This only reads from the primary boot record, it assumes it has been
  loaded by boot.s
   uint32_t initHDD(void)
  Where:

  Returns: 0 for success, non-zero for failure
---------------------------------------------------------------------------*/
uint32_t initHDD(void)
{
    // Get bootRecord and volume id and filled IO_INIT
    bootRecord* b = (bootRecord*)readLBA(0);
    FAT_VolID* v = (FAT_VolID*)readLBA(b->par[0].LBA_Begin);
    MediaDescriptorGlobal.fatBeginLBA = b->par[0].LBA_Begin + v->reservedSectors;
    MediaDescriptorGlobal.dirBeginLBA = MediaDescriptorGlobal.fatBeginLBA + (v->numFats*v->sectorsPerFat);
    MediaDescriptorGlobal.sectorsPerCluster = v->sectorsPerCluster;
    MediaDescriptorGlobal.bytesPerSector = v->bytesPerSector;

    //Print all the information

    putStr("Boot record size=");
    hexstring(sizeof(bootRecord));
    putStr(", Partition description size ");
    hexstring(sizeof(partitionDescription));
    putStr("\nFAT VOL ID size=");
    hexstring(sizeof(FAT_VolID));
    putStr(", ROOT DIR size = ");
    hexstring(sizeof(FAT_DirSector));
    putStr("\nnum Sectors = ");
    hexstring(b->par[0].numSectors);
    putStr(", size = ");
    hexstring(b->par[0].numSectors*v->bytesPerSector/1048576);
    putStr(" (MB)\nLBA starts at ");
    hexstring(b->par[0].LBA_Begin);
    putStr("\nbytes per sector=");
    hexstring(v->bytesPerSector);
    putStr(", sectors per cluster=");
    hexstring(v->sectorsPerCluster);
    putStr(", reserved sectors ");
    hexstring(v->reservedSectors);
    putStr("\nnumber of FATS ");
    hexstring(v->numFats);
    putStr(", sectors per fat ");
    hexstring(v->sectorsPerFat);
    putStr(", root cluster ");
    hexstring(v->rootCluster);
    putStr(", signature ");
    hexstring(v->signature);
    putStr("\nFAT Begin LBA = ");
    hexstring(MediaDescriptorGlobal.fatBeginLBA);
    putStr(", Cluster begin LBA = ");
    hexstring(MediaDescriptorGlobal.dirBeginLBA);
    uart_putc((uint32_t)'\n');
  return(0);
} // End initHDD
Пример #26
0
void
RTFwfile::CloseFile()
{
  putStr("\n}\n");
  DCwfile::CloseFile();
}
    // ---------------------
void serialParse(void)
{
    char charCh;
    byte hexRead, oldHexRead;
  
    charCh = getChar();
    if (!charCh) return;

    if (sysStat & ST_DEBUG_MODE)        // Super commands for Monitor
    {
        rs485TransmitEna();
        putChar(charCh);

        switch(charCh)
        {
            case 'd':
                putStr("\tNode ID switch test.\n\r");
                putStr("\tHit any key to quit.\n\r");
                rs485TransmitDisa();
                while(1)
                {                  
                    charCh = getChar();
                    if (charCh) break;
                    hexRead = readNodeSw();
                    if (hexRead != oldHexRead)
                    {
                        rs485TransmitEna();
                        sprintf(ioBfr, "\n\r Node ID: %02Xh", hexRead);
                        putStr(ioBfr);
                        oldHexRead = hexRead;
                        rs485TransmitDisa();
                    }
                }
                break;

            case 'f':
                putStr("\tFlood sensor test: ");
                adcFloodSensor(ADC_LOQUACIOUS);
                break;

            case 'h':
                adcRHumid(ADC_LOQUACIOUS);
                break;

            case 'r':
                reportInfo();             
                break;

            case 't':
                adcTemper(ADC_LOQUACIOUS);
                break;

            case 'T':
                adcTemperSecondary(ADC_LOQUACIOUS);
                break;


            case '1':
                RELAY1 ^= 1;
                if (RELAY1) putStr("\tRelay 1 on");
                else putStr("\tRelay 1 off");
                break;

            case '2':
                RELAY2 ^= 1;
                if (RELAY2) putStr("\tRelay 2 on");
                else putStr("\tRelay 2 off");
                break;

            case '3':
                SwiPwr1 ^= 1;
                if (SwiPwr1) putStr("\tSwi Pwr1 on");
                else putStr("\tSwi Pwr1 off");
                break;

            case '4':
                SwiPwr2 ^= 1;
                if (SwiPwr2) putStr("\tSwi Pwr2 on");
                else putStr("\tSwi Pwr2 off");
                break;

            case '?':
                menuDisplay();                
                break;
        }                       // EO switch
        putPrompt();
        rs485TransmitDisa();
    }       // EO if debug
    else
    {
        childStateMach(charCh);
    }
}
void menuDisplay(void)
{
    putStr("\n\r * Child / commands *\n\r");
    putStr(" d - rd DIPSWs\n\r");
    putStr(" f - flood sensor\n\r");
    putStr(" h - rd rhumid sen\n\r");
    putStr(" r - report info\n\r");
    putStr(" R - smem Read test\n\r");
    putStr(" t - rd T sen\n\r");
    putStr(" T - rd secondary T sen\n\r");
   //putStr(" W - smem destr. Wr test *\n\r");
    putStr(" 1 - toggle rly 1\n\r");
    putStr(" 2 - toggle rly 2\n\r");
    putStr(" 3 - toggle swi pwr1\n\r");
    putStr(" 4 - toggle swi pwr2\n\r");
    putStr(" ? - this menu\n\r");
    putStr("\n\r");
}
    // --------------------------------
void reportInfo(void)
{
    putPrompt();
    putStr("\n\r CCS Child Monitor, MLA");
    putStr("\n\r Ver: ");
    putStr(verStr);
    putStr("\n\r PNet ver: ");
    putChar(pnetVer);
    putStr("\n\r UID: ");
    putStr(uniqueID);
    sprintf(ioBfr, "\n\r Node: %02X", pnetNodeNumber);
    putStr(ioBfr);
    //putChar('0' + pnetNodeNumber);
    putStr("\n\r Sys st: ");
    putUns2Hex(sysStat);
    putStr("\n\r Relays: ");
    if (RELAY1) putChar('+'); else putChar('-');
    if (RELAY2) putChar('+'); else putChar('-');
    putStr("\n\r Switched Pwr: ");
    if (SwiPwr1) putChar('+'); else putChar('-');
    if (SwiPwr2) putChar('+'); else putChar('-');

    sprintf(ioBfr, "\n\r vRef: %4.03f V\r\n", vRef);
    putStr(ioBfr);

    adcTemper(ADC_SILENT);
    putStr("\n\r Temp now: ");
    sprintf(ioBfr, "%2.01foF [%4.03f]", temperNowF, temper1CalFactor);
    putStr(ioBfr);

    adcTemperSecondary(ADC_SILENT);
    putStr("\n\r Sec temp now: ");
    sprintf(ioBfr, "%2.01foF [%4.03f]",  temperSecondaryF, temper2CalFactor);
    putStr(ioBfr);

    adcRHumid(ADC_SILENT);
    putStr("\n\r Humid now: ");
    sprintf(ioBfr, "%2.01f [%4.03f]",rhumidNow, rhumidCalFactor);
    putStr(ioBfr);
    putStr("\n\r");
}
Пример #30
0
int node2str(spConfigNode*node,str*string)
{
	int i;
	ENTRY;
	
	if(node->text)
		text2str(node->text,string);
	putStr(string,'<');
	for(i=0;i<(int)strlen(node->name);++i)
	{
		switch(node->name[i])
		{
			case '[':case '>': case '\\':
			case '"':case '/':
				putStr(string,'\\');
			default:
				putStr(string,node->name[i]);
		}
	}
	putStr(string,' ');
	for(i=0;i<node->numAttributes;++i)
	{
		attr2str(node->attributes[i],string);
	}
	if(node->numChildren)
	{
		putStr(string,'>');
		
		for(i=0;i<node->numChildren;++i)
		{
			node2str(node->children[i],string);
		}
		
		putStr(string,'<');
		putStr(string,'/');
		for(i=0;i<(int)strlen(node->name);++i)
		{
			switch(node->name[i])
			{
				case '[':case '>': case '\\':
				case '"':case '/':
					putStr(string,'\\');
				default:
					putStr(string,node->name[i]);
			}
		}		
		putStr(string,'>');
	}
	else
	{
		putStr(string,'/');
		putStr(string,'>');
	}
	
	return(0);
}