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;
}
}
}
