char ModBus(char NumByte) { int TempI; //вывод посылки на экран cmRcBuf0[NumByte]=0x00; //обработка посылки if (cmRcBuf0[0]!=0x20) return 0x00; //адрес устройства //ответ не нужен CRC16=GetCRC16(cmRcBuf0,NumByte-2);//подсчет CRC в принятой посылке TempI=(int) (cmRcBuf0[NumByte-1]<<8) + cmRcBuf0[NumByte-2]; if (CRC16!=TempI) return 0x00; //контрольная сумма //ответ не нужен cmTrBuf0[0]=0x20;//адрес устройства //код команды switch(cmRcBuf0[1]) { case 0x03: { //чтение регистров TempI=(int) (cmRcBuf0[2]<<8) + cmRcBuf0[3]; if (TempI!=1) { //првоерка номера регистра, есть только 1 регистр return ErrorMessage(0x02); //данный адрес не может быть обработан } TempI=(int) (cmRcBuf0[4]<<8) + cmRcBuf0[5]; if (TempI!=1) { //проверка кол-ва запрашиваемых регистров, есть только 1 регистр return ErrorMessage(0x02); //данный адрес не может быть обработан } cmTrBuf0[1]=0x03;//команда cmTrBuf0[2]=0x02;//кол-во байт данных cmTrBuf0[3]=0x00;//старший байт TempI=PINB; cmTrBuf0[4]=Low(TempI);//уровни порта F TempI=GetCRC16(cmTrBuf0,5);//подсчет КС посылки cmTrBuf0[5]=Low(TempI); cmTrBuf0[6]=Hi(TempI); return 7; } case 0x06: { //запись в единичный регистр TempI=(int) (cmRcBuf0[2]<<8) + cmRcBuf0[3]; if (TempI!=1) { //првоерка номера регистра, есть только 1 регистр return ErrorMessage(0x02); //данный адрес не может быть обработан } TempI=(int) (cmRcBuf0[4]<<8) + cmRcBuf0[5]; if (TempI>0xFF) { //проверка числа, которое надо записать в порт return ErrorMessage(0x03); //недопустимые данные в запросе } PORTB=Low(TempI); cmTrBuf0[1]=cmRcBuf0[1];//команда cmTrBuf0[2]=cmRcBuf0[2];//адрес cmTrBuf0[3]=cmRcBuf0[3];// cmTrBuf0[4]=cmRcBuf0[4];//данные cmTrBuf0[5]=cmRcBuf0[5];// cmTrBuf0[6]=cmRcBuf0[6];//КС cmTrBuf0[7]=cmRcBuf0[7];// return 8; } default: { return ErrorMessage(0x01); //недопустимая команда } } }//end ModBus()
double HTMLMeterElement::High() const { /** * If the high value is defined, the high value is this value. * Otherwise, the high value is the maximum value. * If the high value is less than the low value, * the high value is the same as the low value. * If the high value is greater than the maximum value, * the high value is the same as the maximum value. */ double max = Max(); const nsAttrValue* attrHigh = mAttrsAndChildren.GetAttr(nsGkAtoms::high); if (!attrHigh || attrHigh->Type() != nsAttrValue::eDoubleValue) { return max; } double high = attrHigh->GetDoubleValue(); if (high >= max) { return max; } return std::max(high, Low()); }
static void __inline__ sccb_start(void) { CFG_WRITE(SIO_D); Low(SIO_D); WAIT_STABLE(); }
static void __inline__ sccb_stop(void) { Low(SIO_C); WAIT_STABLE(); CFG_WRITE(SIO_D); Low(SIO_D); WAIT_CYCLE(); High(SIO_C); WAIT_STABLE(); High(SIO_D); WAIT_CYCLE(); CFG_READ(SIO_D); }
static void dfs(Agraph_t * g, Agnode_t * u, bcstate * stp, Agnode_t * parent) { Agnode_t *v; Agedge_t *e; Agedge_t *ep; Agraph_t *sg; stp->count++; Low(u) = N(u) = stp->count; for (e = agfstedge(g, u); e; e = agnxtedge(g, e, u)) { if ((v = aghead(e)) == u) v = agtail(e); if (v == u) continue; if (N(v) == 0) { push(&stp->stk, e); dfs(g, v, stp, u); Low(u) = min(Low(u), Low(v)); if (Low(v) >= N(u)) { /* u is an articulation point */ Cut(u) = 1; sg = mkBlock(g, stp); do { ep = pop(&stp->stk); agsubnode(sg, aghead(ep), 1); agsubnode(sg, agtail(ep), 1); } while (ep != e); } } else if (parent != v) { Low(u) = min(Low(u), N(v)); if (N(v) < N(u)) push(&stp->stk, e); } } }
//формирование ответа об ошибке char ErrorMessage(char Error) { char TempI; cmTrBuf0[1]=cmRcBuf0[1]+0x80;;//команда с ошибкой cmTrBuf0[2]=Error; TempI=GetCRC16(cmTrBuf0,3);//подсчет КС посылки cmTrBuf0[3]=Low(TempI); cmTrBuf0[4]=Hi(TempI); return 5; }//end ErrorMessage()
char ErrorMessage(char Error){ unsigned int TempI; cmTrBuf1[1]=cmRcBuf1[1]+0x80; cmTrBuf1[2]=Error; TempI=GetCRC16(cmTrBuf1,3); cmTrBuf1[3]=Low(TempI); cmTrBuf1[4]=Hi(TempI); return 5; }//end ErrorMessage()
static void __inline__ sccb_write_byte(u8 data) { int i; CFG_WRITE(SIO_D); WAIT_STABLE(); /* write 8-bits octet. */ for (i=0;i<8;i++) { Low(SIO_C); WAIT_STABLE(); if (data & 0x80) { High(SIO_D); } else { Low(SIO_D); } data = data<<1; WAIT_CYCLE(); High(SIO_C); WAIT_CYCLE(); } /* write byte done, wait the Don't care bit now. */ { Low(SIO_C); High(SIO_D); CFG_READ(SIO_D); WAIT_CYCLE(); High(SIO_C); WAIT_CYCLE(); } }
static u8 __inline__ sccb_read_byte(void) { int i; u8 data; CFG_READ(SIO_D); WAIT_STABLE(); Low(SIO_C); WAIT_CYCLE(); data = 0; for (i=0;i<8;i++) { High(SIO_C); WAIT_STABLE(); data = data<<1; data |= State(SIO_D)?1:0; WAIT_CYCLE(); Low(SIO_C); WAIT_CYCLE(); } /* read byte down, write the NA bit now.*/ { CFG_WRITE(SIO_D); High(SIO_D); WAIT_CYCLE(); High(SIO_C); WAIT_CYCLE(); } return data; }
//настройка UART void StartUART0(void) { UBRRH=Hi(((dXTAL/16)/19200)-1); UBRRL=Low(((dXTAL/16)/19200)-1); UCSRA=0x00; UCSRB=0xD8; UCSRC=0x86; UBRRH=0x00; UBRRL=0x33; EnableReceive0; InitTimer0; StartTimer0; }//end void StartUART0()
nsEventStates HTMLMeterElement::GetOptimumState() const { /* * If the optimum value is in [minimum, low[, * return if the value is in optimal, suboptimal or sub-suboptimal region * * If the optimum value is in [low, high], * return if the value is in optimal or suboptimal region * * If the optimum value is in ]high, maximum], * return if the value is in optimal, suboptimal or sub-suboptimal region */ double value = Value(); double low = Low(); double high = High(); double optimum = Optimum(); if (optimum < low) { if (value < low) { return NS_EVENT_STATE_OPTIMUM; } if (value <= high) { return NS_EVENT_STATE_SUB_OPTIMUM; } return NS_EVENT_STATE_SUB_SUB_OPTIMUM; } if (optimum > high) { if (value > high) { return NS_EVENT_STATE_OPTIMUM; } if (value >= low) { return NS_EVENT_STATE_SUB_OPTIMUM; } return NS_EVENT_STATE_SUB_SUB_OPTIMUM; } // optimum in [low, high] if (value >= low && value <= high) { return NS_EVENT_STATE_OPTIMUM; } return NS_EVENT_STATE_SUB_OPTIMUM; }
static u8 __inline__ sccb_read_byte(void) { int i; u8 data; CFG_READ(SIO_D); WAIT_STABLE(); Low(SIO_C); WAIT_CYCLE(); data = 0; for (i=7;i>=0;i--) { //High(SIO_C); //WAIT_STABLE(); data |= State(SIO_D)<<i; WAIT_CYCLE(); //Low(SIO_C); //WAIT_CYCLE(); } /* read byte down, write the NA bit now.*/ { CFG_WRITE(SIO_D); High(SIO_D); WAIT_CYCLE(); High(SIO_C); WAIT_CYCLE(); } printk("(%d)",data & 0xFF); return (data); }
NS_IMETHODIMP HTMLMeterElement::GetLow(double* aValue) { *aValue = Low(); return NS_OK; }
//обработка принятого сообщения void DataModBus1(unsigned char NumberByte) { if (GetSostPort1() & HardError) //если произошла ошибка приема { Tr_buf_data_uart1[4]=0; Tr_buf_data_uart1[5]=0; ErrorMessage1(0xE1); } else { if ((Rec_buf_data_uart1[0]==0x55)&&(Rec_buf_data_uart1[1]==0xAA)) //проверка байт синхронизации { if (Rec_buf_data_uart1[3]!=NumberByte-5) //сравним принятое количество байт данных с заявленным { Tr_buf_data_uart1[4]=Rec_buf_data_uart1[3]; //заявленное кол-во байт данных Tr_buf_data_uart1[5]=NumberByte-5; //принятое кол-во байт данных ErrorMessage1(0xE3); } else { CRCSum1=GetCRCSum1(Rec_buf_data_uart1,NumberByte-1); if (CRCSum1!=Rec_buf_data_uart1[NumberByte-1]) //прверка принятого CRC { Tr_buf_data_uart1[4]=Rec_buf_data_uart1[NumberByte-1]; //принятая контрольная сумма Tr_buf_data_uart1[5]=CRCSum1; //вычисленная контрольная сумма ErrorMessage1(0xE2); } else { if ((Rec_buf_data_uart1[2]==0x74)||(Rec_buf_data_uart1[2]==0x73)) { if (Rec_buf_data_uart1[2]==0x74){ PassToPC=(ePassword[0]-0x30)*1000+(ePassword[1]-0x30)*100+(ePassword[2]-0x30)*10+(ePassword[3]-0x30); Tr_buf_data_uart1[4]=Hi(PassToPC); Tr_buf_data_uart1[5]=Low(PassToPC); TransDataInf1(0x72, 2); } if (Rec_buf_data_uart1[2]==0x73) { PassToPC=(Rec_buf_data_uart1[4]<<8)+Rec_buf_data_uart1[5]; ePassword[0]=PassToPC/1000+0x30; PassToPC-=(ePassword[0]-0x30)*1000; ePassword[1]=PassToPC/100+0x30; PassToPC-=(ePassword[1]-0x30)*100; ePassword[2]=PassToPC/10+0x30; PassToPC-=(ePassword[2]-0x30)*10; ePassword[3]=PassToPC+0x30; TransDataInf1(0x73, 0); //а теперь запишем пароль в EEPROM eWrite=1; eAddressWrite=0; eMassiveWrite=ePassword; } PCtime=PC_wait; EnableReceive1; } else { for (i_dc1=0; i_dc1<NumberByte; i_dc1++) { Tr_buf_data_uart[i_dc1]=Rec_buf_data_uart1[i_dc1]; Rec_buf_data_uart1[i_dc1]=0x00; } PCbyte=NumberByte; PCready=1; PCtime=PC_wait; } } } } //end if (col.11) else //если адрес не тот, то опять следим за линией { EnableReceive1; } }//end else (col.9) ClearPortError1(); //после начала отправки сообщения очистим регистр приема } //end DataModBus
/* The commutate function uses the High, Low and Float functions to commutate * the motor. The input to the function is the motor state from the hall effect * sensors. Depending on the value of the global variable "direction" the * function sets the motor outputs according to the motor's commutation pattern. * The commutation pattern is derived from the commutation diagram found on p32 * of Maxon's E-Paper Catalog and is shown below. * * Hall Sen 321 | 101 | 001 | 011 | 010 | 110 | 100 | * State | 5 | 1 | 3 | 2 | 6 | 4 | * -------------|-----|-----|-----|-----|-----|-----| * 1 - Red | + | + | 0 | - | - | 0 | * 2 - Black | - | 0 | + | + | 0 | - | * 3 - White | 0 | - | - | 0 | + | + | * * An input of 0 to the commutate function will turn off the motor. */ void commutate(int state){ switch(state){ case 0: Float(1); Float(2); Float(3); break; case 1: if(direction){ High(1); Float(2); Low(3); } else{ Low(1); Float(2); High(3); } break; case 2: if(direction){ Low(1); High(2); Float(3); } else{ High(1); Low(2); Float(3); } break; case 3: if(direction){ Float(1); High(2); Low(3); } else{ Float(1); Low(2); High(3); } break; case 4: if(direction){ Float(1); Low(2); High(3); } else{ Float(1); High(2); Low(3); } break; case 5: if(direction){ High(1); Low(2); Float(3); } else{ Low(1); High(2); Float(3); } break; case 6: if(direction){ Low(1); Float(2); High(3); } else{ High(1); Float(2); Low(3); } break; case 7: Low(1); High(2); break; default: Float(1); Float(2); Float(3); break; } }
int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(800, 600); glutInitWindowPosition(100,100); glutCreateWindow("OGLplus+GLUT+GLEW"); if(glewInit() == GLEW_OK) try { glGetError(); namespace se = oglplus::smart_enums; oglplus::Context gl; oglplus::AMD_performance_monitor apm; const char* f1[2] = {" +--", " `--"}; const char* f2[2] = {" |", " "}; const char* f3[2] = {" +--", " `--"}; const char* f4[2] = {" |", ""}; auto groups = apm.GetGroups(); auto gi=groups.begin(), ge=groups.end(); std::cout << "--+-{Performance monitor groups}" << std::endl; if(gi != ge) std::cout << " |" << std::endl; while(gi != ge) { auto group = *gi; ++gi; const int fgi = (gi == ge)?1:0; std::cout << f1[fgi] << "+-["; std::cout << group.GetString(); std::cout << "]" << std::endl; std::cout << f2[fgi] << f4[0] << std::endl; GLint max; auto counters = group.GetCounters(max); auto ci=counters.begin(), ce=counters.end(); while(ci != ce) { auto counter = *ci; ++ci; const int fci = (ci == ce)?1:0; std::cout << f2[fgi] << f3[fci] << "("; std::cout << counter.GetString(); std::cout << ") ["; std::cout << EnumValueName(counter.Type()); std::cout << "]" << std::endl; std::cout << f2[fgi] << f4[fci] << std::endl; } if(fgi != 0) { oglplus::PerfMonitorAMD mon; mon.SelectCounters(true, counters); mon.Begin(); // Imagine some heavy duty rendering here gl.Clear().ColorBuffer(); mon.End(); if(mon.ResultAvailable()) { std::vector<oglplus::PerfMonitorAMDResult> values; mon.Result(values); auto ri=values.begin(), re=values.end(); while(ri != re) { auto counter = ri->Counter(); auto type = counter.Type(); std::cout << counter.GetString(); std::cout << " ["; std::cout << EnumValueName(type); std::cout << "] = "; if(type == se::UnsignedInt()) std::cout << ri->Low(); else if(type == se::Float()) std::cout << ri->Float(); else if(type == se::Percentage()) std::cout << ri->Float() << "%"; else if(type == se::UnsignedInt64()) std::cout << "too big"; std::cout << std::endl; ++ri; } } } } return 0; } catch(oglplus::Error& err) { std::cerr << "Error (in " << err.GLFunc() << "'): " << err.what() << " [" << err.SourceFile() << ":" << err.SourceLine() << "] " << std::endl; } return 1; }
BYTE ModBus(BYTE NumByte){ BYTE RNum=0; BYTE RSum=0; unsigned int TempI=0; cmRcBuf1[NumByte]=0x00; if (cmRcBuf1[0]!=DEVICE_ADDRESS) return 0x00; CRC16=GetCRC16(cmRcBuf1,NumByte-2); TempI=(unsigned int) (cmRcBuf1[NumByte-1]<<8) + cmRcBuf1[NumByte-2]; if (CRC16!=TempI) return 0x00; cmTrBuf1[0]=DEVICE_ADDRESS; switch(cmRcBuf1[1]){ case 0x03:{ TempI=(unsigned int) (cmRcBuf1[2]<<8) + cmRcBuf1[3]; RNum=TempI; if (RNum>=0x64){ return ErrorMessage(0x02); } TempI=(unsigned int) (cmRcBuf1[4]<<8) + cmRcBuf1[5]; RSum=TempI; if ((RSum>0x64)||((RNum+RSum)>0x64)) { return ErrorMessage(0x02); } cmTrBuf1[1]=0x03; BYTE i=RSum*2; BYTE j=RNum*2; cmTrBuf1[2]=i; BYTE n=3; while(i--){ //cmTrBuf1[n++]=MODBUS_MAS[j++]; cmTrBuf1[n++]=AOHR_registers[j++]; } TempI=GetCRC16(cmTrBuf1,n); cmTrBuf1[n++]=Low(TempI); cmTrBuf1[n++]=Hi(TempI); return n; } case 0x06:{ TempI=(unsigned int) (cmRcBuf1[2]<<8) + cmRcBuf1[3]; RNum=TempI; if (RNum>=0x64){ return ErrorMessage(0x02); } TempI=(unsigned int) (cmRcBuf1[4]<<8) + cmRcBuf1[5]; BYTE c=RNum*2; //MODBUS_MAS[c++]=Hi(TempI); //MODBUS_MAS[c]=Low(TempI); AOHR_registers[c++]=Hi(TempI); AOHR_registers[c]=Low(TempI); cmTrBuf1[1]=cmRcBuf1[1]; cmTrBuf1[2]=cmRcBuf1[2]; cmTrBuf1[3]=cmRcBuf1[3]; cmTrBuf1[4]=cmRcBuf1[4]; cmTrBuf1[5]=cmRcBuf1[5]; cmTrBuf1[6]=cmRcBuf1[6]; cmTrBuf1[7]=cmRcBuf1[7]; return 8; } case 0x10:{ TempI=(unsigned int) (cmRcBuf1[2]<<8) + cmRcBuf1[3]; RNum=TempI; if (RNum>=0x64){ return ErrorMessage(0x02); } TempI=(unsigned int) (cmRcBuf1[4]<<8) + cmRcBuf1[5]; RSum=TempI; if ((RSum>0x64)||((RNum+RSum)>0x64)){ return ErrorMessage(0x02); } TempI=(unsigned int) cmRcBuf1[6]; BYTE BSum=TempI; BYTE n=7; while(BSum--){ //MODBUS_MAS[RNum++]=cmRcBuf1[n++]; AOHR_registers[RNum++]=cmRcBuf1[n++]; } cmTrBuf1[1]=cmRcBuf1[1]; cmTrBuf1[2]=cmRcBuf1[2]; cmTrBuf1[3]=cmRcBuf1[3]; cmTrBuf1[4]=cmRcBuf1[4]; cmTrBuf1[5]=cmRcBuf1[5]; TempI=GetCRC16(cmTrBuf1,6); cmTrBuf1[6]=Low(TempI); cmTrBuf1[7]=Hi(TempI); return 8; } default:{ return ErrorMessage(0x01); } } }