void encoderTest(void)
{
// initialize the encoders
encoderInit();
// print a little intro message so we know things are working
rprintf("\r\nWelcome to the encoder test!\r\n");
// report encoder position continuously
while(1)
{
rprintfProgStrM("Encoder0: ");
// print encoder0 position
// use base-10, 10 chars, signed, pad with spaces
rprintfNum(10, 10, TRUE, ' ', encoderGetPosition(0));
rprintfProgStrM(" Encoder1: ");
// print encoder1 position
// use base-10, 10 chars, signed, pad with spaces
rprintfNum(10, 10, TRUE, ' ', encoderGetPosition(1));
// print carriage return and line feed
rprintfCRLF();
}
}
unsigned char ataWriteSectorsLBA( unsigned char Drive,
unsigned long lba,
unsigned int numsectors,
unsigned char *Buffer)
{
unsigned int cyl, head, sect;
unsigned char temp;
#ifdef DEBUG_ATA
rprintfProgStrM("ATA LBA write ");
rprintfu32(lba); rprintfProgStrM(" ");
rprintfu16(numsectors); rprintfProgStrM(" ");
rprintfu16((unsigned int)Buffer);
rprintfCRLF();
#endif
sect = (int) ( lba & 0x000000ffL );
lba = lba >> 8;
cyl = (int) ( lba & 0x0000ffff );
lba = lba >> 16;
head = ( (int) ( lba & 0x0fL ) ) | ATA_HEAD_USE_LBA;
temp = ataWriteSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );
if(temp)
ataDiskErr();
return temp;
}
uint8_t edpComposeCommand(uint8_t srcEdpAddr, uint8_t* cmdBuffer)
{
uint8_t string[80];
uint8_t len;
uint8_t i;
// instructions
rprintfProgStrM("Enter EDP Command, format [c][p1][p2][p3]...[pN]\r\n");
rprintfProgStrM("[c] is command char, [px] parameters in 2-digit hex\r\n");
// get user input
rprintfProgStrM("EDP Command>");
len = inputString(0x0D, 80, string);
rprintfCRLF();
// check for null user input
if(!len)
{
rprintfProgStrM("ERROR: No command\r\n");
// return immediately with zero command length
return 0;
}
// prepare command
cmdBuffer[0] = srcEdpAddr;
cmdBuffer[1] = string[0];
for(i=0; i<len/2; i++)
{
cmdBuffer[i+2] = asciiHexToByte(&string[1+(i*2)]);
}
// return command length
return 2+(len/2);
}
void dumpArgsStr(void)
{
rprintfCRLF();
rprintf("Dump arguments as strings\r\n");
rprintfProgStrM("Arg0: "); rprintfStr(cmdlineGetArgStr(0)); rprintfCRLF();
rprintfProgStrM("Arg1: "); rprintfStr(cmdlineGetArgStr(1)); rprintfCRLF();
rprintfProgStrM("Arg2: "); rprintfStr(cmdlineGetArgStr(2)); rprintfCRLF();
rprintfProgStrM("Arg3: "); rprintfStr(cmdlineGetArgStr(3)); rprintfCRLF();
rprintfCRLF();
}
void ds18b20Print(u16 result, u08 resolution)
{
// print raw value
rprintfProgStrM(" 0x");
rprintfu16(result);
rprintfChar(' ');
// print real temp
rprintfNum(10, 4, TRUE , ' ', result>>4);
rprintf(".");
rprintfNum(10, 4, FALSE, '0', (10000*((u32)(result&0x000F)))/16 );
rprintfProgStrM(" C");
}
void ataPrintSector( u08 *Buffer)
{
u08 i;
u16 j;
u08 *buf;
u08 s;
buf = Buffer;
// print the low order address indicies
rprintfProgStrM(" 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 0123456789ABCDEF\r\n");
rprintfProgStrM(" ----------------------------------------------- ---- ASCII -----\r\n");
// print the data
for(j=0; j<0x20; j++)
{
// print the high order address index for this line
rprintfu16(j<<4);
rprintfProgStrM(" ");
// print the hex data
for(i=0; i<0x10; i++)
{
rprintfu08(buf[(j<<4)+i]);
rprintfProgStrM(" ");
}
// leave some space
rprintfProgStrM(" ");
// print the ascii data
for(i=0; i<0x10; i++)
{
s = buf[(j<<4)+i];
// make sure character is printable
if(s >= 0x20)
{
rprintfChar(s);
}
else
{
rprintfChar(0x20);
}
}
rprintfCRLF();
}
}
void CommandLine(void)
{
u08 c;
/* Variable to Run or stop program */
Run = TRUE;
/* Clears the screen and sets the cursor under the Title */
vt100ClearScreen();
vt100SetCursorPos(1,0);
rprintfProgStrM("\r\n\t\t\tStepper Motor Driver - Serial Console\r\n");
cmdlineInit();
cmdlineSetOutputFunc(uartSendByte);
cmdlineAddCommand("quit", quitCommandLine);
cmdlineAddCommand("help", helpDisplay);
cmdlineAddCommand("step", runMotor);
cmdlineInputFunc('\r');
while(Run)
{
while( uartReceiveByte(&c) )
cmdlineInputFunc(c);
cmdlineMainLoop();
}
rprintfCRLF();
rprintf("Program halted.");
}
void spyglassTest(void)
{
// initializing Spyglass interface and I2C bus
rprintf("Initializing Spyglass communication...");
spyglassInit();
spyglassLcdInit();
rprintf("Done!\r\n");
rprintf("Printing 'Hello World!' message to spyglass LCD.\r\n");
rprintfInit(spyglassLcdWriteChar);
spyglassLcdGotoXY(0,0);
rprintfProgStrM("Hello World!");
rprintfInit(uartSendByte);
timerPause(1000);
// initialize systick timer
rprintf("Initializing Periodic Timer\r\n");
timer2SetPrescaler(TIMERRTC_CLK_DIV1024);
// attach the 'systickHandler' so that it gets called every time Timer2 overflows
timerAttach(TIMER2OVERFLOW_INT, systickHandler);
rprintf("Starting local command prompt. Type '?' to get help.\r\n");
rprintf("cmd>");
while(1)
{
serviceLocal();
}
}
void dhcpRequest(void)
{
struct netDhcpHeader* packet;
uint32_t val;
packet = (struct netDhcpHeader*)&netstackGetBuffer()[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN];
// build BOOTP/DHCP header
packet->bootp.op = BOOTP_OP_BOOTREQUEST; // request type
packet->bootp.htype = BOOTP_HTYPE_ETHERNET;
packet->bootp.hlen = BOOTP_HLEN_ETHERNET;
packet->bootp.ciaddr = htonl(ipGetConfig()->ip);
packet->bootp.yiaddr = HTONL(0l);
packet->bootp.siaddr = HTONL(0l);
packet->bootp.giaddr = HTONL(0l);
nicGetMacAddress(&packet->bootp.chaddr[0]); // fill client hardware address
packet->bootp.xid = DhcpTransactID;
packet->bootp.flags = HTONS(1);
// build DHCP request
// begin with magic cookie
packet->cookie = 0x63538263;
// set operation
val = DHCP_MSG_DHCPDISCOVER;
dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);
#ifdef DHCP_DEBUG
rprintfProgStrM("DHCP: Sending Query\r\n");
//dhcpPrintHeader(packet);
#endif
// send request
udpSend(0xFFFFFFFF, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+1, (uint8_t*)packet);
}
//----- Begin Code ------------------------------------------------------------
int main(void)
{
// initialize our libraries
// initialize the UART (serial port)
uartInit();
uartSetBaudRate(115200);
// make all rprintf statements use uart for output
rprintfInit(uartSendByte);
// initialize the timer system
timerInit();
// initialize vt100 terminal
vt100Init();
timerPause(100);
// print welcome message
vt100ClearScreen();
vt100SetCursorPos(1,0);
rprintfProgStrM("\r\nWelcome to the MMC Test Suite!\r\n");
timerPause(1000);
mmcTest();
return 0;
}
u08 schedAttach(volatile u08* _signal, u08 _period)
{
u08 ret;
u08 cnt;
u08 found;
ret = 1;
cnt = 0;
found = false;
while ((cnt < MAX_SIGNALS) && (found == false))
{
if (signal[cnt] == 0)
{
signal[cnt] = _signal;
*signal[cnt] = false;
period[cnt] = _period;
ticks[cnt] = 0;
ret = 0;
found = true;
}
cnt++;
}
#ifdef DEBUG_SCHEDULER
rprintfProgStrM("\r\n schedAttach %u", ret);
#endif
return ret;
}
int netstackService(void)
{
int len;
struct netEthHeader* ethPacket;
// look for a packet
len = nicPoll(NETSTACK_BUFFERSIZE, NetBuffer);
if(len)
{
ethPacket = (struct netEthHeader*)&NetBuffer[0];
#if NET_DEBUG >= 5
rprintf("Received packet len: %d, type:", len);
rprintfu16(htons(ethPacket->type));
rprintfCRLF();
rprintf("Packet Contents\r\n");
debugPrintHexTable(len, NetBuffer);
#endif
if(ethPacket->type == htons(ETHTYPE_IP))
{
// process an IP packet
#ifdef NETSTACK_DEBUG
rprintfProgStrM("NET Rx: IP packet\r\n");
#endif
// add the source to the ARP cache
// also correctly set the ethernet packet length before processing?
arpIpIn((struct netEthIpHeader*)&NetBuffer[0]);
//arpPrintTable();
netstackIPProcess( len-ETH_HEADER_LEN, (ip_hdr*)&NetBuffer[ETH_HEADER_LEN] );
}
else if(ethPacket->type == htons(ETHTYPE_ARP))
{
// process an ARP packet
#ifdef NETSTACK_DEBUG
rprintfProgStrM("NET Rx: ARP packet\r\n");
#endif
arpArpIn(len, ((struct netEthArpHeader*)&NetBuffer[0]) );
#ifdef NETSTACK_DEBUG
//arpPrintTable();
#endif
}
}
return len;
}
void edpRunCommand(uint8_t destEdpAddr, uint8_t cmdLength, uint8_t* cmdBuffer)
{
uint8_t response;
EdpReply* edpReply;
uint8_t retval;
EdpCommand* edpCommand = (EdpCommand*)cmdBuffer;
// send command
rprintf("Sending Command: 0x%x '%c' ->",edpCommand->Command,edpCommand->Command);
retval = edpSendCommand(destEdpAddr, cmdLength, edpCommand);
// handle result values
if(retval == EDP_COMMAND_OK)
{
// command sent successfully
rprintfProgStrM("Send Success!\r\n");
}
else if(retval == EDP_COMMAND_NODEV)
{
// device did not exist
rprintfProgStrM("Send Failed->NO DEVICE!\r\n");
rprintf("No EDP device could be contacted at address 0x%x.\r\n", destEdpAddr);
rprintfProgStrM("The device may be busy or not responding.\r\n");
rprintfProgStrM("Check target device and I2C bus cabling.\r\n");
// return immediately
return;
}
else
{
// other error
rprintfProgStrM("Send Failed->Unspecified Error!\r\n");
// return immediately
return;
}
// get the reply, if any, from the command
retval = edpGetCommandReply(&response, &edpReply);
// handle result values
if(retval == EDP_REPLY_BADCHKSUM)
{
rprintf("**** Reply has bad checksum ****\r\n");
}
// display the reply
edpDisplayReply(response, edpReply);
}
void cs8900RegDump(void)
{
rprintfProgStrM("CS8900 PacketPage Registers\r\n");
rprintfProgStrM("CHIP ID: ");
rprintfu16(cs8900ReadReg(PP_ChipID));
rprintfCRLF();
rprintfProgStrM("PP_ISAIOB: ");
rprintfu16(cs8900ReadReg(PP_ISAIOB));
rprintfCRLF();
rprintfProgStrM("MAC addr: ");
rprintfu16(cs8900ReadReg(PP_IA+0));
rprintfu16(cs8900ReadReg(PP_IA+2));
rprintfu16(cs8900ReadReg(PP_IA+4));
rprintfCRLF();
}
void ataDriveInit(void)
{
u08 i;
unsigned char* buffer = (unsigned char*) SECTOR_BUFFER_ADDR;
// read drive identity
rprintfProgStrM("\r\nScanning IDE interface...\r\n");
// Wait for drive to be ready
ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);
// issue identify command
ataWriteByte(ATA_REG_CMDSTATUS1, 0xEC);
// wait for drive to request data transfer
ataStatusWait(ATA_SR_DRQ, ATA_SR_DRQ);
timerPause(200);
// read in the data
ataReadDataBuffer(buffer, 512);
// set local drive info parameters
ataDriveInfo.cylinders = *( ((unsigned int*) buffer) + ATA_IDENT_CYLINDERS );
ataDriveInfo.heads = *( ((unsigned int*) buffer) + ATA_IDENT_HEADS );
ataDriveInfo.sectors = *( ((unsigned int*) buffer) + ATA_IDENT_SECTORS );
ataDriveInfo.LBAsupport = *( ((unsigned int*) buffer) + ATA_IDENT_FIELDVALID );
ataDriveInfo.sizeinsectors = *( (unsigned long*) (buffer + ATA_IDENT_LBASECTORS*2) );
// copy model string
for(i=0; i<40; i+=2)
{
// correct for byte order
ataDriveInfo.model[i ] = buffer[(ATA_IDENT_MODEL*2) + i + 1];
ataDriveInfo.model[i+1] = buffer[(ATA_IDENT_MODEL*2) + i ];
}
// terminate string
ataDriveInfo.model[40] = 0;
// process and print info
if(ataDriveInfo.LBAsupport)
{
// LBA support
rprintf("Drive 0: %dMB ", ataDriveInfo.sizeinsectors/(1000000/512) );
rprintf("LBA mode -- MODEL: ");
}
else
{
// CHS, no LBA support
// calculate drive size
ataDriveInfo.sizeinsectors = (unsigned long) ataDriveInfo.cylinders*
ataDriveInfo.heads*ataDriveInfo.sectors;
rprintf("Drive 0: %dMB ", ataDriveInfo.sizeinsectors/(1000000/512) );
rprintf("CHS mode C=%d H=%d S=%d -- MODEL: ", ataDriveInfo.cylinders, ataDriveInfo.heads, ataDriveInfo.sectors );
}
// print model information
rprintfStr(ataDriveInfo.model); rprintfCRLF();
// initialize local disk parameters
//ataDriveInfo.cylinders = ATA_DISKPARM_CLYS;
//ataDriveInfo.heads = ATA_DISKPARM_HEADS;
//ataDriveInfo.sectors = ATA_DISKPARM_SECTORS;
}
void ataDiskErr(void)
{
unsigned char b;
b = ataReadByte(ATA_REG_ERROR);
rprintfProgStrM("ATA Error: ");
rprintfu08(b);
rprintfCRLF();
}
void dallasPrintROM(dallas_rom_id_T* rom_id)
{
s08 i;
// print out the rom in the format: xx xx xx xx xx xx xx xx
for(i=7;i>=0;i--)
{
rprintfu08(rom_id->byte[i]);
rprintfChar(' ');
}
// print out the rom in the format: 0xXXXXXXXXXXXXXXXX
rprintfProgStrM(" (0x");
for(i=7;i>=0;i--)
{
rprintfu08(rom_id->byte[i]);
}
rprintfProgStrM("ULL)");
}
int main (void)
{
// initialize
uartInit();
timerInit();
a2dInit();
glcdInit();
outb(DDRA, 0x00);
// send rprintf output to serial port
rprintfInit(uartSendByte);
// print welcome message to serial port
rprintfProgStrM("\r\nWelcome to glcdtest...\r\n");
// send rprintf output to lcd display
rprintfInit(glcdWriteChar);
// perform basic functionality tests
rprintfProgStrM("All initialized...");
glcdSetAddress(4,LINE2);
glcdWriteChar('H');
glcdWriteChar('E');
glcdWriteChar('L');
glcdWriteChar('L');
glcdWriteChar('O');
glcdSetAddress(4,LINE3);
rprintfProgStrM("line 3");
glcdSetAddress(4,LINE4);
rprintfProgStrM("line 4");
glcdSetAddress(4,LINE5);
rprintfProgStrM("line 5");
// run application program
//oscope();
lcdtest();
return 0;
}
void netstackIPProcess(unsigned int len, ip_hdr* packet)
{
// check IP addressing, stop processing if not for me and not a broadcast
if ((htonl(packet->destipaddr) != ipGetConfig()->ip) &&
(htonl(packet->destipaddr) != (ipGetConfig()->ip|(~ipGetConfig()->netmask))) &&
(htonl(packet->destipaddr) != 0xFFFFFFFF))
return;
// handle ICMP packet
if (packet->proto == IP_PROTO_ICMP)
{
#ifdef NETSTACK_DEBUG
rprintfProgStrM("NET Rx: ICMP/IP packet\r\n");
//icmpPrintHeader((icmpip_hdr*)packet);
#endif
icmpIpIn((icmpip_hdr*)packet);
}
else if (packet->proto == IP_PROTO_UDP)
{
#ifdef NETSTACK_DEBUG
rprintfProgStrM("NET Rx: UDP/IP packet\r\n");
//debugPrintHexTable(NeBufferLen-14, &NetBuffer[14]);
#endif
netstackUDPIPProcess(len, ((udpip_hdr*)packet));
}
else if (packet->proto == IP_PROTO_TCP)
{
#ifdef NETSTACK_DEBUG
rprintfProgStrM("NET Rx: TCP/IP packet\r\n");
#endif
netstackTCPIPProcess(len, ((tcpip_hdr*)packet));
}
else
{
#ifdef NETSTACK_DEBUG
rprintfProgStrM("NET Rx: IP packet\r\n");
#endif
}
}
int main(void)
{
struct netEthAddr myEthAddress;
timerInit();
uartInit();
uartSetBaudRate(9600);
rprintfInit(uartSendByte);
timerPause(100);
rprintf("\r\nNetwork Stack Example\r\n");
// initialize systick timer
rprintf("Initializing Periodic Timer\r\n");
timer2SetPrescaler(TIMER_CLK_DIV1024);
timerAttach(TIMER2OVERFLOW_INT, systickHandler);
// init network stack
rprintf("Initializing Network Stack\r\n");
netstackInit(IPADDRESS, NETMASK, GATEWAY);
nicGetMacAddress(&myEthAddress.addr[0]);
rprintfProgStrM("Eth Addr is: "); netPrintEthAddr(&myEthAddress); rprintfCRLF();
rprintfProgStrM("IP Addr is: "); netPrintIPAddr(ipGetConfig()->ip); rprintfCRLF();
rprintf("Network Stack is up!\r\n");
rprintf("Starting packet receive loop\r\n");
while (1)
{
// service local stuff
serviceLocal();
// service the network
netstackService();
}
return 0;
}
void cs8900IORegDump(void)
{
rprintfProgStrM("CS8900 I/O Registers\r\n");
rprintfProgStrM(" FRAME ISQ ADDR DATA0 DATA1\r\n");
rprintfProgStrM("-------------------------------\r\n");
rprintfProgStrM(" ");
rprintfu16(cs8900Read16(CS8900_IO_RXTX_DATA_PORT0));
rprintfProgStrM(" ");
rprintfu16(cs8900Read16(CS8900_IO_ISQ));
rprintfProgStrM(" ");
rprintfu16(cs8900Read16(CS8900_IO_PP_PTR));
rprintfProgStrM(" ");
rprintfu16(cs8900Read16(CS8900_IO_PP_DATA_PORT0));
rprintfProgStrM(" ");
rprintfu16(cs8900Read16(CS8900_IO_PP_DATA_PORT1));
rprintfCRLF();
}
void icmpPrintHeader(icmpip_hdr* packet)
{
rprintfProgStrM("ICMP Packet:\n");
// print source IP address
rprintfProgStrM("SrcIpAddr: "); netPrintIPAddr(htonl(packet->ip.srcipaddr)); rprintfCRLF();
// print dest IP address
rprintfProgStrM("DstIpAddr: "); netPrintIPAddr(htonl(packet->ip.destipaddr)); rprintfCRLF();
// print type
rprintfProgStrM("Type : ");
switch(packet->icmp.type)
{
case ICMP_TYPE_ECHOREQUEST: rprintfProgStrM("ECHO REQUEST"); break;
case ICMP_TYPE_ECHOREPLY: rprintfProgStrM("ECHO REPLY"); break;
default: rprintfProgStrM("UNKNOWN"); break;
}
rprintfCRLF();
// print code
rprintfProgStrM("Code : 0x"); rprintfu08(packet->icmp.icode); rprintfCRLF();
}
void dhcpRelease(void)
{
struct netDhcpHeader* packet;
uint32_t val;
uint8_t* optptr;
packet = (struct netDhcpHeader*)&netstackGetBuffer()[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN];
// build BOOTP/DHCP header
packet->bootp.op = BOOTP_OP_BOOTREQUEST; // request type
packet->bootp.htype = BOOTP_HTYPE_ETHERNET;
packet->bootp.hlen = BOOTP_HLEN_ETHERNET;
packet->bootp.ciaddr = htonl(ipGetConfig()->ip);
packet->bootp.yiaddr = HTONL(0l);
packet->bootp.siaddr = HTONL(0l);
packet->bootp.giaddr = HTONL(0l);
nicGetMacAddress(&packet->bootp.chaddr[0]); // fill client hardware address
packet->bootp.xid = DhcpTransactID; // set trans ID (use part of MAC address)
packet->bootp.flags = HTONS(1);
// build DHCP request
// begin with magic cookie
packet->cookie = 0x63538263;
// set operation
val = DHCP_MSG_DHCPRELEASE;
optptr = dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);
// set the server ID
val = htonl(DhcpServerIP);
optptr = dhcpSetOption(optptr, DHCP_OPT_SERVERID, 4, &val);
// request the IP previously offered
optptr = dhcpSetOption(optptr, DHCP_OPT_REQUESTEDIP, 4, &packet->bootp.ciaddr);
#ifdef DHCP_DEBUG
rprintfProgStrM("DHCP: Sending Release to "); netPrintIPAddr(DhcpServerIP); rprintfCRLF();
//dhcpPrintHeader(packet);
#endif
// send release
udpSend(DhcpServerIP, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+6+6+1, (uint8_t*)packet);
// deconfigure ip addressing
ipSetConfig(0,0,0);
DhcpLeaseTime = 0;
}
unsigned char ataWriteSectorsCHS(unsigned char Drive,
unsigned char Head,
unsigned int Track,
unsigned char Sector,
unsigned int numsectors,
unsigned char *Buffer)
{
unsigned char temp;
// Wait for drive to be ready
temp = ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);
// Prepare parameters...
ataWriteByte(ATA_REG_HDDEVSEL, 0xA0+(Drive ? 0x10:00)+Head); // CHS mode/Drive/Head
ataWriteByte(ATA_REG_CYLHI, Track>>8); // MSB of track
ataWriteByte(ATA_REG_CYLLO, Track); // LSB of track
ataWriteByte(ATA_REG_STARTSEC, Sector); // sector
ataWriteByte(ATA_REG_SECCOUNT, numsectors); // # of sectors
// Issue write sector command
ataWriteByte(ATA_REG_CMDSTATUS1, 0x31);
//delay(100);
// Wait for drive to request data transfer
ataStatusWait(ATA_SR_DRQ, 0);
// write data to drive
ataWriteDataBuffer(Buffer, 512*numsectors);
// Wait for drive to finish write
temp = ataStatusWait(ATA_SR_BSY, ATA_SR_BSY);
// check for errors
if (temp & ATA_SR_ERR)
{
rprintfProgStrM("WR ERR\r\n");
return 1;
}
// Return the error bit from the status register...
return (temp & ATA_SR_ERR) ? 1:0;
}
void cmdlineProcessInputString(void)
{
u08 cmdIndex;
u08 i=0;
// save command in history
cmdlineDoHistory(CMDLINE_HISTORY_SAVE);
// find the end of the command (excluding arguments)
// find first whitespace character in CmdlineBuffer
while( !((CmdlineBuffer[i] == ' ') || (CmdlineBuffer[i] == 0)) ) i++;
if(!i)
{
// command was null or empty
// output a new prompt
//cmdlinePrintPrompt();
// we're done
return;
}
rprintfProgStrM("\", \"data\": ");
// search command list for match with entered command
for(cmdIndex=0; cmdIndex<CmdlineNumCommands; cmdIndex++)
{
if( !strncmp(CmdlineCommandList[cmdIndex], CmdlineBuffer, i) )
{
// user-entered command matched a command in the list (database)
// run the corresponding function
CmdlineExecFunction = CmdlineFunctionList[cmdIndex];
// new prompt will be output after user function runs
// and we're done
return;
}
}
// if we did not get a match
// output an error message
cmdlinePrintError();
// output a new prompt
cmdlinePrintPrompt();
}
void goCmdline(void)
{
u08 c;
// print welcome message
vt100ClearScreen();
vt100SetCursorPos(1,0);
rprintfProgStrM("\r\nWelcome to the Command Line Test Suite!\r\n");
// initialize cmdline system
cmdlineInit();
// direct cmdline output to uart (serial port)
cmdlineSetOutputFunc(uartSendByte);
// add commands to the command database
cmdlineAddCommand("exit", exitFunction);
cmdlineAddCommand("help", helpFunction);
cmdlineAddCommand("dumpargs1", dumpArgsStr);
cmdlineAddCommand("dumpargs2", dumpArgsInt);
cmdlineAddCommand("dumpargs3", dumpArgsHex);
// send a CR to cmdline input to stimulate a prompt
cmdlineInputFunc('\r');
// set state to run
Run = TRUE;
// main loop
while(Run)
{
// pass characters received on the uart (serial port)
// into the cmdline processor
while(uartReceiveByte(&c)) cmdlineInputFunc(c);
// run the cmdline execution functions
cmdlineMainLoop();
}
rprintfCRLF();
rprintf("Exited program!\r\n");
}
unsigned char ataWriteSectors(unsigned char Drive,
unsigned long lba,
unsigned int numsectors,
unsigned char *Buffer)
{
unsigned int cyl, head, sect;
unsigned char temp;
// check if drive supports native LBA mode
if(ataDriveInfo.LBAsupport)
{
// drive supports using native LBA
temp = ataWriteSectorsLBA(Drive, lba, numsectors, Buffer);
}
else
{
// drive required CHS access
#ifdef DEBUG_ATA
// do this defore destroying lba
rprintfProgStrM("ATA LBA for CHS write: ");
rprintfProgStrM("LBA="); rprintfu32(lba); rprintfProgStrM(" ");
#endif
// convert LBA to pseudo CHS
// remember to offset the sector count by one
sect = (u08) (lba % ataDriveInfo.sectors)+1;
lba = lba / ataDriveInfo.sectors;
head = (u08) (lba % ataDriveInfo.heads);
lba = lba / ataDriveInfo.heads;
cyl = (u16) lba;
#ifdef DEBUG_ATA
rprintfProgStrM("C:H:S=");
rprintfu16(cyl); rprintfProgStrM(":");
rprintfu08(head); rprintfProgStrM(":");
rprintfu08(sect); rprintfCRLF();
#endif
temp = ataWriteSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );
}
if(temp)
ataDiskErr();
return temp;
}
void sp5K_writeFunction(void)
{
u08 dateTimeStr[11];
char tmp[3];
RtcTimeType rtcDateTime;
char *p;
u08 devId, address, regValue;
u08 value = 0;
s08 retS = FALSE;
u08 mcp_address = 0;
u08 length = 0;
u08 *nro = NULL;
u08 *msg = NULL;
u08 timeout;
char phase;
u08 chip;
u16 sleepTime;
memset( cmd_printfBuff, NULL, CHAR128);
makeargv();
// Parametros:
if (!strcmp_P( strupr(argv[1]), PSTR("PARAM\0")))
{
// PASSWD
if (!strcmp_P( strupr(argv[2]), PSTR("PASSWD\0"))) {
memset(systemVars.passwd, '\0', sizeof(systemVars.passwd));
memcpy(systemVars.passwd, argv[3], sizeof(systemVars.passwd));
systemVars.passwd[PASSWD_LENGTH - 1] = '\0';
pv_snprintfP_OK();
return;
}
// APN
if (!strcmp_P( strupr(argv[2]), PSTR("APN\0"))) {
memset(systemVars.apn, '\0', sizeof(systemVars.apn));
memcpy(systemVars.apn, argv[3], sizeof(systemVars.apn));
systemVars.apn[APN_LENGTH - 1] = '\0';
pv_snprintfP_OK();
return;
}
// SERVER PORT
if (!strcmp_P( strupr(argv[2]), PSTR("PORT\0"))) {
memset(systemVars.serverPort, '\0', sizeof(systemVars.serverPort));
memcpy(systemVars.serverPort, argv[3], sizeof(systemVars.serverPort));
systemVars.serverPort[PORT_LENGTH - 1] = '\0';
pv_snprintfP_OK();
return;
}
// SERVER IP
if (!strcmp_P( strupr(argv[2]), PSTR("IP\0"))) {
memset(systemVars.serverAddress, '\0', sizeof(systemVars.serverAddress));
memcpy(systemVars.serverAddress, argv[3], sizeof(systemVars.serverAddress));
systemVars.serverAddress[IP_LENGTH - 1] = '\0';
pv_snprintfP_OK();
return;
}
// SERVER SCRIPT
// write param script cgi-bin/oseApp/scripts/oseSp5K001.pl
if (!strcmp_P( strupr(argv[2]), PSTR("SCRIPT\0"))) {
memset(systemVars.serverScript, '\0', sizeof(systemVars.serverScript));
memcpy(systemVars.serverScript, argv[3], sizeof(systemVars.serverScript));
systemVars.serverScript[SCRIPT_LENGTH - 1] = '\0';
pv_snprintfP_OK();
return;
}
// MagP ( magnitud por pulso )
if (!strcmp_P( strupr(argv[2]), PSTR("MAGP\0"))) {
retS = setParamMagP(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// dname X ( digital name X )
if (!strcmp_P( strupr(argv[2]), PSTR("DNAME\0"))) {
retS = setParamDname(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// aname X ( analog name X )
if (!strcmp_P( strupr(argv[2]), PSTR("ANAME\0"))) {
retS = setParamAname(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// imin X
if (!strcmp_P( strupr(argv[2]), PSTR("IMIN\0"))) {
retS = setParamImin(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// imax X
if (!strcmp_P( strupr(argv[2]), PSTR("IMAX\0"))) {
retS = setParamImax(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Mmin X
if (!strcmp_P( strupr(argv[2]), PSTR("MMIN\0"))) {
retS = setParamMmin(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Mmax X
if (!strcmp_P( strupr(argv[2]), PSTR("MMAX\0"))) {
retS = setParamMmax(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// offmmin X
if (!strcmp_P( strupr(argv[2]), PSTR("OFFMMIN\0"))) {
retS = setParamOffset(0,argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// offmmax X
if (!strcmp_P( strupr(argv[2]), PSTR("OFFMMAX\0"))) {
retS = setParamOffset(1,argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
/* DebugLevel */
if (!strcmp_P( strupr(argv[2]), PSTR("DEBUGLEVEL\0"))) {
retS = setParamDebugLevel(argv[3]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
/* LogLevel */
if (!strcmp_P( strupr(argv[2]), PSTR("LOGLEVEL\0"))) {
retS = setParamLogLevel(argv[3]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// dlgId
if (!strcmp_P( strupr(argv[2]), PSTR("DLGID\0"))) {
memcpy(systemVars.dlgId, argv[3], sizeof(systemVars.dlgId));
systemVars.dlgId[DLGID_LENGTH - 1] = '\0';
pv_snprintfP_OK();
return;
}
/* TimerPoll */
if (!strcmp_P( strupr(argv[2]), PSTR("TIMERPOLL\0"))) {
retS = setParamTimerPoll(argv[3]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
/* TimerDial */
if (!strcmp_P( strupr(argv[2]), PSTR("TIMERDIAL\0"))) {
retS = setParamTimerDial(argv[3]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
/* Wrkmode */
if (!strcmp_P( strupr(argv[2]), PSTR("WRKMODE\0"))) {
retS = setParamWrkMode(argv[3],argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
/* Pwrmode */
if (!strcmp_P( strupr(argv[2]), PSTR("PWRMODE\0"))) {
retS = setParamPwrMode(argv[3]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
/* // MONITOR
// write param monitor [sqe|frame]
if (!strcmp_P( strupr(argv[2]), PSTR("MONITOR\0"))) {
retS = setParamMonitor(argv[3]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
*/
}
// CONSIGNA
if (!strcmp_P( strupr(argv[2]), PSTR("CONSIGNA\0"))) {
retS = setParamConsigna(argv[3], argv[4]);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// ALL SystemVars ( save )
if (!strcmp_P( strupr(argv[1]), PSTR("SAVE\0"))) {
retS = saveSystemParamsInEE( &systemVars );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// RTC
if (!strcmp_P( strupr(argv[1]), PSTR("RTC\0"))) {
/* YYMMDDhhmm */
memcpy(dateTimeStr, argv[2], 10);
// year
tmp[0] = dateTimeStr[0]; tmp[1] = dateTimeStr[1]; tmp[2] = '\0';
rtcDateTime.year = atoi(tmp);
// month
tmp[0] = dateTimeStr[2]; tmp[1] = dateTimeStr[3]; tmp[2] = '\0';
rtcDateTime.month = atoi(tmp);
// day of month
tmp[0] = dateTimeStr[4]; tmp[1] = dateTimeStr[5]; tmp[2] = '\0';
rtcDateTime.day = atoi(tmp);
// hour
tmp[0] = dateTimeStr[6]; tmp[1] = dateTimeStr[7]; tmp[2] = '\0';
rtcDateTime.hour = atoi(tmp);
// minute
tmp[0] = dateTimeStr[8]; tmp[1] = dateTimeStr[9]; tmp[2] = '\0';
rtcDateTime.min = atoi(tmp);
retS = rtcSetTime(&rtcDateTime);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Si no estoy en modo service no puedo hacer estas tareas administrativas.
if ( systemVars.wrkMode != WK_SERVICE) {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("WARNING: Debe pasar a modo SERVICE !!!\r\n\0"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// MCP
// write mcp 0|1|2 addr value
if (!strcmp_P( strupr(argv[1]), PSTR("MCP\0"))) {
devId = atoi(argv[2]);
address = atoi(argv[3]);
regValue = strtol(argv[4],NULL,2);
if ( devId == 0 ) { mcp_address = MCP_ADDR0; }
if ( devId == 1 ) { mcp_address = MCP_ADDR1; }
if ( devId == 2 ) { mcp_address = MCP_ADDR2; }
retS = MCP_write( address, mcp_address, 1, ®Value);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// EEPROM
if (!strcmp_P( strupr(argv[1]), PSTR("EE\0"))) {
address = atoi(argv[2]);
p = argv[3];
while (*p != NULL) {
p++;
length++;
if (length > CMDLINE_BUFFERSIZE )
break;
}
retS = EE_write( address, length, argv[3] );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// LED
// write led 0|1
if (!strcmp_P( strupr(argv[1]), PSTR("LED\0"))) {
value = atoi(argv[2]);
retS = MCP_setLed( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// gprsPWR
if (!strcmp_P( strupr(argv[1]), PSTR("GPRSPWR\0"))) {
value = atoi(argv[2]);
retS = MCP_setGprsPwr( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// gprsSW
if (!strcmp_P( strupr(argv[1]), PSTR("GPRSSW\0"))) {
value = atoi(argv[2]);
retS = MCP_setGprsSw( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// termPWR
if (!strcmp_P( strupr(argv[1]), PSTR("TERMPWR\0"))) {
value = atoi(argv[2]);
retS = MCP_setTermPwr( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// sensorPWR
if (!strcmp_P( strupr(argv[1]), PSTR("SENSORPWR\0"))) {
value = atoi(argv[2]);
retS = MCP_setSensorPwr( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// analogPWR
if (!strcmp_P( strupr(argv[1]), PSTR("ANALOGPWR\0"))) {
value = atoi(argv[2]);
retS = MCP_setAnalogPwr( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// SMS
if (!strcmp_P(argv[1], PSTR("SMS\0"))) {
nro = argv[2];
msg = cmdlineGetArgStr(3);
rprintfStr(GPRS_UART, "AT+CMGS=\"+\0" );
rprintfStr(GPRS_UART, nro );
rprintfStr(GPRS_UART, "\r\0");
// Espero el prompt > para enviar el mensaje.
timeout = 10;
xUartQueueFlush(GPRS_UART);
while (timeout > 0) {
vTaskDelay( (portTickType)( 1000 / portTICK_RATE_MS ));
if (strstr( &xUart0RxedCharsBuffer.buffer, ">") != NULL) {
break;
}
timeout--;
}
rprintfStr(GPRS_UART, msg );
rprintfStr(GPRS_UART, "\r");
rprintfStr(CMD_UART, &xUart0RxedCharsBuffer.buffer );
rprintfCRLF(CMD_UART);
rprintfStr(GPRS_UART, "\032");
return;
}
// ATCMD
if (!strcmp_P(argv[1], PSTR("ATCMD\0"))) {
msg = argv[2];
timeout = atoi(argv[3]);
if (timeout == 0)
timeout = 1;
xUartQueueFlush(GPRS_UART);
rprintfStr(GPRS_UART, msg);
rprintfStr(GPRS_UART, "\r\0");
rprintfStr(CMD_UART, "sent>\0");
rprintfStr(CMD_UART, msg);
rprintfCRLF(CMD_UART);
while (timeout > 0) {
vTaskDelay( (portTickType)( 1000 / portTICK_RATE_MS ));
timeout--;
}
rprintfStr(CMD_UART, &xUart0RxedCharsBuffer.buffer );
rprintfCRLF(CMD_UART);
return;
}
#ifdef CHANNELS_3
// Valves: Phase
// write ph A1 1
if (!strcmp_P( strupr(argv[1]), PSTR("PH\0"))) {
phase = toupper( argv[2][0] );
//(s0)++;
chip = argv[2][1] - 0x30;
value = atoi(argv[3]);
retS = setValvesPhase(phase,chip, value);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Valves: Enable
// write en A1 1
if (!strcmp_P( strupr(argv[1]), PSTR("EN\0"))) {
phase = toupper( argv[2][0] );
//(s0)++;
chip = argv[2][1] - 0x30;
value = atoi(argv[3]);
retS = setValvesEnable(phase,chip, value);
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Valves: Reset
if (!strcmp_P( strupr(argv[1]), PSTR("VRESET\0"))) {
value = atoi(argv[2]);
retS = setValvesReset( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Valves: Sleep
if (!strcmp_P( strupr(argv[1]), PSTR("VSLEEP\0"))) {
value = atoi(argv[2]);
retS = setValvesSleep( value );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Valves: Pulse [A/B][1/2] {+|-} {ms}
if (!strcmp_P( strupr(argv[1]), PSTR("VPULSE\0"))) {
phase = toupper( argv[2][0] );
chip = argv[2][1] - 0x30;
value = toupper( argv[3][0] );
sleepTime = atol(argv[4]);
if ( sleepTime > 5000 ) {
sleepTime = 5000;
}
retS = setValvesPulse( phase, chip, value, sleepTime );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Valves: OPEN
if (!strcmp_P( strupr(argv[1]), PSTR("OPEN\0"))) {
phase = toupper( argv[2][0] );
chip = argv[2][1] - 0x30;
retS = setValvesOpen( phase, chip );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Valves: CLOSE
if (!strcmp_P( strupr(argv[1]), PSTR("CLOSE\0"))) {
phase = toupper( argv[2][0] );
chip = argv[2][1] - 0x30;
retS = setValvesClose( phase, chip );
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
// Valves: Consigna
if (!strcmp_P( strupr(argv[1]), PSTR("CONSIGNA\0"))) {
if (!strcmp_P( strupr(argv[2]), PSTR("DIA\0"))) {
retS = setConsignaDia();
}
if (!strcmp_P( strupr(argv[2]), PSTR("NOCHE\0"))) {
retS = setConsignaNoche();
}
if ( retS ) {
pv_snprintfP_OK();
} else {
pv_snprintfP_ERR();
}
return;
}
#endif
// CMD NOT FOUND
if (xSemaphoreTake( sem_CmdUart, MSTOTAKECMDUARTSEMPH ) == pdTRUE ) {
rprintfProgStrM(CMD_UART, "ERROR\r\n");
rprintfProgStrM(CMD_UART, "CMD NOT DEFINED\r\n");
xSemaphoreGive( sem_CmdUart );
}
return;
}
void sp5K_readFunction(void)
{
u08 devId, address, regValue, pin, channel, pcbChannel, adcChannel;
u08 length = 10;
s08 retS;
u08 mcp_address;
RtcTimeType rtcDateTime;
u08 i;
u16 adcRetValue;
char eeRdBuffer[EERDBUFLENGHT];
u16 eeAddress;
u08 pos;
frameDataType rdFrame;
u16 recCount;
double I,M,D;
u08 bdGetStatus;
u16 rcdIndex;
u08 b[9];
memset( cmd_printfBuff, NULL, CHAR128);
makeargv();
// RTC
// Lee la hora del RTC.
if (!strcmp_P( strupr(argv[1]), PSTR("RTC\0"))) {
retS = rtcGetTime(&rtcDateTime);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d/%02d/%04d "),rtcDateTime.day,rtcDateTime.month, rtcDateTime.year );
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("%02d:%02d:%02d\r\n\0"),rtcDateTime.hour,rtcDateTime.min, rtcDateTime.sec );
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DCD
if (!strcmp_P( strupr(argv[1]), PSTR("DCD\0"))) {
retS = MCP_queryDcd(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DCD OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// RI
if (!strcmp_P( strupr(argv[1]), PSTR("RI\0"))) {
retS = MCP_queryRi(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("RI OFF\r\n\0")); }
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN0
if (!strcmp_P( strupr(argv[1]), PSTR("DIN0\0"))) {
retS = MCP_queryDin0(&pin);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN0 %d\r\n\0"), pin);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// DIN1
if (!strcmp_P( strupr(argv[1]), PSTR("DIN1\0"))) {
retS = MCP_queryDin1(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("DIN1 %d\r\n\0"), pin);
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(cmd_printfBuff);
return;
}
// TERMSW
if (!strcmp_P( strupr(argv[1]), PSTR("TERMSW\0"))) {
retS = MCP_queryTermPwrSw(&pin);
if (retS ) {
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
if ( pin == 1 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW ON\r\n\0")); }
if ( pin == 0 ) { pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("TERMSW OFF\r\n\0")); }
} else {
snprintf_P( cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MCP
// read mcp 0|1|2 addr
if (!strcmp_P( strupr(argv[1]), PSTR("MCP\0"))) {
devId = atoi(argv[2]);
address = atoi(argv[3]);
if ( devId == 0 ) { mcp_address = MCP_ADDR0; }
if ( devId == 1 ) { mcp_address = MCP_ADDR1; }
if ( devId == 2 ) { mcp_address = MCP_ADDR2; }
retS = MCP_read( address, mcp_address, 1, ®Value);
if (retS ) {
// Convierto el resultado a binario.
pos = snprintf_P( cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
strcpy(b,byte_to_binary(regValue));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("mcp %d: reg=[%d] data=[0X%03x] [%s] \r\n\0"),devId, address,regValue, b);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// *****************************************************************************************************
// SOLO PARA USO EN MODO SERVICE.
if ( systemVars.wrkMode != WK_SERVICE) {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("WARNING: Debe pasar a modo SERVICE !!!\r\n"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// ADC
// read adc channel
// El canal es de 0..3/0..7 y representa el canal fisico en el conector, NO
// EL PROPIO CANAL DEL A/D
if (!strcmp_P( strupr(argv[1]), PSTR("ADC\0"))) {
pcbChannel = atoi(argv[2]);
if ( NRO_CHANNELS == 3 ) {
switch (pcbChannel ) {
case 0:
adcChannel = 3;
break;
case 1:
adcChannel = 5;
break;
case 2:
adcChannel = 7;
break;
case 3:
adcChannel = 1; // Bateria
break;
}
}
retS = ADS7828_convert( adcChannel, &adcRetValue );
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("adc_%d(%d)=[%d]\r\n\0"),pcbChannel, adcChannel, adcRetValue);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// FRAME
// Lee todos los canales y presenta el frame.
if (!strcmp_P( strupr(argv[1]), PSTR("FRAME\0"))) {
SIGNAL_tkDataReadFrame();
return;
}
// EEPROM
// read ee addr length
if (!strcmp_P( strupr(argv[1]), PSTR("EE\0"))) {
eeAddress = atol(argv[2]);
length = atoi(argv[3]);
// Buffer control.
if (length > EERDBUFLENGHT) {
length = EERDBUFLENGHT;
}
retS = EE_read( eeAddress, length, &eeRdBuffer);
if (retS ) {
pos = snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n"));
pos += snprintf_P( &cmd_printfBuff[pos],CHAR128,PSTR("addr=[%d] data=[%s]\r\n\0"),eeAddress,eeRdBuffer);
} else {
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("ERROR\r\n\0"));
}
sp5K_printStr(&cmd_printfBuff);
return;
}
// MEMORY DUMP
if (!strcmp_P( strupr(argv[1]), PSTR("MEMORY\0"))) {
recCount = 0;
for (;;) {
vTaskDelay( (portTickType)(50 / portTICK_RATE_MS) );
rcdIndex = BD_getRDptr();
bdGetStatus = BD_get( &rdFrame, rcdIndex);
// BD vacia
if (bdGetStatus == 0) {
break;
}
recCount++;
// Armo el frame
memset( cmd_printfBuff, NULL, CHAR128);
pos = 0;
pos = snprintf_P( &cmd_printfBuff, CHAR128, PSTR("(%d/%d)>" ), recCount, rcdIndex);
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%04d%02d%02d,"),rdFrame.rtc.year,rdFrame.rtc.month, rdFrame.rtc.day );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%02d%02d%02d,"),rdFrame.rtc.hour,rdFrame.rtc.min, rdFrame.rtc.sec );
// Valores analogicos
for ( channel = 0; channel < NRO_CHANNELS; channel++) {
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f"),systemVars.aChName[channel],rdFrame.analogIn[channel] );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(","));
}
// Valores digitales.
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR("%s=%.2f,"), systemVars.dChName[0], rdFrame.din0_pCount );
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR( "%s=%.2f"), systemVars.dChName[1], rdFrame.din0_pCount );
#ifdef CHANNELS_3
// Bateria
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128, PSTR(",bt=%.2f"), rdFrame.batt );
#endif
pos += snprintf_P( &cmd_printfBuff[pos], CHAR128,PSTR("<\r\n\0") );
// Imprimo
sp5K_printStr(&cmd_printfBuff);
BD_delete(-1);
taskYIELD();
}
snprintf_P( &cmd_printfBuff,CHAR128,PSTR("OK\r\n\0"));
sp5K_printStr(&cmd_printfBuff);
return;
}
// CMD NOT FOUND
if (xSemaphoreTake( sem_CmdUart, MSTOTAKECMDUARTSEMPH ) == pdTRUE ) {
rprintfProgStrM(CMD_UART, "ERROR\r\n");
rprintfProgStrM(CMD_UART, "CMD NOT DEFINED\r\n");
xSemaphoreGive( sem_CmdUart );
}
return;
}
//------------------------------------------------------------------------------------
void sp5K_helpFunction(void)
{
if (xSemaphoreTake( sem_CmdUart, MSTOTAKECMDUARTSEMPH ) == pdTRUE ) {
rprintfProgStrM(CMD_UART, "Spymovil \0");
rprintfProgStrM(CMD_UART, SP5K_MODELO);
rprintfChar(CMD_UART, ' ');
rprintfProgStrM(CMD_UART, SP5K_VERSION);
rprintfChar(CMD_UART, ' ');
rprintfProgStrM(CMD_UART, EE_TYPE);
rprintfChar(CMD_UART, '-');
rprintfProgStrM(CMD_UART, FTYPE);
rprintfChar(CMD_UART, ' ');
rprintfProgStrM(CMD_UART, SP5K_REV);
rprintfChar(CMD_UART, ' ');
rprintfProgStrM(CMD_UART, SP5K_DATE);
rprintfCRLF(CMD_UART);
rprintfProgStrM(CMD_UART, "Available commands are:\r\n");
rprintfProgStrM(CMD_UART, "-cls\r\n\0");
rprintfProgStrM(CMD_UART, "-help\r\n\0");
rprintfProgStrM(CMD_UART, "-reset {default ,memory}\r\n\0");
rprintfProgStrM(CMD_UART, "-status\r\n\0");
rprintfProgStrM(CMD_UART, "-write rtc YYMMDDhhmm \r\n");
rprintfProgStrM(CMD_UART, " param { wrkmode [service | monitor {sqe|frame}], pwrmode [continuo|discreto] } \r\n");
rprintfProgStrM(CMD_UART, " timerpoll, timerdial, dlgid \r\n");
rprintfProgStrM(CMD_UART, " debuglevel +/-{none,i2c,bd,data,gprs,digital,all} \r\n");
rprintfProgStrM(CMD_UART, " loglevel (none, info, all)\r\n");
rprintfProgStrM(CMD_UART, " imin|imax|mmin|mmax|magp|offmmin|offmmax X val\r\n");
rprintfProgStrM(CMD_UART, " aname, dname\r\n");
rprintfProgStrM(CMD_UART, " apn, port, ip, script, passwd\r\n");
#ifdef CHANNELS_3
rprintfProgStrM(CMD_UART, " consigna [none|doble], [dia|noche] {hh:mm} \r\n");
#endif
rprintfProgStrM(CMD_UART, " save\r\n");
if ( systemVars.wrkMode == WK_SERVICE) {
rprintfProgStrM(CMD_UART, " mcp devId regAddr {xxxxxxxx}\r\n");
rprintfProgStrM(CMD_UART, " ee addr string\r\n");
rprintfProgStrM(CMD_UART, " led {0|1},gprspwr {0|1},gprssw {0|1},termpwr {0|1},sensorpwr {0|1},analogpwr {0|1}\r\n");
rprintfProgStrM(CMD_UART, " sms {nro,msg}, atcmd {atcmd,timeout}\r\n");
#ifdef CHANNELS_3
rprintfProgStrM(CMD_UART, " ph [A/B][1/2] {0|1}, en [A/B][1/2] {0|1}, vreset {0|1} vsleep {0|1}\r\n");
rprintfProgStrM(CMD_UART, " vpulse [A/B][1/2] {+|-} {ms}\r\n");
rprintfProgStrM(CMD_UART, " open [A/B][1/2], close [A/B][1/2], consigna [dia|noche] \r\n");
#endif
}
rprintfProgStrM(CMD_UART, "-read rtc\r\n");
rprintfProgStrM(CMD_UART, " mcp devId regAddr\r\n");
rprintfProgStrM(CMD_UART, " dcd,ri,termsw,din0,din1\r\n");
if ( systemVars.wrkMode == WK_SERVICE) {
rprintfProgStrM(CMD_UART, " adc{channel}, frame\r\n");
rprintfProgStrM(CMD_UART, " ee addr lenght\r\n");
rprintfProgStrM(CMD_UART, " memory \r\n");
rprintfCRLF(CMD_UART);
}
xSemaphoreGive( sem_CmdUart );
}
}
