/***********************************************

main.c
Tutorial Lectia 6
Interpretor de comenzi (CLIP Command Line InterPreter)
Format comanda:
cspppppppp<CR>
|||||||||| |
|||||||||| +----------> Sfarsit comanda (CR=0xD)
||++++++++------------> Parametrul comenzii (max. 8 caractere ASCII Hex)
|+--------------------> Separator (unul sau mai multe spatii, 0x20)
+---------------------> Cod comanda (0x3F..0x7F, ASCII "?".."~")
Hardware: KT458-V0 (PIC18F4520)
Nucleu: K5420 V1.0
Adresa de start Firmware: 0x400
Resurse utilizate:
RC5 - Backlight (BKL)
RC6 - TxD USART
RC7 - RxD USART
***********************************************/
/***********************************************
Fisiere incluse
***********************************************/
#include <p18cxxx.h>
/***********************************************
Definitii
***********************************************/
#define BKL LATCbits.LATC5 // Control backlight
// Constante USART
#define FOSC 12000000UL // Frecventa oscilatorului (Hz)
#define BAUD 57600UL // Rata Baud USART
#define DIVIDER ((int)(FOSC/(16UL * BAUD) -1)) // Valoare divizor
// Definitii tipuri
typedef union _BYTE
{
unsigned char _byte;
struct
{
unsigned b0:1;
unsigned b1:1;
unsigned b2:1;
unsigned b3:1;
unsigned b4:1;
unsigned b5:1;
unsigned b6:1;
unsigned b7:1;
};
} BYTE;
// Constante diverse
#define BUF_LEN 16 // Lungime linie de comanda
#define CR 0x0D // CR
#define LF 0x0A // LF
#define ESC 0x1B // Esc
/***********************************************
Variabile globale
***********************************************/
#pragma udata
BYTE Flags; // Semafoare

#define CMDFlag Flags.b0 // Semafor comanda valida

unsigned char CBuf[BUF_LEN]; // Buffer comanda
char Ch; // Cod comanda
unsigned char CmdLen; // Lungime linie de comanda
unsigned long Par; // Parametrul comenzii
unsigned char NPar; // Numar parametri
/***********************************************
Prototipuri
***********************************************/
void high_isr(void);
void low_isr(void);
void putc(unsigned char ch);
void putrs(const rom char *data);
unsigned char getc(void);
char Hex2Asc(char ch);
void putb(unsigned char aByte);
void putbnlz(unsigned char aByte);
unsigned char isdec(unsigned char ch);
unsigned char ishex(unsigned char ch);
unsigned char Asc2Hex(char ch);
void GetCmd(void);
void ProcCmd(void);
void ExecCmd(void);
void B_Cmd(void);
void H_Cmd(void);
void Z_Cmd(void);
void C_Cmd(void);
/***********************************************
Redirectari intreruperi
***********************************************/
#pragma code high_vector = 0x408
void interrupt_at_high_vector(void)
{
_asm
goto high_isr
_endasm
}//end interrupt_at_high_vector
#pragma code low_vector = 0x418
void interrupt_at_low_vector(void)
{
_asm
goto low_isr
_endasm
}//end interrupt_at_low_vector
#pragma code
/***********************************************
Rutine de tratare a intreruperilor (ISR)
***********************************************/
#pragma interrupt high_isr
void high_isr(void)
{
}//end high_isr
#pragma interruptlow low_isr
void low_isr(void)
{
}//end low_isr
/***********************************************

Functia main
***********************************************/
#pragma code
void main(void)
{
// Initializare PORT-uri
TRISCbits.TRISC5 = 0; // RC5 - iesire Backlight
TRISCbits.TRISC6 = 1; // RC6 intrare USART TxD
TRISCbits.TRISC7 = 1; // RC7 intrare USART RxD
// Initializare USART
TXSTAbits.SYNC = 0; // Mod asincron
TXSTAbits.BRGH = 1; // High speed
SPBRG = DIVIDER; // Valoare divizor pentru BRG16=0
RCSTAbits.SPEN = 1; // Activeaza USART
RCSTAbits.RX9 = 0; // Receptie pe 8 biti
RCSTAbits.CREN = 1; // Activeaza receptia
TXSTAbits.TX9 = 0; // Transmisie pe 8 biti
TXSTAbits.TXEN = 1; // Activeaza transmisia
PIR1bits.RCIF = 0; // Sterge semafor intrerupere
PIE1bits.RCIE = 0; // Dezactiveaza intrerupere receptie
putrs("\r\nLectia 6");
putrs("\r\nCLIP V1.0");
putrs("\r\n>"); // Afiseaza prompter-ul
// Initializare variabile
BKL = 0; // Stinge backlight
while(1)
{
GetCmd(); // Citeste o linie de comanda
ProcCmd(); // Proceseaza comanda
if(CMDFlag) // Test comanda valida
ExecCmd(); // Executa comanda
putrs("\r\n>"); // Afiseaza prompter-ul
}//end while
}//end main
/***********************************************
Comenzi CLIP
***********************************************/
/***********************************************
Comanda B
Control backlight
Format comanda:
B - afiseaza stare backlight
B 0 - stinge backlight
B 1 - aprinde backlight
***********************************************/
void B_Cmd(void)
{
if(NPar) // Test comanda cu parametru
{
if(Par) // Test valoare parametru
BKL = 1; // Aprinde backlight
else
BKL = 0; // Stinge backlight
}//end if NPar
putrs("\r\nBacklight "); // Afisesza stare backlight
if(BKL)
putrs("on");

else
putrs("off");
}//end B_Cmd
/***********************************************
Comanda H
Afiseaza comenzile disponibile
Format comanda:
? sau
H sau
h
***********************************************/
void H_Cmd(void)
{
putrs("\r\nComenzi disponibile:");
putrs("\r\nB - Backlight");
putrs("\r\nH - Help");
putrs("\r\nZ - Conversie zecimal");
}//end H_Cmd
/***********************************************
Comanda Z
Conversie ASCII Hex in zecimal
Format comanda:
Z v
v valoare de convertit in zecimal
NOTA:
Se retin doar ultimele doua caractere ASCII Hex introduse
***********************************************/
void Z_Cmd(void)
{
if(NPar == 0)
return;
putrs("\r\nPar=0x");
putb(Par & 0xFF); // Retine doar ultimul octet
putc('=');
putbnlz(Par & 0xFF); // Afisesza in zecimal
}
//end Z_Cmd
// comanda C Afiseaza un mesaj pe ecran
void C_Cmd(void)
{
if(Par='C')
putrs("\r\nazi iau examenul");
}//end C_Cmd
/***********************************************
Functii CLIP
***********************************************/
/***********************************************
Function: void ExecCmd(void)
Executa comanda
Intrare: Ch - cod comanda
NPar - numar parametri
Par - valoare parametru
***********************************************/
void ExecCmd(void)
{
switch(Ch) // Selectie comanda
{

case 'B':
case 'b':
B_Cmd(); // Executa comanda B_Cmd
break;
case '?':
case 'H':
case 'h':
H_Cmd(); // Executa comanda H_Cmd
break;
case 'Z':
case 'z':
Z_Cmd(); // Executa comanda Z_Cmd
break;
case 'C':
case 'c':
C_Cmd();
break;
}//end switch Ch
}//end ExecCmd
/***********************************************
Function: void ProcCmd(void)
Interpreteaza linia de comanda
Intrare: CBuf[] - linia de comanda
CmdLen - lungime comanda
Iesire: CMDFlag = 1 - comanda valida
Ch - cod comanda (0x3F..0x7F, ASCII "?".."~"
NPar - numar parametri
Par - valoare parametru (daca NPar=1)
***********************************************/
void ProcCmd(void)
{
unsigned char i;
char ch;
CMDFlag = 0;
NPar = 0;
Par = 0x0;
if(CmdLen == 0) // Test lungime comanda
return;
// Extrage cod comanda
i = 0x0;
ch = CBuf[i++]; // Citeste caracter din buffer
if((ch < 0x3F) || (ch > 0x7F)) // Test cod comanda valid
{
// Comanda invalida
return;
}
else
{
// Comanda valida ("?".."~")
Ch = ch; // Salveaza cod comanda
CMDFlag = 1; // Semnaleaza comanda valida
}//end if
// Ignora eventualele spatii dintre comanda si parametru
while(CBuf[i] == 0x20) i++;
// Extrage parametrul comenzii
if(ishex(CBuf[i])) // Test daca primul caracter este ASCII Hex
NPar++; // Semnaleaza 1 parametru

else
return; // Semnaleaza comanda fara parametru
while(ishex(CBuf[i]))
{
Par = (Par << 4) + Asc2Hex(CBuf[i]); // Conversie Par in binar
i++;
}
}//end ProcCmd
/***********************************************
Function: void GetCmd(void)
Citeste o linie de comanda
Iesire: CBuf[] - linia de comanda
CmdLen - lungime comanda
***********************************************/
void GetCmd(void)
{
unsigned char i, ch;
for(i = 0; i < BUF_LEN; i++)
CBuf[i] = 0x0; // Initializeaza buffer
i = 0; // Initializeaza index in buffer
while(1)
{
ch = getc(); // Citeste un caracter
if(ch == ESC)
{
BKL = 0; // Stinge backlight
Reset(); // RESET la ESC
}//end if ch=ESC
if(ch == CR)
{
CmdLen = i; // Salveaza lungime comanda
return;
}//end if ch=CR
if((ch > 0x1F) && (ch < 0x80)) // Accepta numai caracterele 0x20..0x7F
{
CBuf[i++] = ch; // Salveaza caracterul in buffer
putc(ch); // Ecou caracter
}//end if
}//end while
}//end GetCmd
/***********************************************
Functii utilizator
***********************************************/
/***********************************************
Function: void putc(unsigned char ch)
Transmite octet pe USART
Intrare: ch = valoare octet de transmis
***********************************************/
void putc(unsigned char ch)
{
while(!PIR1bits.TXIF) continue; // Asteapta terminarea transmisiei
TXREG = ch; // Incarca octetul in TXREG
}//end putc
/***********************************************
Function: void putrs(const char *data)
Transmite sir de caractere pe USART
Intrare: data sir din ROM terminat cu 0x0

***********************************************/
void putrs(const rom char *data)
{
while(*data) putc(*data++);
}//end putrs
/***********************************************
Function: unsigned char getc(void)
Citeste octet de pe USART
Iesire: octetul receptionat
***********************************************/
unsigned char getc(void)
{
while(!PIR1bits.RCIF) continue; // Asteapta receptia unui caracter
return RCREG; // Intoarce valoarea din RCREG
}//end getc
/***********************************************
Function: char Hex2Asc(char ch)
Conversie din format intern in ASCII Hex
Intrare: ch=0x0..0xF
Iesire: Hex2Asc='0'..'9', 'A'..'F'
***********************************************/
char Hex2Asc(char ch)
{
ch = (ch & 0xF); // Retine quartetul inferior
if(ch < 10)
return (ch + '0'); // Conversie in ASCII Hex '0'..'9'
else
return ((ch - 10) + 'A'); // Conversie in ASCII Hex 'A'..'F'
}//end Hex2Asc
/***********************************************
Function: void putb(unsigned char aByte)
Afiseaza octet in ASCII Hex
***********************************************/
void putb(unsigned char aByte)
{
putc(Hex2Asc((aByte >> 4) & 0xF)); // Afiseaza prima cifra ASCII Hex
putc(Hex2Asc(aByte & 0xF)); // Afiseaza a doua cifra ASCII Hex
}//end putb
/***********************************************
Function: void putbnlz(unsigned char aByte)
Afiseaza octet in zecimal fara cifrele nesemnificative
***********************************************/
void putbnlz(unsigned char aByte)
{
if(aByte / 100)
{
putc((aByte / 100) + 0x30); // Afiseaza cifra sutelor
putc(((aByte % 100) / 10) + 0x30); // Afiseaza cifra zecilor
}
else
{
if((aByte % 100) / 10)
{
putc(((aByte % 100) / 10) + 0x30); // Afiseaza cifra zecilor
}// end if
}//end if
putc((aByte % 10) + 0x30); // Afiseaza cifra unitatilor

}//end putbnlz
/***********************************************
Function: unsigned char isdec(unsigned char ch)
Verifica daca ch este cifra ('0'..'9')
Intrare: ch=caracter
Iesire: ishex=1 - ch este cifra
ishex=0 - ch nu este cifra
***********************************************/
unsigned char isdec(unsigned char ch)
{
if((ch >= '0') && (ch <= '9')) return ( 1 );
return ( 0 );
}//end isdec
/***********************************************
Function: unsigned char ishex(unsigned char ch)
Verifica daca ch este cifra hexa ('0'..'9', 'a'..'f' sau 'A'..'F')
Intrare: ch=caracter
Iesire: ishex=1 - ch este cifra hexa
ishex=0 - ch nu este cifra hexa
***********************************************/
unsigned char ishex(unsigned char ch)
{
if((ch >= '0') && (ch <= '9')) return ( 1 );
if((ch >= 'a') && (ch <= 'f')) return ( 1 );
if((ch >= 'A') && (ch <= 'F')) return ( 1 );
return ( 0 );
}//end ishex
/***********************************************
Function: unsigned char Asc2Hex(char ch)
Conversie din ASCII Hex in binar
Intrare: ch='0'..'9', 'A'..'F'
Iesire: Asc2Hex=0x0..0xF
***********************************************/
unsigned char Asc2Hex(char ch)
{
if (!ishex(ch)) return 0;
if (isdec(ch)) return (ch - '0');
if ((ch >= 'a') && (ch <= 'f')) return (ch - 0x27 - '0');
if ((ch >= 'A') && (ch <= 'F')) return (ch - 0x7 - '0');
return ( 0 );
}//end Asc2Hex
/***********************************************
End Of File main.c
***********************************************/