/******************************************************************************
* baseTSK
*/
void baseTSK(void *pPrm){
portTickType xLastWakeTime;
uint32_t i = 0, j = 0;
uint16_t IdleCount; //Счетчик простоя, нужен для вызова заставки
uint8_t varParam = 0;
uint8_t fvarParamNew = 1;
uint8_t stHig, stDiv = 1;
xLastWakeTime = xTaskGetTickCount(); //Инициализируем xLastWakeTime текущим временем
IdleCount = 0;
uiGraphicsColor = black;
uiTextColor = R;
IdleCount = 0;
lcd_Clear();
if(ps.state.bit.scopeRun == 1){
ps.state.bit.scopeRun = 0;
}
//Печать статических символов
lcd_PutChar8x12(90,10,'V');
lcd_PutChar8x12(90,32,'A');
lcd_PutString8x12(12,45,"Imax=");
uiTextColor = B;
grf_line(0, 69, 100, 69, 1);
uiTextColor = RGB;
lcd_gotoxy(41,39,43,43);
for(j = 0; j < 9; j++){
lcd_data(uiTextColor); //точка
}
//Настройка клавиатуры
kc.AutoPress = AutoPressON;
kc.scanningToFirstRewind = 15;
kc.scanningToRewind = 1;
BeepTime(300);
while(1){
/**************************************
* Обработка кнопок
*/
if(BtScan() != 0){
BeepTime(T_BEEP_PRESS_KEY);
IdleCount = 0;
}
if(ks.NEXT){
varParam++;
fvarParamNew = 1;
if(varParam >= 3) varParam = 0;
}
if(ks.BMDVW){
if(ps.state.bit.switchIsON == 0){
selWindow(chargerWindow); //Удаляем текущую задачу
}else{
selWindow(scopeWindow);
}
}
if(ks.SET){ //Переключаем набор параметров
if(ps.state.bit.switchIsON == 0){ //Если выключен выход
bs.crst++;
if(bs.crst > 4){
bs.crst = 0;
}
if(varParam == VAR_VOLT){
enco.pval = &bs.set[bs.crst].u;
}
if(varParam == VAR_CURR){
enco.pval = &bs.set[bs.crst].i;
}
if(varParam == VAR_MODE){
enco.pval = &bs.set[bs.crst].Mode;
}
}else{ //Если включен выход
BeepTime(T_BEEP_ERROR);
}
}
if(ks.SWITCH){
if(ps.state.bit.switchIsON == 0){
ps.task.switchRequest = switchOnRequest;
}else{
ps.task.switchRequest = switchOffRequest;
}
}
if(ks.UP){
enBigStepUp();
}
if(ks.DOWN){
enBigStepDown();
}
if(ks.ZERO){
enWriteVal(0); //Обнуляем
}
/**************************************
* Настройка клавиатуры, настройка энкодера
*/
if(fvarParamNew != 0){
if(varParam == VAR_VOLT){
kc.AutoPress = AutoPressON; //Разрешить автонажатие
kc.scanningToRewind = 5; //Колличество сканирований до повторного срабатывания
enSet(0, MAX_VAL_U, 6, U_BIG_STEP,
enNONCIRC, enU16, &bs.set[bs.crst].u);
}
if(varParam == VAR_CURR){
kc.AutoPress = AutoPressON;
kc.scanningToRewind = 5;
enSet(0, MAX_VAL_I, 2, I_BIG_STEP,
enNONCIRC, enU16, &bs.set[bs.crst].i);
}
if(varParam == VAR_MODE){
kc.AutoPress = AutoPressOFF;
enSet(0, 2, 1, 1,
enCIRC, enU16, &bs.set[bs.crst].Mode);
}
}
//Вынимаем значение с энкодера
enGet();
/***************************************
* Задание БП
*/
ps.task.voltage = bs.set[bs.crst].u;
switch(bs.set[bs.crst].Mode){
case(baseImax):{
ps.task.mode = mode_overcurrentShutdown;
ps.task.current = bs.set[bs.crst].i;
}break;
case(baseILimitation):{
ps.task.mode = mode_limitation;
ps.task.current = bs.set[bs.crst].i;
}break;
case(baseUnprotected):{
ps.task.mode = mode_limitation;
ps.task.current = I_SHORT_CIRCUIT;
}break;
}
if(ps.task.control != localControl){
ps.task.switchRequest = switchOffRequest;
lcd_PrintImage((void*)connImg); //Заставка
nvMem_savePrm(nvMem.nvMemBase);
BeepTime(300);
vTaskDelete(NULL);
}
//Запуск заставки
if(ps.state.bit.switchIsON != 0){
IdleCount = 0;
}
else IdleCount++;
if(IdleCount >= IDLE_TIME){
retEf = 1;
xTaskCreate(cube3dTSK,"cube3dTSK", CUBE_TSK_SZ_STACK, NULL, 2, NULL);
vTaskDelete(NULL); //Удаляем текущую задачу
}
/**************************************
* Вывод на дисплей
*/
//Печать курсора
if(fvarParamNew !=0){
uiTextColor = G;
if(varParam == VAR_VOLT){
lcd_PutChar8x12(2,56, ' '); //Удаляем старый курсор
lcd_PutChar8x12(2,5, '\x82'); //Рисуем новый курсор
}
if(varParam == VAR_CURR){
lcd_PutChar8x12(2,5, ' ');
lcd_PutChar8x12(2,45, '\x82');
}
if(varParam == VAR_MODE){
lcd_PutChar8x12(2,45, ' ');
lcd_PutChar8x12(2,56, '\x82');
}
fvarParamNew = 0;
}
//Печать значения напряжения
uiTextColor = RGB;
if(ps.state.bit.switchIsON !=0){
sprintf(str, "%05u", ps.meas.voltage);
}else{
sprintf(str, "%05u", ps.task.voltage);
}
lcd_PutChar14x19(12, 2, str[0]);
lcd_PutChar14x19(26, 2, str[1]);
lcd_gotoxy(41, 17, 43, 21);
for(j = 0; j < 9; j++){
lcd_data(uiTextColor);
}
lcd_PutChar14x19(44, 2, str[2]);
lcd_PutChar14x19(58, 2, str[3]);
lcd_PutChar14x19(72, 2, str[4]);
//Печать значения тока
if(ps.state.bit.switchIsON !=0){
sprintf(str, "%04u", ps.meas.current);
lcd_PutChar14x19(26, 24, str[0]);
lcd_PutChar14x19(44, 24, str[1]);
lcd_PutChar14x19(58, 24, str[2]);
lcd_PutChar14x19(72, 24, str[3]);
}else{ //Если выключено
lcd_PutChar14x19(26, 24, '-');
lcd_PutChar14x19(44, 24, '-');
lcd_PutChar14x19(58, 24, '-');
lcd_PutChar14x19(72, 24, '-');
}
//Псевтоаналоговая шкала
if(ps.state.bit.switchIsON !=0){
i = adcStct.adcreg[CH_IADC] - sysset.pI[0].adc;
stHig = i / stDiv;
while(stHig > DISP_H){
stDiv = stDiv * 2;
stHig = i / stDiv;
}
while((stHig <= DISP_H / 2 - 10)&&(i > DISP_H / 2)){ //-10 гистерезис
stDiv = stDiv / 2;
if(stDiv == 0){
stDiv = 1;
break;
}
stHig = i / stDiv;
}
if(stHig > DISP_H) stHig = DISP_H;
lcd_gotoxy(100, 0, 100, 79);
for(j = 0; j < 80 - stHig; j++)
lcd_data(uiGraphicsColor);
for(j = 0; j < stHig; j++)
lcd_data(uiTextColor);
}else{ //Если выключено
lcd_gotoxy(100, 0, 100, 79);
for(j = 0; j < 80; j++){
lcd_data(uiGraphicsColor);
}
}
//Печать символа ограничения
uiTextColor = G;
if(ps.state.bit.modeIlim == 1){
lcd_PutChar14x19(12,24,'\x2E');
}else{
lcd_PutChar14x19(12,24,'\x2F'); //печать символа ограничения
}
//Печать текущий набор настроек
uiTextColor = RGB;
lcd_PutChar8x12(3, 28, bs.crst + '\x30' + 1); //Режимы от 0 до 4 показываем от 1 до 5
//Печать значения Imax
sprintf(str, "%04u", bs.set[bs.crst].i); //Печатаем удвоенное значение, т.к. единице оотвествует 2mA
uiTextColor = R;
lcd_PutChar8x12(58, 45, str[0]);
lcd_PutChar8x12(66, 45, '.');
lcd_PutChar8x12(74, 45, str[1]);
lcd_PutChar8x12(82, 45, str[2]);
lcd_PutChar8x12(90, 45, str[3]);
//Печать режима по току
uiTextColor = GB;
if(bs.set[bs.crst].Mode == baseImax){
lcd_PutString8x12(12, 56, "I max ");
}
if(bs.set[bs.crst].Mode == baseILimitation){
lcd_PutString8x12(12, 56, "Limitation ");
}
if(bs.set[bs.crst].Mode == baseUnprotected){
lcd_PutString8x12(12, 56, "UNPROTECTED");
}
printStatusBar();
/*************************************/
vTaskDelayUntil(&xLastWakeTime, BASE_TSK_PERIOD); //Запускать задачу каждые 30ms
}
}
void Connection::socketData() {
int toRead;
int bytesRead=0;
int thisRead=0;
int version;
int subversion;
int header_size=0;
int answer_size=0;
char* ans;
QString answer;
if (bytes < 0) {
//fprintf(stderr,"QtRadio: FATAL: INVALID byte counter: %d\n", bytes);
//tcpSocket->close();
return;
}
toRead=tcpSocket->bytesAvailable();
if (toRead <= 0) {
return;
}
while(bytesRead<toRead) {
//fprintf (stderr, "%d of %d [%d]\n", bytesRead, toRead, state);
switch(state) {
case READ_HEADER_TYPE:
thisRead=tcpSocket->read(&hdr[bytes],3 - bytes);
if (thisRead < 0) {
fprintf(stderr,"QtRadio: FATAL: READ_AUDIO_HEADER: error in read: %d\n", thisRead);
tcpSocket->close();
return;
}
bytes+=thisRead;
if (bytes == 3){
switch(hdr[0]) {
case AUDIO_BUFFER:
state=READ_AUDIO_HEADER;
break;
case SPECTRUM_BUFFER:
version=hdr[1];
subversion=hdr[2];
switch(version) {
case 2:
switch(subversion) {
case 0:
header_size=HEADER_SIZE_2_0;
break;
case 1:
header_size=HEADER_SIZE_2_1;
break;
default:
fprintf(stderr,"QtRadio: Invalid subversion. Expected %d.%d got %d.%d\n",HEADER_VERSION,HEADER_SUBVERSION,version,subversion);
break;
}
break;
default:
fprintf(stderr,"QtRadio: Invalid version. Expected %d.%d got %d.%d\n",HEADER_VERSION,HEADER_SUBVERSION,version,subversion);
break;
}
state=READ_HEADER;
break;
case BANDSCOPE_BUFFER:
break;
case RTP_REPLY_BUFFER:
state=READ_RTP_REPLY;
break;
case 52: //ANSWER_BUFFER
// answer size is in hdr pos 1 & 2 max 99
state = READ_ANSWER;
bytes = 0;
answer_size = atoi(hdr) - 400 ; // 1st digt is buffer type 4
ans = (char*)malloc(answer_size +1);
break;
}
}
break;
case READ_AUDIO_HEADER:
//fprintf (stderr, "READ_AUDIO_HEADER: hdr size: %d bytes: %d\n", AUDIO_HEADER_SIZE, bytes);
thisRead=tcpSocket->read(&hdr[bytes],AUDIO_HEADER_SIZE - bytes);
if (thisRead < 0) {
fprintf(stderr,"QtRadio: FATAL: READ_AUDIO_HEADER: error in read: %d\n", thisRead);
tcpSocket->close();
return;
}
bytes+=thisRead;
if (bytes == AUDIO_HEADER_SIZE){
// g0orx binary header
//length = atoi(&hdr[AUDIO_LENGTH_POSITION]);
length=((hdr[3]&0xFF)<<8)+(hdr[4]&0xFF);
buffer = (char*)malloc(length);
bytes = 0;
state = READ_BUFFER;
}
break;
case READ_HEADER:
//fprintf (stderr, "READ_HEADER: hdr size: %d bytes: %d\n", header_size, bytes);
thisRead=tcpSocket->read(&hdr[bytes],header_size - bytes);
if (thisRead < 0) {
fprintf(stderr,"QtRadio: FATAL: READ_HEADER: error in read: %d\n", thisRead);
tcpSocket->close();
return;
}
bytes+=thisRead;
if(bytes==header_size) {
// g0orx binary header
length=((hdr[3]&0xFF)<<8)+(hdr[4]&0xFF);
if ((length < 0) || (length > 4096)){
state = READ_HEADER_TYPE;
}
else {
buffer=(char*)malloc(length);
bytes=0;
state=READ_BUFFER;
}
}
break;
case READ_BUFFER:
//fprintf (stderr, "READ_BUFFER: length: %d bytes: %d\n", length, bytes);
thisRead=tcpSocket->read(&buffer[bytes],length-bytes);
if (thisRead < 0) {
fprintf(stderr,"QtRadio: FATAL: READ_BUFFER: error in read: %d\n", thisRead);
tcpSocket->close();
return;
}
bytes+=thisRead;
//qDebug() << "READ_BUFFER: read " << bytes << " of " << length;
if(bytes==length) {
version=hdr[1];
subversion=hdr[2];
queue.enqueue(new Buffer(hdr,buffer));
QTimer::singleShot(0,this,SLOT(processBuffer()));
hdr=(char*)malloc(HEADER_SIZE_2_1);
bytes=0;
state=READ_HEADER_TYPE;
}
break;
case READ_RTP_REPLY:
thisRead=tcpSocket->read(&hdr[bytes],7-bytes); // length and port
bytes+=thisRead;
if(bytes==7) {
/*
int port;
port=((hdr[5]&0xFF)<<8) + (hdr[6]&0xFF);
// configure this ends rtp so we can send to remote
qDebug() << "Connection emit remoteRTP "<<host<<":"<<port;
emit remoteRTP((char*)host.toUtf8().constData(),port);
*/
bytes=0;
state=READ_HEADER_TYPE;
}
break;
case READ_ANSWER:
//qDebug() << "Connection READ ANSWER";
thisRead=tcpSocket->read(&ans[bytes],answer_size - bytes);
if (thisRead < 0) {
fprintf(stderr,"QtRadio: FATAL: READ_BUFFER: error in read: %d\n", thisRead);
tcpSocket->close();
return;
}
bytes+=thisRead;
if(bytes==answer_size) {
//fprintf(stderr,"ans length = %lu\n",strlen(ans));
ans[answer_size] = '\0';
answer = ans;
QRegExp rx;
if(answer.contains("q-version")){
//"20120107;-rxtx-rtp"; YYYYMMDD; text desc
rx.setPattern(":(\\d+);-(\\S+)");
rx.indexIn(answer);
#if QT_VERSION >= 0x050000
emit setdspversion(rx.cap(1).toLong(),rx.cap(2).toUtf8());
#else
emit setdspversion(rx.cap(1).toLong(),rx.cap(2).toAscii());
#endif
serverver = rx.cap(1).toLong();
if (serverver < 20120201){ // tx login start
emit setCanTX(true); //server to old to tell
}
sendCommand("q-master");
}else if(answer.contains("q-server")){
rx.setPattern("q-server:(\\S+)");
rx.indexIn(answer);
QString servername = rx.cap(1);
emit setservername(servername);
rx.setPattern("([YNP])$"); // Y no checking, N no TX, P depend who and where we are
rx.indexIn(answer);
QString hasTX = rx.cap(1);
if (hasTX.compare("N") == 0){
emit setCanTX(false);
}else if(hasTX.compare("P") == 0){
emit setCanTX(false);
emit setChkTX(true);
}else{ // must be yes
//qDebug() <<"Yes Master";
if (amSlave){
emit setCanTX(false);
emit setChkTX(false);
}else{
emit setCanTX(true);
emit setChkTX(false);
}
}
}else if(answer.contains("q-master")){
//qDebug() << "q-master:" << answer;
if (answer.contains("slave")){
amSlave = true;
emit printStatusBar(" ...Slave Mode. ");
}else{
amSlave = false;
emit printStatusBar(" ...Master Mode. ");
}
}else if(answer.contains("q-rtpport")){
rx.setPattern("rtpport:(\\d+);");
rx.indexIn(answer);
QString p = rx.cap(1);
emit setRemoteRTPPort(host,p.toInt());
}else if(answer.contains("q-cantx:")){
rx.setPattern("([YN])$");
rx.indexIn(answer);
QString TXNow= rx.cap(1);
if (TXNow.compare("Y") == 0){
emit setCanTX(true);
}else{
emit setCanTX(false);
}
}else if(answer.contains("q-loffset:")){
rx.setPattern("q-loffset:(\\d+)\\.");
rx.indexIn(answer);
double loffset= rx.cap(1).toDouble();
emit resetbandedges(loffset);
}else if(answer.contains("q-info")){
rx.setPattern("info:s;(\\d+);f;(\\d+);m;(\\d+);z;(\\d+);l;(\\d+|-\\d+);r;(\\d+|-\\d+)");
rx.indexIn(answer);
QString f = rx.cap(2);
QString m = rx.cap(3);
QString z = rx.cap(4);
QString l = rx.cap(5);
QString r = rx.cap(6);
long long newf = f.toLongLong();
int newmode = m.toInt();
int zoom = z.toInt();
int left = l.toInt();
int right = r.toInt();
emit slaveSetFreq(newf);
emit slaveSetFilter(left, right);
emit slaveSetZoom(zoom);
if(newmode != lastMode){
emit slaveSetMode(newmode);
}
lastFreq = newf;
lastMode = newmode;
} else if (answer.contains("q-protocol3")){
rx.setPattern("([YN])$");
rx.indexIn(answer);
QString protocol3= rx.cap(1);
if (protocol3.compare("Y") == 0){
emit setProtocol3(true);
emit setFPS();
}
} else if (answer[0] == '*') {
qDebug() << "--------------->" << answer;
emit hardware (QString(answer));
}
//answer.prepend(" Question/Answer ");
//emit printStatusBar(answer);
qDebug() << "ANSWER bytes "<< bytes <<" answer "<< ans;
free(ans);
bytes=0;
state=READ_HEADER_TYPE;
}
break;
default:
fprintf (stderr, "FATAL: WRONG STATUS !!!!!\n");
}
bytesRead+=thisRead;
}
}
