28 #define EDFA_TIMEOUT_MS 2000
30 #define FULL_CMD_MAX_LENGTH 30
34 static char _retEdfaCmdBuf[EDFA_MAX_RET_LEN];
40 static char _cmdBuf[20];
41 static char status[20]=
"sta: 000000000\r";
44 char * strstr(
const char *in,
const char *str);
45 char * strcat(
char *s,
const char *append);
47 static int _EdfaCursor = 0;
52 int atoi_mult(
const char* s,
int decimals,
bool trunc_nRound);
60 if(
bfEmpty(EDFA_UART->rxfifo))
return false;
63 bfRead(EDFA_UART->rxfifo,(uint8_t*) c);
66 printf(
"rx -> %c\n",*c);
78 printf(
"tx -> %c\n",c);
85 void _edfaputs (
const char *
string)
91 while(*
string !=
'\0')
98 while(*
string !=
'\0' && i < 20){
103 if(i < 20)_cmdBuf[i] =
'\0';
111 bool _edfaRxCommand()
121 if (c >=
' ' && c <=
'~' && _EdfaCursor < (EDFA_MAX_RET_LEN - 1) )
123 _retEdfaCmdBuf[_EdfaCursor++] = c;
128 _retEdfaCmdBuf[_EdfaCursor] =
'\0';
129 if (_EdfaCursor > 0){
143 if(strstr(_cmdBuf,
"sta"))strcpy(_retEdfaCmdBuf,status);
144 else if(strstr(_cmdBuf,
"emon")){
145 strcpy(_retEdfaCmdBuf,
"EMON\0");
146 strcpy(status,
"STA:100696068\0");
149 else if(strstr(_cmdBuf,
"emoff")){
150 strcpy(_retEdfaCmdBuf,
" EMOFF\0");
151 strcpy(status,
"STA:000000000\0");
154 else if(strstr(_cmdBuf,
"rop")){
155 strcpy(_retEdfaCmdBuf,
" rop: 6.1\0");
157 else if(strstr(_cmdBuf,
"rip")){
158 strcpy(_retEdfaCmdBuf,
" rip:-2.0345\0");
160 else if(strstr(_cmdBuf,
"rdc1")){
161 strcpy(_retEdfaCmdBuf,
"rdc1:2184\0");
163 else if(strstr(_cmdBuf,
"rct")){
164 strcpy(_retEdfaCmdBuf,
"rct:28.9\0");
166 else if(strstr(_cmdBuf,
"apc")){
167 if(!bemi)strcpy(_retEdfaCmdBuf,
"apc\0");
168 else strcpy(_retEdfaCmdBuf,
"ERR: Emission is on\0");
170 else if(strstr(_cmdBuf,
"sps")){
171 strcpy(_retEdfaCmdBuf,
"sps:\0");
172 ic = strstr(_cmdBuf,
"sps") - _cmdBuf;
174 strcat(_retEdfaCmdBuf,_cmdBuf+ic);
176 else if(strstr(_cmdBuf,
"rps")){
177 strcpy(_retEdfaCmdBuf,
"rps: 7.30\0");
179 else if(strstr(_cmdBuf,
"rmp")){
180 strcpy(_retEdfaCmdBuf,
"rmp:10.5\0");
183 else if(strstr(_cmdBuf,
"agc")){
184 if(!bemi)strcpy(_retEdfaCmdBuf,
"agc\0");
185 else strcpy(_retEdfaCmdBuf,
"ERR: Emission is on\0");
187 else if(strstr(_cmdBuf,
"sgs")){
188 strcpy(_retEdfaCmdBuf,
"sgs:\0");
189 ic = strstr(_cmdBuf,
"sgs") - _cmdBuf;
191 strcat(_retEdfaCmdBuf,_cmdBuf+ic);
193 else if(strstr(_cmdBuf,
"rgs")){
194 strcpy(_retEdfaCmdBuf,
"rgs: 16.4\0");
196 else if(strstr(_cmdBuf,
"rop")){
197 strcpy(_retEdfaCmdBuf,
"rop:26.1\0");
199 else if(strstr(_cmdBuf,
"rmg")){
200 strcpy(_retEdfaCmdBuf,
"rmg:32.0\0");
202 else if(strstr(_cmdBuf,
"rng")){
203 strcpy(_retEdfaCmdBuf,
"rng:10.4\0");
206 else if(strstr(_cmdBuf,
"rmt")){
207 strcpy(_retEdfaCmdBuf,
"rmt:73.0\0");
209 else if(strstr(_cmdBuf,
"rmc")){
210 strcpy(_retEdfaCmdBuf,
"rmc:2500\0");
212 else if(strstr(_cmdBuf,
"rpn")){
213 strcpy(_retEdfaCmdBuf,
"RPN: P60-000280\0");
215 else if(strstr(_cmdBuf,
"rfv")){
216 strcpy(_retEdfaCmdBuf,
"RFV: 1.0.114\0");
218 else if(strstr(_cmdBuf,
"rdate")){
219 strcpy(_retEdfaCmdBuf,
"RDATE: MAY 12, 2009\0");
221 else if(strstr(_cmdBuf,
"rsn")){
222 strcpy(_retEdfaCmdBuf,
"RSN: FA100625\0");
224 else strcpy(_retEdfaCmdBuf,
"BCMD\0");
234 void stolower(
char *s)
237 if((
'A' <= *s) && (*s <=
'Z'))
238 *s =
'a' + (*s -
'A');
247 bool _checkEdfaRet(
const char* cmd ,
bool hasRet,
char **ptrRet)
250 size_t len = strlen(cmd);
251 stolower(_retEdfaCmdBuf);
254 if( strstr(_retEdfaCmdBuf,
"bcmd")){
259 rt = strstr(_retEdfaCmdBuf,cmd);
262 rt = strstr(_retEdfaCmdBuf,
"err");
273 if(*(rt+len) !=
':'){
293 bool edfaCmd(
const char* cmd,
bool hasRet,
char** ret)
296 if(!_edfaRxCommand())
return false;
297 return _checkEdfaRet(cmd ,hasRet,ret);
304 bool edfaCmdArg(
const char* cmd,
const char* arg,
bool hasRet,
char** ret)
306 char fullcmd[FULL_CMD_MAX_LENGTH];
307 size_t lencmd = strlen(cmd);
308 size_t lenarg = strlen(arg);
309 if(lencmd + lenarg + 1 >= FULL_CMD_MAX_LENGTH){
314 strcpy (fullcmd,cmd);
315 strcat (fullcmd,
" ");
316 strcat (fullcmd, arg);
319 if(!_edfaRxCommand())
return false;
320 return _checkEdfaRet(cmd ,hasRet,ret);
325 bool edfaReadStatus(
bool* emission,
bool* startup)
331 if(!edfaCmd(
"sta",
true,&rtString))
return false;
332 while(rtString[ilast] !=
'\0'){ilast++;}
334 while(rtString[ilast] !=
' ' && rtString[ilast] !=
':'){
336 if(rtString[ilast] >=
'0' && rtString[ilast] <=
'9') istatus += (rtString[ilast]-
'0') * tens;
340 *emission = ((istatus >> 2) & 0x1) == 0x1 ?
true:
false;
341 *startup = ((istatus >> 7) & 0x1) == 0x1 ?
true:
false;;
347 return edfaCmd(
"emon",
false,NULL);
352 return edfaCmd(
"emoff",
false,NULL);
356 bool edfaReadCompOutPw(
char** retString)
358 return edfaCmd(
"rop",
true,retString);
361 bool edfaReadCompInPw(
char** retString)
363 return edfaCmd(
"rip",
true,retString);
366 bool edfaReadPumpDiodeCur(
char** retString)
368 return edfaCmd(
"rdc",
true,retString);
371 bool edfaReadTemp(
char** retString)
373 return edfaCmd(
"rct",
true,retString);
376 bool edfaSetAPCMode(
char** retString)
378 return edfaCmd(
"apc",
false,retString);
381 bool edfaSetCompOutPw(
const char* s_dbm,
char** retString)
385 return edfaCmdArg(
"sps",s_dbm,
true,retString);
388 bool edfaReadCompPwSet(
char** retString)
390 return edfaCmd(
"rps",
true,retString);
393 bool edfaReadMaxCompOutPw(
char** retString)
395 return edfaCmd(
"rmp",
true,retString);
399 bool edfaSetAGCMode(
char** retString)
401 return edfaCmd(
"agc",
false,retString);
404 bool edfaSetGainSet(
const char* s_db,
char** retString)
407 return edfaCmdArg(
"sgs",s_db,
true,retString);
410 bool edfaReadGainSet(
char** retString)
412 return edfaCmd(
"rgs",
true,retString);
415 bool edfaReadActGain(
char** retString)
417 return edfaCmd(
"rop",
true,retString);
420 bool edfaReadMaxGain(
char** retString)
422 return edfaCmd(
"rmg",
true,retString);
424 bool edfaReadMinGain(
char** retString)
426 return edfaCmd(
"rng",
true,retString);
430 bool edfaReadMaxTemp(
char** retString)
432 return edfaCmd(
"rmt",
true,retString);
435 bool edfaReadMaxPumpDiodeCur(
char** retString)
437 return edfaCmd(
"rmc",
true,retString);
439 bool edfaReadPart(
char** retString)
441 return edfaCmd(
"rpn",
true,retString);
444 bool edfaReadFwVer(
char** retString)
446 return edfaCmd(
"rfv",
true,retString);
449 bool edfaReadDate(
char** retString)
451 return edfaCmd(
"rdate",
true,retString);
454 bool edfaReadSerial(
char** retString)
456 return edfaCmd(
"rsn",
true,retString);
489 static int quick_pow10(
int n)
491 static int pow10[10] = {
492 1, 10, 100, 1000, 10000,
493 100000, 1000000, 10000000, 100000000, 1000000000
499 int atoi_mult(
const char* s,
int decimals,
bool trunc_nRound){
501 assert(decimals+1 < 10);
502 int left = 0, right = 0, sign =1, digit = 0;
503 while(*s ==
' '){s++;}
508 for (
int point_seen = 0; *s; s++){
514 if (d >= 0 && d <= 9){
517 right = right*10 + d;
518 if(!trunc_nRound && digit > decimals){
526 if(digit == decimals && trunc_nRound)
break;
529 return sign * left * quick_pow10(decimals) + sign * right * quick_pow10(decimals - digit);
548 int edfaOutputPower()
551 if(!edfaReadCompOutPw(&pRet)){
555 return atoi_mult(pRet,3,
true);
562 if(!edfaReadCompInPw(&pRet)){
566 return atoi_mult(pRet,3,
true);
570 int edfaReadSetpoint()
573 if(!edfaReadCompPwSet(&pRet)){
577 return atoi_mult(pRet,3,
true);
584 if(!edfaReadPumpDiodeCur(&pRet)){
588 return atoi_mult(pRet,3,
true);
596 if(!edfaReadTemp(&pRet)){
600 return atoi_mult(pRet,3,
true);
604 void edfaWriteSetpoint(
f32_t val,
char** retString)
610 int integer,mantissa;
616 ||
cnvFormatU(mantissa , c_mantissa,_int) == 0){
620 strcat(c_integer,
".");
621 strcat(c_integer,c_mantissa);
623 edfaSetCompOutPw(c_integer, retString);
628 return edfaCmd(cmd,
true, retString);
632 return edfaCmd(cmd,
false, NULL);
#define E_EDFA_TOOLONG
command parameter too long
int cnvFormatU(int32_t input, char *output, CnvParams params)
Formats an unsigned integer into a character buffer.
static bool bfEmpty(ByteFifo *const bf)
Returns whether or not the byte-fifo is empty.
#define E_EDFA_NOCOMMA
no comma when required in response
static void __irqEnable()
Enabled IRQ's on a global level.
int32_t fltInt(f32_t value)
Returns the integer part of the floating point value.
#define E_EDFA_INVALID
invalid
int cnvFormatI(int32_t input, char *output, CnvParams params)
Formats a signed integer into a character buffer.
#define E_EDFA_TIMEOUT
Receive timeout.
uint32_t fltFrac(f32_t value, int decimals)
Returns the fractional part of the floating point with the specified number of decimals.
static void __irqDisable()
Disables IRQ's on a global level.
#define E_EDFA_BDCM
bd command
Special library for primitive IEEE 754 floating point handling without dragging all float support alo...
#define CNV_DEFAULT
Default conversion/formatting parameters (base 10).
static uint32_t timeOutInit(uint32_t msec)
Initializes a timeout with the specified no of msecs.
static bool timeOut(uint32_t to)
Checks whether or not the timeout has expired.
Manages the global system error.
This structure provides information about formatting and parsing.
uint32_t f32_t
32 bit representation for float.
#define E_EDFA_NOCMD
no echoed command back
bool bfRead(ByteFifo *const bf, uint8_t *const b)
Reads a byte from the byte-fifo.
bool errSet(uint32_t code, const char *error, const char *name)
Sets an error.
#define ERROR(CODE,...)
Expands an error code to an error code with a description (if ERROR_W_DESCR is declared).
bool suartTx(SUART_Descriptor *desc, char c)
Transmits a character.
EDFA-EAU (30-C3-20-C) Uart driver.
bool edfaDbgCmdReply(const char *cmd, char **retString)
Execute an EDFA debug command, and returns the reply.
This module implements parsing and formating of strings and integers.
bool edfaDbgCmd(const char *cmd)
Execute an EDFA debug command w/o a reply.