void RadioTraffic::SendQuickMessage(Ship* ship, int action) { if (!ship) return; Element* elem = ship->GetElement(); if (elem) { if (action >= RadioMessage::REQUEST_PICTURE) { Ship* controller = ship->GetController(); if (controller && !ship->IsStarship()) { RadioMessage* msg = new(__FILE__,__LINE__) RadioMessage(controller, ship, action); Transmit(msg); } } else if (action >= RadioMessage::SPLASH_1 && action <= RadioMessage::DISTRESS) { RadioMessage* msg = new(__FILE__,__LINE__) RadioMessage((Element*) 0, ship, action); Transmit(msg); } else { RadioMessage* msg = new(__FILE__,__LINE__) RadioMessage(elem, ship, action); if (action == RadioMessage::ATTACK || action == RadioMessage::ESCORT) msg->AddTarget(ship->GetTarget()); Transmit(msg); } } }
int main(void) { // LED P1DIR |= BIT0; /* P1OUT |= BIT0; */ // UART BCSCTL1 = CALBC1_1MHZ; // Set DCO to 1MHz DCOCTL = CALDCO_1MHZ; // Set DCO to 1MHz // Configure hardware UART P1SEL |= BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD P1SEL2 |= BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD Setup_UART(); UARTSendArray("Hello\n", 6); __delay_cycles(1000); // ADXL345 P1SEL |= BIT6 + BIT7; // Assign I2C pins to USCI_B0 P1SEL2 |= BIT6 + BIT7; // Assign I2C pins to USCI_B0 // Init sequence for ADXL345 //Transmit process Setup_TX(ADXL_345); Transmit(0x2D,0x00); // STUCK while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent //Transmit process Setup_TX(ADXL_345); Transmit(0x2D,0x10); while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent //Transmit process Setup_TX(ADXL_345); Transmit(0x2D,0x08); while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent /* Set watchdog timer interval to 1000ms (requires external crystal to work) */ WDTCTL = WDT_ADLY_1_9; /* "Interrupt enable 1" for the Watchdog Timer interrupt */ IE1 |= WDTIE; /* Go into low power mode 3, general interrupts enabled */ __bis_SR_register( LPM3_bits + GIE ); /* Do nothing...forever */ for( ; ; ) { } }
int main(void) { // LED P1DIR |= BIT0; P1OUT |= BIT0; P4DIR |= BIT7; P4OUT |= BIT7; /* // UART BCSCTL1 = CALBC1_1MHZ; // Set DCO to 1MHz DCOCTL = CALDCO_1MHZ; // Set DCO to 1MHz */ // Configure hardware UART //P3SEL |= BIT3 + BIT4; //Setup_UART(); //UARTSendArray("Hello\n", 6); //__delay_cycles(1000); // ADXL345: MISO (SCL) 1.6->3.1, MOSI (SDA) 1.7->3.0 P3SEL |= BIT0 + BIT1; // Assign I2C pins to USCI_B0 // Init sequence for ADXL345 //Transmit process Setup_TX(ADXL_345); Transmit(0x2D,0x00); // STUCK while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent //Transmit process Setup_TX(ADXL_345); Transmit(0x2D,0x10); while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent //Transmit process Setup_TX(ADXL_345); Transmit(0x2D,0x08); while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent WDTCTL = WDT_ADLY_1_9; SFRIE1 |= WDTIE; //printf("start\n"); __bis_SR_register( LPM3_bits + GIE ); /* Do nothing...forever */ for( ; ; ) { } }
// ユーザー領域を書き換える bool clKicker6A::UserWriteBIN(const std::wstring &file){ char buf[XMEGA_EEPROM_SIZE]; int size = 0; memset(buf, 0xFF, XMEGA_EEPROM_SIZE); // ファイルを読み込む FILE *fp; if (_wfopen_s(&fp, file.c_str(), L"rb") == 0){ size = fread(buf, sizeof(char), XMEGA_EEPROM_SIZE, fp); fclose(fp); } if (0 < size){ // 転送していく bool result = false; int pages = (size + XMEGA_EEPROM_PAGE_SIZE - 1) / XMEGA_EEPROM_PAGE_SIZE; for(int page = 0; page < pages; page++){ // Write char *p = &buf[XMEGA_EEPROM_PAGE_SIZE * page]; unsigned short page_w = page; unsigned int transfered = 0; Trace(L"Write(%d) %d bytes", page, XMEGA_EEPROM_PAGE_SIZE); // ページをセット result = Transmit(CMDID_SET_PAGE, 2, &page_w); if (result == false) break; // ライト result = Transmit(CMDID_WRITE_EEPROM, XMEGA_EEPROM_PAGE_SIZE, p, &transfered); if (result == false) break; Trace(L"Written %d bytes", transfered); Sleep(10); } if (result == true){ Trace(L"成功しました"); }else{ Trace(L"失敗しました"); } return result; } return false; }
void SetMotor(short ControlValue) { Transmit(int(ControlValue), false); short ControlValueAbs, ControlValueSign; ControlValueAbs = (ControlValueSign = ControlValue > 0)? ControlValue:-ControlValue; /* INVERSE SPEED MAPPING */ if(ControlValueAbs == 0) ControlValueAbs = 0; if(ControlValueAbs < MAP_THRESH) ControlValueAbs = MAP_OFFSET; else ControlValueAbs += MAP_OFFSET - MAP_THRESH; /* MAX SPEED CONTROL */ if(ControlValueAbs > MAX_SPEED) ControlValueAbs = MAX_SPEED; if(ControlValueSign) { myMotorL.Forward(ControlValueAbs); myMotorR.Forward(ControlValueAbs); } else { myMotorL.Backward(-ControlValueAbs); myMotorR.Backward(-ControlValueAbs); } }
void NexaCtrl::DeviceOff(unsigned long controller_id, unsigned int device_id) { SetControllerBits(controller_id); SetBit(kGroupFlagOffset, 0); SetBit(kOnFlagOffset, 0); SetDeviceBits(device_id); Transmit(kLowPulseLength); }
void main(void) { WDTCTL = WDTPW + WDTHOLD; P1DIR|=0x41; P1REN |= BIT3; P1OUT |= BIT3; Uart_init(); CCR0=65535; TACTL = TASSEL_2 + MC_1 + ID_3; while(1) { if(k%2==1) { Transmit('u'); a=TAR>>1; Value_send(a); } if(P1IN & 0x08) { P1OUT&=~0x01; flag=0; } else { if(flag==0) { flag=1; k++; P1OUT|=0x41; if(k%2==1) { P1OUT|=0x01; TAR=0; Transmit('b'); } if(k%2==0) { a=0; P1OUT&=~0x40; Transmit('e'); } } } }
static void on_button_trigger_transmit_clicked(GtkEntry *entry,gpointer data) { ArComPduType* Pdu = (ArComPduType*)data; Arch_Trace("Trigger %s\'s transmission\n",Pdu->Name); Transmit(Pdu); }
/* * Sendet die Nachricht M über die Connection CON. Treten dabei keine * Fehler auf, liefert die Funktion 1 zurück. Kommt es zu einem * (Kommunikations-) Fehler, wird eine Fehlermeldung ausgegeben und * das Programm terminiert. NAME ist der Netname des Adressaten * der Nachricht. NAME wird nur für die Ausgabe einer eventuellen * Fehlermeldung benötigt. */ void PutMessage(const NetName name, Connection con, Message *m) { int wcnt; wcnt = Transmit(con, m, sizeof(Message)); if (wcnt != sizeof(Message)) { fprintf(stderr, "Fehler beim Senden an %s: %s\n", name, NET_ErrorText()); exit(20); } }
void RF_Connection_Test(void) { Init_RF(); timer1_A3_Up_Mode; while(1){ if (buttonPressed) // Process a button pressed --> transmit { //P3OUT |= BIT6; // Pulse LED during Transmit buttonPressed = 0; P1IFG = 0; ReceiveOff(); Transmit( (unsigned char*)TxBuffer, sizeof TxBuffer); //Wait for TX status to be reached before going back to low power mode while((Strobe(RF_SNOP) & 0x70) != 0x20); P1IE |= BIT1; // Re-enable button press } else if (packetTransmit) { RF1AIE &= ~BIT9; // Disable RFIFG9 TX end-of-packet interrupts //P3OUT &= ~BIT6; // Turn off LED after Transmit ReceiveOn(); //Wait for RX status to be reached while((Strobe(RF_SNOP) & 0x70) != 0x10); packetTransmit = 0; } else if(packetReceived) // Process a received packet { char toggle = 1; // Read the length byte from the FIFO RxBufferLength = ReadSingleReg( RXBYTES ); ReadBurstReg(RF_RXFIFORD, RxBuffer, RxBufferLength); // Check the packet contents and don't toggle LED if they are different for(i = 0; i < RxBuffer[0]; i++) { if(RxBuffer[i] != TxBuffer[i]) toggle = 0; } if(toggle){ LED_Togg; // Toggle LED packetReceived = 0; } } } }
void Send_Data(unsigned char ADDRESS, unsigned char* Data) { unsigned char TxBuffer[PACKET_LEN]; append(Data, ADDRESS, TxBuffer); ReceiveOff(); receiving = 0; Transmit( (unsigned char*)TxBuffer, sizeof TxBuffer); transmitting = 1; }
bool CEC_LogicalDevice::TransmitFrame(int targetAddress, unsigned char* buffer, int count) { if (_primaryState != CEC_IDLE) return false; unsigned char addr[1]; addr[0] = MAKE_ADDRESS(_logicalAddress, targetAddress); ClearTransmitBuffer(); if (!TransmitPartial(addr, 1)) return false; return Transmit(buffer, count); }
/************************************************************************ * SOURCE FILE : WndProc.cpp * PROGRAM : Dumb Terminal * FUNCTION : LRESULT CALLBACK WndProc (HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam); * HWND hwnd - A handle to the window * UINT Message - The message to handle * WPARAM wParam - wParam parameters * LPARAM lParam - lParam parameters * RETURNS : LRESULT * DATE : September 27, 2010a * REVISIONS : None * DESIGNER : Nick Huber * PROGRAMMER : Nick Huber * NOTES : * * The WndProc for the terminal program, all messages are handled here *************************************************************************/ LRESULT CALLBACK WndProc (HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam) { PCPARAMS cp; HDC hdc; PAINTSTRUCT ps; switch (Message) { case WM_COMMAND: cp = (PCPARAMS)GetWindowLongPtr(hwnd, 0); if (cp->connectMode) { MessageBox(NULL, TEXT("Unable to change settings while in Connect Mode, press ESC to return to Command Mode"), TEXT(""), MB_OK); return 0; } MainMenu(hwnd, LOWORD (wParam), cp); return 0; case WM_CHAR: cp = (PCPARAMS) GetWindowLongPtr(hwnd,0); if (cp->connectMode) { if(VK_ESCAPE == wParam) { SetWindowText(hwnd, TEXT("Dumb Terminal - Command Mode")); CloseHandle(cp->hComm); cp->connectMode = FALSE; return 0; } if(!Transmit(wParam, cp)) { MessageBox (NULL, TEXT("Error sending data"), TEXT(""), MB_OK); return 0; } } return 0; case WM_PAINT: cp = (PCPARAMS) GetWindowLongPtr(hwnd,0); hdc = BeginPaint(hwnd, &ps); DisplayData(hwnd, hdc, cp); EndPaint(hwnd,&ps); return 0; case WM_DESTROY: cp = (PCPARAMS) GetWindowLongPtr(hwnd,0); PostQuitMessage (0); return 0; } return DefWindowProc(hwnd, Message, wParam, lParam); }
// 動作モードを変更する bool clKicker6A::ChangeMode(MODE_e mode){ char cmd; switch(mode){ case MODE_DFU: cmd = 0; break; case MODE_APP: cmd = 1; break; default: return false; } return Transmit(CMDID_RESET, 1, &cmd); }
void ADC_send(int v) { for(i=0;i<4;i++) // Converting Integer to Digits { x[i]=v%10; v=v/10; } for(i=3;i>=0;i--) { x[i]= x[i]+48; // Converting Each digit to character while (!(IFG2 & UCA0TXIFG)); // USART0 TX buffer ready? UCA0TXBUF = (x[i] & 0xFF00)>>8; while (!(IFG2 & UCA0TXIFG)); // USART0 TX buffer ready? UCA0TXBUF = (x[i] & 0x00FF); // } Transmit(' '); }
void main(void) { WDTCTL = WDTPW + WDTHOLD; // Stop WDT P3SEL |= 0x06; // Assign I2C pins to USCI_B0 while(1) { //Transmit process Setup_TX(); RPT_Flag = 1; Transmit(); while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent //Receive process Setup_RX(); Receive(); while (UCB0CTL1 & UCTXSTP); // Ensure stop condition got sent } }
// フラッシュを読み出す bool clKicker6A::FlashReadBIN(const std::wstring &file){ if (m_Mode != MODE_DFU) return false; bool result = false; do{ char buf[XMEGA_APP_SIZE]; // Read for(int page = 0; page < XMEGA_APP_PAGES; page++){ char *p = buf + XMEGA_PAGE_SIZE * page; unsigned short page_w = page; unsigned int transfered = 0; // ページをセット result = Transmit(CMDID_SET_PAGE, 2, &page_w, &transfered); if (result == false) break; if (transfered != 2) break; // リード result = Receive(CMDID_READ, XMEGA_PAGE_SIZE, p, &transfered); if (result == false) break; Trace(L"Read(%d) %d bytes", page, transfered); } if (result == false) break; // 書き出し FILE *fp; if (_wfopen_s(&fp, file.c_str(), L"wb") == 0){ fwrite(buf, sizeof(char), XMEGA_APP_SIZE, fp); fclose(fp); } }while(false); if (result == true){ Trace(L"成功しました"); }else{ Trace(L"失敗しました"); } return result; }
int main() { InitializeStream(&s_stream); Configure(); DendriteInit(); AxonInit(); volatile float foo = 1.0f; float bar = 0.001f; foo += bar; s_y = 0; s_x = 0; while(1) { DendriteReadSticks(); UpdateDendrite(); Transmit(); } }
NS_IMETHODIMP nsEnigMimeListener::StartRequest(nsIRequest* aRequest, nsISupports* aContext) { nsresult rv; DEBUG_LOG(("nsEnigMimeListener::StartRequest: (%p)\n", this)); if (!mHeaders.IsEmpty()) { // Try to parse headers ParseMimeHeaders(mHeaders.get(), mHeaders.Length()); } if (mListener) { rv = mListener->OnStartRequest(aRequest, mContext ? mContext.get() : aContext); if (NS_FAILED(rv)) return rv; } mRequestStarted = PR_TRUE; if (mHeaders.IsEmpty() && mSkipBody) { // No headers terminated and skipping body; so discard whatever we have mDataStr = ""; } if (!mDataStr.IsEmpty()) { // Transmit header/body data already in buffer nsCAutoString temStr( mDataStr ); mDataOffset += mDataStr.Length(); mDataStr = ""; rv = Transmit(temStr.get(), temStr.Length(), aRequest, aContext); if (NS_FAILED(rv)) return rv; } return NS_OK; }
void ArCom_Schedule(void) { static uint32 I = 0; // TODO if(IsTimerElapsed(1)) { uint32 elapsed = GetTimerElapsedMicroSeconds(); for (uint32 i=0; i<sArch.PduNbr; i++) { ArComPduType* Pdu = &(sArch.Pdu[i]); if( (Pdu->IsTxEnabled) && (Pdu->Period != 0) && (Pdu->Timer < Pdu->Period)) { Pdu->Timer += elapsed; } } StartTimer(); } for (; I<sArch.PduNbr; I++) { ArComPduType* Pdu = &(sArch.Pdu[I]); if( (Pdu->IsTxEnabled) && (Pdu->Period != 0) && (Pdu->Timer >= Pdu->Period)) // Elapsed Timer { Transmit(Pdu); Pdu->Timer = 0; // Reset it I++; break; // Each time, only transmit 1 item } } if(I >= sArch.PduNbr) { I = 0; } }
NS_IMETHODIMP nsEnigMimeListener::Write(const char* buf, PRUint32 count, nsIRequest* aRequest, nsISupports* aContext) { nsresult rv; DEBUG_LOG(("nsEnigMimeListener::Write: (%p) %d\n", this, count)); if (mRequestStarted) return Transmit(buf, count, aRequest, aContext); // Search for headers EMBool startingRequest = HeaderSearch(buf, count); if (!startingRequest) return NS_OK; rv = StartRequest(aRequest, aContext); if (NS_FAILED(rv)) return rv; return NS_OK; }
/** * Dims a device to the specified level (0-100). */ void NexaCtrl::DeviceDim(unsigned long controller_id, unsigned int device_id, unsigned int dim_level) { // Normally, allowed input would be 0-15, but 0-100 makes more sense. dim_level *= (15/100); SetControllerBits(controller_id); SetBit(kGroupFlagOffset, 0); // Specific for dim low_pulse_array[(kOnFlagOffset*2)] = kPulseLow0; low_pulse_array[(kOnFlagOffset*2) + 1] = kPulseLow0; SetDeviceBits(device_id); bool dim_bits[kDimLength]; itob(dim_bits, dim_level, kDimLength); int bit; for (bit = 0; bit<kDimLength; bit++) { SetBit(kDimOffset+bit, dim_bits[bit]); } Transmit(kLowPulseLength + (kDimLength * 2)); }
void main(void) { WDTCTL = WDTPW + WDTHOLD; // Stop WDT BCSCTL1 = CALBC1_1MHZ; // Set range DCOCTL = CALDCO_1MHZ; // SMCLK = DCO = 1MHz P1SEL |= TXD; P1DIR |= TXD; P1IES |= RXD; // RXD Hi/lo edge interrupt P1IFG &= ~RXD; // Clear RXD (flag) before enabling interrupt P1IE |= RXD; // Enable RXD interrupt P2DIR = 0x3f; P2OUT = 0x09; isReceiving = false; // Set initial values hasReceived = false; __bis_SR_register(GIE); // interrupts enabled\ while(1) { if (hasReceived) // If the device has recieved a value { hasReceived = false; // Clear the flag switch(RXByte) { case 'f': P2OUT = 0x24;/*前进*/ //__delay_cycles(2000000); //P2OUT = 0x09; break; break; case 'b': P2OUT = 0x12;/*后退*/ //__delay_cycles(2000000); //P2OUT = 0x09; break; break; case 'l': P2OUT = 0x28; break; case 'r': P2OUT = 0x05; break; case 's': P2OUT = 0x09; break; case 'x': P2OUT = 0x22; break; case 'y': P2OUT = 0x14; break; case '1'://opposite 'l' P2OUT = 0x18; case '2'://opposite 'r' P2OUT = 0x03; default: break; } TXByte = RXByte; // Load the recieved byte into the byte to be transmitted Transmit(); } if (~hasReceived) // Loop again if another value has been received __bis_SR_register(CPUOFF + GIE); // LPM0, the ADC interrupt will wake the processor up. This is so that it does not // endlessly loop when no value has been Received. } }
static void MtkSend_CFG(char* dat) { while (*dat != 0) GpsLink(Transmit(*dat++)); }
void main (void){ unsigned int uartUpdateTimer = UART_UPDATE_INTERVAL; unsigned int servo_stepval, servo_stepnow; unsigned int servo_lut[ SERVO_STEPS+1 ]; unsigned int i; // Calculate the step value and define the current step, defaults to minimum. servo_stepval = ( (SERVO_MAX - SERVO_MIN) / SERVO_STEPS ); servo_stepnow = SERVO_MIN; // Fill up the LUT for (i = 0; i > SERVO_STEPS; i++) { servo_stepnow += servo_stepval; servo_lut[i] = servo_stepnow; //pulseWidth = (myAngle * 11) + 500; // конвертируем угол в микросекунды } TA1CCR1 = 0; // Setup the PWM, etc. WDTCTL = WDTPW + WDTHOLD; // Kill watchdog timer TACCTL1 = OUTMOD_7; // TACCR1 reset/set TACTL = TASSEL_2 + MC_1; // SMCLK, upmode TACCR0 = PWM_Period-1; // PWM Period TACCR1 = PWM_Duty; // TACCR1 PWM Duty Cycle P1DIR |= BIT2; // P1.2 = output P1SEL |= BIT2; // P1.2 = TA1 output P2SEL2 |= BIT2; // P1.2 = TA1 output InitializeClocks(); InitializeButton(); InitializeLeds(); PreApplicationMode(); // Blinks LEDs, waits for button press /* Application Mode begins */ applicationMode = APP_APPLICATION_MODE; __enable_interrupt(); // Enable interrupts. while(1) { __bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled if ((--uartUpdateTimer == 0) || calibrateUpdate ) { ConfigureTimerUart(); if (calibrateUpdate) { TXByte = 248; // A character with high value, outside of temp range Transmit(); calibrateUpdate = 0; } TXByte = (unsigned char)( ((tempAverage - 630) * 761) / 1024 ); Transmit(); uartUpdateTimer = UART_UPDATE_INTERVAL; ConfigureTimerPwm(); } } /* TACCR1 = SERVO_MAX; //180° __delay_cycles(1000000); TACCR1 = 1600; //90° __delay_cycles(1000000); TACCR1 = SERVO_MIN; //0° */ // Main loop // while (1){ // Go to 0° // TACCR1 = servo_lut[0]; // __delay_cycles(1000000); // Go to 45° // TACCR1 = servo_lut[45]; // __delay_cycles(1000000); // Go to 90° // TACCR1 = servo_lut[90]; // __delay_cycles(1000000); // Go to 180° // TACCR1 = servo_lut[179]; // __delay_cycles(1000000); /* // Move forward toward the maximum step value for (i = 0; i > SERVO_STEPS; i++) { TACCR1 = servo_lut[i]; __delay_cycles(20000); } // Move backward toward the minimum step value for (i = SERVO_STEPS; i > 0; i--) { TACCR1 = servo_lut[i]; __delay_cycles(20000); } */ // } }
void cc1101_t::TransmitAndWaitIdle(void *Ptr, uint8_t Length) { Transmit(Ptr, Length); while(!GDO0IsHi()); // Wait until sync word is sent while(GDO0IsHi()); // Wait until transmission completed }
void ReceiveTransmitMaster(void) { //ControlSum for Transmit RegTransmit[0]=0; for(Reg0=1;Reg0<=10;++Reg0) { // RegTransmit[Reg0][0]=3; RegTransmit[0] +=RegTransmit[Reg0]; // RegTransmit[Reg0][1]=4; } //Transmit TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);//Start CtTWCR=CtTWCR0; if(!Transmit()) { TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO); Reg0=5000; } else { Reg0=5000;// } while(Reg0) {_WDR(); --Reg0; } //for Ind ControlSum Reg100=0; for(Reg0=1;Reg0<=10;++Reg0) Reg100=Reg100+RamReceive[Reg0]; Reg100=RamReceive[0]; //Receive TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);//Start CtTWCR=CtTWCR0; if(Receive()) { //ControlSum Reg101=0; for(Reg0=1;Reg0<=10;++Reg0) Reg101=Reg101+RamReceive[Reg0]; if(Reg101==RamReceive[0]) { for(Reg0=1;Reg0<=8;++Reg0) RomReceive[Reg0]=RamReceive[Reg0]; CtErrorLink=CtErrorLink0; } } else { TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO); } }
//transmits byte over com port void TransmitByte(unsigned int TByte){ TXByte=TByte; Transmit(); uartUpdateTimer = 10; }
bool CEC_LogicalDevice::ProcessStateMachine(bool* success) { unsigned char buffer[1]; bool wait = false; switch (_primaryState) { case CEC_ALLOCATE_LOGICAL_ADDRESS: switch (_secondaryState) { case CEC_XMIT_POLLING_MESSAGE: // Section 6.1.3 specifies that <Polling Message> while allocating a Logical Address // will have the same initiator and destination address buffer[0] = MAKE_ADDRESS(_validLogicalAddresses[_deviceType][_tertiaryState], _validLogicalAddresses[_deviceType][_tertiaryState]); ClearTransmitBuffer(); Transmit(buffer, 1); _secondaryState = CEC_RCV_POLLING_MESSAGE; wait = true; break; case CEC_RCV_POLLING_MESSAGE: if (success) { if (*success) { // Someone is there, try the next _tertiaryState++; if (_validLogicalAddresses[_deviceType][_tertiaryState] != CLA_UNREGISTERED) _secondaryState = CEC_XMIT_POLLING_MESSAGE; else { _logicalAddress = CLA_UNREGISTERED; DbgPrint("Logical address assigned: %d\r\n", _logicalAddress); DbgPrint("Physical addresss used: %d\r\n", _physicalAddress); _primaryState = CEC_READY; } } else { // We hereby claim this as our logical address! _logicalAddress = _validLogicalAddresses[_deviceType][_tertiaryState]; SetAddress(_logicalAddress); DbgPrint("Logical address assigned: %d\n", _logicalAddress); DbgPrint("Physical addresss used: %d\r\n", _physicalAddress); _primaryState = CEC_READY; set_led(2, true); } } else wait = true; break; } break; case CEC_READY: _primaryState = CEC_IDLE; OnReady(); wait = true; break; case CEC_IDLE: wait = true; break; } return wait; }
void main (void) { WDTCTL = WDTPW + WDTHOLD; // Watchdog timeri durdur BCSCTL1 = CALBC1_1MHZ; // 1mhz dahili osilatör DCOCTL = CALDCO_1MHZ; // SMCLK = DCO = 1MHz // AD çevirici sýcaklýk ölçmek için ayarlanýr. ADC10CTL1 = INCH_10 + ADC10DIV_3; ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON ; P1SEL |= TXD; // gönderme pini ayarlarý P1IES |= RXD; // Alma pini ayarlarý P1IFG &= ~RXD; // Clear RXD (flag) before enabling interrupt P1IE |= RXD; // Enable RXD interrupt P1DIR=0; //Port1 tamam giriþ P1DIR |= TXD+LED1+LED2; // Gerekli pinler çýkýþ olarak ayarlanýr. isReceiving = false; // Set initial values hasReceived = false; gonderilen=0; P1OUT=0; //Port1 çýkýþý temizle. __bis_SR_register(GIE); // interrupts enabled // Ana döngü while(1){ delay(100); //LED1'in durumuna göre gönderilen verinin 1. biti düzenlenir. if(P1OUT & LED1) gonderilen |= 0x01; else gonderilen &= ~0x01; //LED2'nin durumuna göre gönderilen verinin 2. biti düzenlenir. if(P1OUT & LED2) gonderilen |= 0x02; else gonderilen &= ~0x02; //Butonun durumuna göre gönderilen verinin 3. biti düzenlenir. if(!(P1IN & BUTON)) gonderilen |= 0x04; else gonderilen &= ~0x04; //Gönderilen verinin 8. biti set edilerek buton ve LEd durum bilgileri gönderilir. TXByte = (gonderilen | 0x80); Transmit(); ADC10CTL0 |= ENC + ADC10SC; // AD çevrimi baþlat if(ADC10CTL0 & ADC10IFG) // AD çevrim bitti mi? { ADC10CTL0 &= !ADC10IFG; // çevrim bayarðýný temizle ham = ADC10MEM; // sýcaklýðý oku derece = ((ham - 673) * 423) / 1024; //Sýcaklýðý dereceye çevir. //Gönderilen verinin 8.biti sýfýrlanarak sýcaklýk bilgisi gönderilir. TXByte = (int)derece & 0x7f; Transmit(); } //Alýnan veri deðerlendirilir. if(hasReceived){ alinan=RXByte; hasReceived = false; //Gelen verinin 1. bitine göre LED1 durumu düzenlenir. if(alinan & 0x01) P1OUT |= LED1; else P1OUT &= ~LED1; //Gelen verinin 2. bitine göre LED2 durumu düzenlenir. if(alinan & 0x02) P1OUT |= LED2; else P1OUT &= ~LED2; } } }