/** * @brief emulate instruction * @return returns false if something goes wrong (e.g. illegal instruction) * * Current limitations: * * - Illegal instructions are not implemented * - Excess cycles due to page boundary crossing are not calculated * - Some known architectural bugs are not emulated */ bool Cpu::emulate() { /* fetch instruction */ uint8_t insn = fetch_op(); bool retval = true; /* emulate instruction */ switch(insn) { /* BRK */ case 0x0: brk(); break; /* ORA (nn,X) */ case 0x1: ora(load_byte(addr_indx()),6); break; /* ORA nn */ case 0x5: ora(load_byte(addr_zero()),3); break; /* ASL nn */ case 0x6: asl_mem(addr_zero(),5); break; /* PHP */ case 0x8: php(); break; /* ORA #nn */ case 0x9: ora(fetch_op(),2); break; /* ASL A */ case 0xA: asl_a(); break; /* ORA nnnn */ case 0xD: ora(load_byte(addr_abs()),4); break; /* ASL nnnn */ case 0xE: asl_mem(addr_abs(),6); break; /* BPL nn */ case 0x10: bpl(); break; /* ORA (nn,Y) */ case 0x11: ora(load_byte(addr_indy()),5); break; /* ORA nn,X */ case 0x15: ora(load_byte(addr_zerox()),4); break; /* ASL nn,X */ case 0x16: asl_mem(addr_zerox(),6); break; /* CLC */ case 0x18: clc(); break; /* ORA nnnn,Y */ case 0x19: ora(load_byte(addr_absy()),4); break; /* ORA nnnn,X */ case 0x1D: ora(load_byte(addr_absx()),4); break; /* ASL nnnn,X */ case 0x1E: asl_mem(addr_absx(),7); break; /* JSR */ case 0x20: jsr(); break; /* AND (nn,X) */ case 0x21: _and(load_byte(addr_indx()),6); break; /* BIT nn */ case 0x24: bit(addr_zero(),3); break; /* AND nn */ case 0x25: _and(load_byte(addr_zero()),3); break; /* ROL nn */ case 0x26: rol_mem(addr_zero(),5); break; /* PLP */ case 0x28: plp(); break; /* AND #nn */ case 0x29: _and(fetch_op(),2); break; /* ROL A */ case 0x2A: rol_a(); break; /* BIT nnnn */ case 0x2C: bit(addr_abs(),4); break; /* AND nnnn */ case 0x2D: _and(load_byte(addr_abs()),4); break; /* ROL nnnn */ case 0x2E: rol_mem(addr_abs(),6); break; /* BMI nn */ case 0x30: bmi(); break; /* AND (nn,Y) */ case 0x31: _and(load_byte(addr_indy()),5); break; /* AND nn,X */ case 0x35: _and(load_byte(addr_zerox()),4); break; /* ROL nn,X */ case 0x36: rol_mem(addr_zerox(),6); break; /* SEC */ case 0x38: sec(); break; /* AND nnnn,Y */ case 0x39: _and(load_byte(addr_absy()),4); break; /* AND nnnn,X */ case 0x3D: _and(load_byte(addr_absx()),4); break; /* ROL nnnn,X */ case 0x3E: rol_mem(addr_absx(),7); break; /* RTI */ case 0x40: rti(); break; /* EOR (nn,X) */ case 0x41: eor(load_byte(addr_indx()),6); break; /* EOR nn */ case 0x45: eor(load_byte(addr_zero()),3); break; /* LSR nn */ case 0x46: lsr_mem(addr_zero(),5); break; /* PHA */ case 0x48: pha(); break; /* EOR #nn */ case 0x49: eor(fetch_op(),2); break; /* BVC */ case 0x50: bvc(); break; /* JMP nnnn */ case 0x4C: jmp(); break; /* EOR nnnn */ case 0x4D: eor(load_byte(addr_abs()),4); break; /* LSR A */ case 0x4A: lsr_a(); break; /* LSR nnnn */ case 0x4E: lsr_mem(addr_abs(),6); break; /* EOR (nn,Y) */ case 0x51: eor(load_byte(addr_indy()),5); break; /* EOR nn,X */ case 0x55: eor(load_byte(addr_zerox()),4); break; /* LSR nn,X */ case 0x56: lsr_mem(addr_zerox(),6); break; /* CLI */ case 0x58: cli(); break; /* EOR nnnn,Y */ case 0x59: eor(load_byte(addr_absy()),4); break; /* EOR nnnn,X */ case 0x5D: eor(load_byte(addr_absx()),4); break; /* LSR nnnn,X */ case 0x5E: lsr_mem(addr_absx(),7); break; /* RTS */ case 0x60: rts(); break; /* ADC (nn,X) */ case 0x61: adc(load_byte(addr_indx()),6); break; /* ADC nn */ case 0x65: adc(load_byte(addr_zero()),3); break; /* ROR nn */ case 0x66: ror_mem(addr_zero(),5); break; /* PLA */ case 0x68: pla(); break; /* ADC #nn */ case 0x69: adc(fetch_op(),2); break; /* ROR A */ case 0x6A: ror_a(); break; /* JMP (nnnn) */ case 0x6C: jmp_ind(); break; /* ADC nnnn */ case 0x6D: adc(load_byte(addr_abs()),4); break; /* ROR nnnn */ case 0x6E: ror_mem(addr_abs(),6); break; /* BVS */ case 0x70: bvs(); break; /* ADC (nn,Y) */ case 0x71: adc(load_byte(addr_indy()),5); break; /* ADC nn,X */ case 0x75: adc(load_byte(addr_zerox()),4); break; /* ROR nn,X */ case 0x76: ror_mem(addr_zerox(),6); break; /* SEI */ case 0x78: sei(); break; /* ADC nnnn,Y */ case 0x79: adc(load_byte(addr_absy()),4); break; /* ADC nnnn,X */ case 0x7D: adc(load_byte(addr_absx()),4); break; /* ROR nnnn,X */ case 0x7E: ror_mem(addr_absx(),7); break; /* STA (nn,X) */ case 0x81: sta(addr_indx(),6); break; /* STY nn */ case 0x84: sty(addr_zero(),3); break; /* STA nn */ case 0x85: sta(addr_zero(),3); break; /* STX nn */ case 0x86: stx(addr_zero(),3); break; /* DEY */ case 0x88: dey(); break; /* TXA */ case 0x8A: txa(); break; /* STY nnnn */ case 0x8C: sty(addr_abs(),4); break; /* STA nnnn */ case 0x8D: sta(addr_abs(),4); break; /* STX nnnn */ case 0x8E: stx(addr_abs(),4); break; /* BCC nn */ case 0x90: bcc(); break; /* STA (nn,Y) */ case 0x91: sta(addr_indy(),6); break; /* STY nn,X */ case 0x94: sty(addr_zerox(),4); break; /* STA nn,X */ case 0x95: sta(addr_zerox(),4); break; /* STX nn,Y */ case 0x96: stx(addr_zeroy(),4); break; /* TYA */ case 0x98: tya(); break; /* STA nnnn,Y */ case 0x99: sta(addr_absy(),5); break; /* TXS */ case 0x9A: txs(); break; /* STA nnnn,X */ case 0x9D: sta(addr_absx(),5); break; /* LDY #nn */ case 0xA0: ldy(fetch_op(),2); break; /* LDA (nn,X) */ case 0xA1: lda(load_byte(addr_indx()),6); break; /* LDX #nn */ case 0xA2: ldx(fetch_op(),2); break; /* LDY nn */ case 0xA4: ldy(load_byte(addr_zero()),3); break; /* LDA nn */ case 0xA5: lda(load_byte(addr_zero()),3); break; /* LDX nn */ case 0xA6: ldx(load_byte(addr_zero()),3); break; /* TAY */ case 0xA8: tay(); break; /* LDA #nn */ case 0xA9: lda(fetch_op(),2); break; /* TAX */ case 0xAA: tax(); break; /* LDY nnnn */ case 0xAC: ldy(load_byte(addr_abs()),4); break; /* LDA nnnn */ case 0xAD: lda(load_byte(addr_abs()),4); break; /* LDX nnnn */ case 0xAE: ldx(load_byte(addr_abs()),4); break; /* BCS nn */ case 0xB0: bcs(); break; /* LDA (nn,Y) */ case 0xB1: lda(load_byte(addr_indy()),5); break; /* LDY nn,X */ case 0xB4: ldy(load_byte(addr_zerox()),3); break; /* LDA nn,X */ case 0xB5: lda(load_byte(addr_zerox()),3); break; /* LDX nn,Y */ case 0xB6: ldx(load_byte(addr_zeroy()),3); break; /* CLV */ case 0xB8: clv(); break; /* LDA nnnn,Y */ case 0xB9: lda(load_byte(addr_absy()),4); break; /* TSX */ case 0xBA: tsx(); break; /* LDY nnnn,X */ case 0xBC: ldy(load_byte(addr_absx()),4); break; /* LDA nnnn,X */ case 0xBD: lda(load_byte(addr_absx()),4); break; /* LDX nnnn,Y */ case 0xBE: ldx(load_byte(addr_absy()),4); break; /* CPY #nn */ case 0xC0: cpy(fetch_op(),2); break; /* CMP (nn,X) */ case 0xC1: cmp(load_byte(addr_indx()),6); break; /* CPY nn */ case 0xC4: cpy(load_byte(addr_zero()),3); break; /* CMP nn */ case 0xC5: cmp(load_byte(addr_zero()),3); break; /* DEC nn */ case 0xC6: dec(addr_zero(),5); break; /* INY */ case 0xC8: iny(); break; /* CMP #nn */ case 0xC9: cmp(fetch_op(),2); break; /* DEX */ case 0xCA: dex(); break; /* CPY nnnn */ case 0xCC: cpy(load_byte(addr_abs()),4); break; /* CMP nnnn */ case 0xCD: cmp(load_byte(addr_abs()),4); break; /* DEC nnnn */ case 0xCE: dec(addr_abs(),6); break; /* BNE nn */ case 0xD0: bne(); break; /* CMP (nn,Y) */ case 0xD1: cmp(load_byte(addr_indy()),5); break; /* CMP nn,X */ case 0xD5: cmp(load_byte(addr_zerox()),4); break; /* DEC nn,X */ case 0xD6: dec(addr_zerox(),6); break; /* CLD */ case 0xD8: cld(); break; /* CMP nnnn,Y */ case 0xD9: cmp(load_byte(addr_absy()),4); break; /* CMP nnnn,X */ case 0xDD: cmp(load_byte(addr_absx()),4); break; /* DEC nnnn,X */ case 0xDE: dec(addr_absx(),7); break; /* CPX #nn */ case 0xE0: cpx(fetch_op(),2); break; /* SBC (nn,X) */ case 0xE1: sbc(load_byte(addr_indx()),6); break; /* CPX nn */ case 0xE4: cpx(load_byte(addr_zero()),3); break; /* SBC nn */ case 0xE5: sbc(load_byte(addr_zero()),3); break; /* INC nn */ case 0xE6: inc(addr_zero(),5); break; /* INX */ case 0xE8: inx(); break; /* SBC #nn */ case 0xE9: sbc(fetch_op(),2); break; /* NOP */ case 0xEA: nop(); break; /* CPX nnnn */ case 0xEC: cpx(load_byte(addr_abs()),4); break; /* SBC nnnn */ case 0xED: sbc(load_byte(addr_abs()),4); break; /* INC nnnn */ case 0xEE: inc(addr_abs(),6); break; /* BEQ nn */ case 0xF0: beq(); break; /* SBC (nn,Y) */ case 0xF1: sbc(load_byte(addr_indy()),5); break; /* SBC nn,X */ case 0xF5: sbc(load_byte(addr_zerox()),4); break; /* INC nn,X */ case 0xF6: inc(addr_zerox(),6); break; /* SED */ case 0xF8: sed(); break; /* SBC nnnn,Y */ case 0xF9: sbc(load_byte(addr_absy()),4); break; /* SBC nnnn,X */ case 0xFD: sbc(load_byte(addr_absx()),4); break; /* INC nnnn,X */ case 0xFE: inc(addr_absx(),7); break; /* Unknown or illegal instruction */ default: D("Unknown instruction: %X at %04x\n", insn,pc()); retval = false; } return retval; }
int main(void) { char remotePrev = 0; signed char remoteValue; unsigned int cowDelay = 0; unsigned char cowDirection = FORWARD; unsigned char count = 0; unsigned int motorb_current = 0; char motorb_safety = ON; char name[15]; timer0_prescale(TMR0_PRE1024); // set_bit(TIMSK0, TOIE0); twiMasterInit(100000); sei(); hcmmod_rc(DISABLE); iomod_text(FIRST_LINE, "Darla Rules"); //darla_relay(0x00); // while (1); while (TRUE) { if (masterCounter > cowDelay) { clear_bit(TIMSK0, TOIE0); masterCounter = 0; if (cowDirection == FORWARD) hcmd_drive_limit(MOTORB, +40, 1); else if (cowDirection == REVERSE) hcmd_drive_limit(MOTORB, -40, 2); } remoteValue = iomod_remote(); if (remoteValue != -1) iomod_decimal(FIRST_LINE, remoteValue, 4); //if (remoteValue == 1) { if ((remoteValue == 1) && (remotePrev != 1)) { masterCounter = 0; cowDirection = FORWARD; cowDelay = 2400; set_bit(TIMSK0, TOIE0); darla_send_set(darlaSet1, 7); mp3mod_play_file("o1NEWMC.mp3"); /* Need to avoid multiple calls from remote, which seemed to be the * cause of problems with the MP3 not working. */ //delay_ms(1000); remotePrev = 1; } //else if (remoteValue == 2) { else if ((remoteValue == 2) && (remotePrev != 2)) { masterCounter = 0; cowDirection = REVERSE; cowDelay = 50; set_bit(TIMSK0, TOIE0); darla_send_set(darlaSet2, 3); mp3mod_play_file("i2MTC.mp3"); remotePrev = 2; //delay_ms(1000); } else if (remoteValue == 4) hcmd_drive_limit(MOTORB, +40, 1); else if (remoteValue == 6) hcmd_drive_limit(MOTORB, -40, 2); else if (remoteValue == 5) hcmd_stop_motor(MOTORB, BRAKE); else if (remoteValue == 7) darla_relay(OFF); else if (remoteValue == 8) darla_relay(MM); else if (remoteValue == 9) darla_relay(UC); // darla_send_set(darlaSetT, 2); /* Prevent Darla from moving if current draw is too high */ iomod_decimal(SECOND_LINE, hcmmod_current(MOTORB), 6); motorb_current = hcmmod_current(MOTORB); if ((motorb_current > 200) && (motorb_safety == ON)) hcmd_stop_motor(MOTORB, BRAKE); } }
void INT0_vect ( void ) { cli (); printf ("I am in an interrupt----------->\n"); sei (); }
int main( void ) { // Enable interrupts as early as possible sei(); Timer_Init(); // Set as outputs and stop rotor DDRD |= (1 << PD1)|(1 << PD2); PORTD &= ~((1 << PD1)|(1 << PD2)); // Setup ADC initAdcFeedback(); Can_Message_t txMsg; txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) | (NODE_ID << CAN_SHIFT_NMT_SID); txMsg.DataLength = 4; txMsg.RemoteFlag = 0; txMsg.ExtendedFlag = 1; txMsg.Data.words[0] = APP_TYPE; txMsg.Data.words[1] = APP_VERSION; // Set up callback for CAN reception BIOS_CanCallback = &can_receive; // Send CAN_NMT_APP_START BIOS_CanSend(&txMsg); // Read calibration value from eeprom azimuthCalibration = eeprom_read_word( CALIBRATE_AZIMUTH ); // Timer for reading position feedback Timer_SetTimeout(0, 100, TimerTypeFreeRunning, 0); Timer_SetTimeout(1, 1000, TimerTypeFreeRunning, 0); sendStatus( STATUS ); while (1) { if (Timer_Expired(0)) { // Periodicly read antennas position readFeedback(); } if (Timer_Expired(1)) { sendStatus(STATUS); } if (rxMsgFull) { switch (rxMsg.Id){ case MSG_CAL_SET: // Set calibration value if( 2 == rxMsg.DataLength ){ calibration( SET, rxMsg.Data.words[0] ); } break; case MSG_CAL_GET: // Get calibration value if( 0 == rxMsg.DataLength ){ txMsg.Id = MSG_CAL_RET; txMsg.DataLength = 2; txMsg.Data.words[0] = calibration( GET, 0 ); BIOS_CanSend(&txMsg); } break; case MSG_ABS: // Start turning to absolute position if( 2 == rxMsg.DataLength ){ } break; case MSG_REL: // Start turning to relative position if( 2 == rxMsg.DataLength ){ } break; case MSG_START: // Start turning if( 1 == rxMsg.DataLength ){ // First data byte decides direction controlRelay( rxMsg.Data.bytes[0] ); } break; case MSG_STOP: // Stop turning //if( 1 == rxMsg.DataLength ){ controlRelay( ROTATE_STOP ); //} break; case MSG_STATUS: // Get position if( 0 == rxMsg.DataLength ){ sendStatus(STATUS); } break; default: break; } rxMsgFull = 0; // } } return 0; }
int main(void) { SetSystemClockPrescaler(0); init(); sei(); led_blink(3); while (1) { if(SW_ACTIVE()) { // SW pressed uint8_t pressCnt = 100; // wait until released do { // long term press detected? if(pressCnt>0 && --pressCnt==0) LED_ON(); _delay_ms(10); } while(SW_ACTIVE()); // SW released LED_OFF(); if(pressCnt>0) handleSensor(1); // force transmit else { // program mode LED_ON(); fs20_resetbuffer(); fs20_rxon(); fstelegram_t t; t.type = 'U'; // undefined pressCnt = 100; // wait for next telegram // exit if button pressed or timeout occured while(!fs20_readFS20Telegram(&t) && --pressCnt>0 && !SW_ACTIVE()) _delay_ms(100); fs20_idle(); LED_OFF(); // save the result if(t.type=='F') { saveConfig(t.housecode, t.button); led_blink(2); // confirm save of config handleSensor(1); // force transmit } // wait until sw releases while(SW_ACTIVE()); } } // check long term timer if(longTimerCnt >= LONGTIMER_VAL) handleSensor(1); // finaly check if sensor value changed // this will only be the case if the current sensor value haven't been sent // during this cycle handleSensor(0); // sleep well LED_OFF(); SENS_ACTIVATE(0); set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_mode(); } }
void set_time(bool timeType){ int *hou = &hour; int *min = &minute; update_timeXPos(hour, minute); if (timeType == ALARM_TYPE){ hou = &alarm_hour; min = &alarm_minute; update_timeXPos(alarm_hour, alarm_minute); } int item = 0; int old_selectedItem = 1; cli(); btn_drehenc_pushed = false; sei(); clear_pixelMatrix(); print_time(timeType); print_symbol(16,17, hakenSymb,108,46); print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinSymb,timeXPos+get_timeWidth(alarm_hour)/2-4, 2); update_LCD(); while(item != 2){ while(!btn_drehenc_pushed){ if(rotary != 0){ item += rotary; cli(); rotary = 0; sei(); item = item % 3; if(item<0){ item += 3; } switch (old_selectedItem){ case 0: for(int x = 0; x<128; x++){ for(int y = 2; y<10; y++) reset_pixel(x,y); } break; case 1: for(int x = 0; x<128; x++){ for(int y = 2; y<10; y++) reset_pixel(x,y); }break; case 2: for(int x = 92; x<102; x++){ for(int y = 2+3*15+5; y<2+3*15+8+5; y++) reset_pixel(x,y); }break; } switch (item) { case 0: print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinSymb,timeXPos+hourWidth/2-4, 2); break; case 1: print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinSymb,timeXPos+hourWidth+2*SPACE_TO_DOTS+ TIMEDOT_WIDTH + minuteWidth/2-4, 2); break; case 2: print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinSymb, 92, 2+3*15+5);break; } old_selectedItem = item; update_LCD(); } goodNight(); check_light(); } cli(); btn_drehenc_pushed = false; sei(); switch (item) { case 0: { print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinOffenSymb,timeXPos+hourWidth/2-4, 2); update_LCD(); set_timeParameter(hou, 24, timeType); print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinSymb,timeXPos+hourWidth/2-4, 2); break; } case 1: { print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinOffenSymb,timeXPos+hourWidth+2*SPACE_TO_DOTS+ TIMEDOT_WIDTH + minuteWidth/2-4, 2); update_LCD(); set_timeParameter(min, 60, timeType); print_symbol(8,HERZ_KLEIN_WIDTH,herzKleinSymb,timeXPos+hourWidth+2*SPACE_TO_DOTS+ TIMEDOT_WIDTH + minuteWidth/2-4, 2); break; } case 2: { seconds = 0; cli(); TCNT2 = 0; timeAdvance = 0; timeUpdate = 0; sei(); break; } } update_LCD(); } }
int door_main(void) { serial_init(9600, 8e2); pin13_mode_output(); pin_mode_input(PIN_CLK); /* clk */ pin_mode_input(PIN_DATA); /* data */ pin_mode_output(PIN_GREEN_LED); /* green led lock */ pin_mode_output(PIN_YELLOW_LED); /* yellow led lock */ pin_mode_output(PIN_OPEN_LOCK); /* open */ pin_mode_output(PIN_DAYMODE); /* stay open */ pin_mode_output(PIN_STATUS_LED); /* yellow status */ pin_high(PIN_OPEN_LOCK); pin_high(PIN_DAYMODE); pin_high(PIN_GREEN_LED); pin_high(PIN_YELLOW_LED); /* trigger pin2 interrupt when the clock * signal goes high */ pin2_interrupt_mode_rising(); pin2_interrupt_enable(); data_reset(); /* setup timer1 to trigger interrupt a 4 times a second */ timer1_mode_ctc(); timer1_compare_a_set(62499); timer1_clock_d64(); timer1_interrupt_a_enable(); softserial_init(); pin_mode_output(PIN_RFID_ENABLE); pin_low(PIN_RFID_ENABLE); sleep_mode_idle(); while (1) { /* * sleep if no new events need to be handled * while avoiding race conditions. see * http://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html */ cli(); if (events == EV_NONE && !ev_softserial) { sleep_enable(); sei(); sleep_cpu(); sleep_disable(); continue; } sei(); if (events & EV_SERIAL) { handle_serial_input(); continue; } if (ev_softserial) { handle_rfid_input(); } events &= ~EV_DATA; if (cnt > 0 && data[cnt - 1] == 0xB4) { if (cnt >= 10) { struct sha1_context ctx; char digest[SHA1_DIGEST_LENGTH]; sha1_init(&ctx); sha1_update(&ctx, (char *)data, 256); sha1_final(&ctx, digest); serial_print("HASH+"); serial_hexdump(digest, SHA1_DIGEST_LENGTH); serial_print("\n"); } data_reset(); continue; } events &= ~EV_TIME; if (second > 10*4) { serial_print("ALIVE\n"); second = 0; data_reset(); continue; } } }
/*---------------------------------------------------------------------------*/ int main(void) { uint8_t rv; uint8_t i = 0; uint8_t mcp3421_addr; uint8_t mcp9800_addr; uint8_t tmpReadout[4]; /* Variables for cold junction moving average filter */ int16_t movAvg_read; int8_t movAvg_ind = 0; int32_t movAvg_sum = 0; uint8_t movAvg_stabil = 0; int16_t movAvg_mem[8] = {0,0,0,0,0,0,0,0}; gainSetting = 0; timer0_counter = 0; initSerialNumber(); usb_init(); I2C_Init(); timer_init(); pinMode(B,1,OUTPUT); /*-----------------------------------------------------------------------*/ /* Search for viable MCP3421 address options */ /*-----------------------------------------------------------------------*/ for(i=0x68;i<0x70;i++) { I2C_Start(); rv = I2C_Write(write_address(i)); I2C_Stop(); if(rv == 0) { mcp3421_addr = i; } } /*-----------------------------------------------------------------------*/ /* Search for viable MCP9800 address options */ /*-----------------------------------------------------------------------*/ I2C_Start(); rv = I2C_Write(write_address(0x48)); I2C_Stop(); if(rv == 0) { mcp9800_addr = 0x48; } else { mcp9800_addr = 0x4D; } /*-----------------------------------------------------------------------*/ /* Set MCP9800 to 12 bit resolution */ /*-----------------------------------------------------------------------*/ I2C_Start(); I2C_Write(write_address(mcp9800_addr)); I2C_Write(0x01); I2C_Write((1<<7)|(1<<6)|(1<<5)); I2C_Stop(); /*-----------------------------------------------------------------------*/ /* Set MCP9800 Register Pointer to Ambient Temperature */ /*-----------------------------------------------------------------------*/ I2C_Start(); I2C_Write(write_address(mcp9800_addr)); I2C_Write(0x00); I2C_Stop(); while(1) { /*-------------------------------------------------------------------*/ /* MCP9800: Cold junction channel */ /*-------------------------------------------------------------------*/ usbPoll(); I2C_Start(); debug[0] = I2C_Write(read_address(mcp9800_addr)); tmpReadout[0] = I2C_Read(ACK); tmpReadout[1] = I2C_Read(NO_ACK); I2C_Stop(); movAvg_read = ((int16_t)tmpReadout[0] << 8) + ((int16_t)tmpReadout[1]); movAvg_sum -= movAvg_mem[movAvg_ind]; movAvg_sum += movAvg_read; movAvg_mem[movAvg_ind] = movAvg_read; if(movAvg_ind == 7) { movAvg_ind = 0; movAvg_stabil = 1; } else { movAvg_ind++; } if(movAvg_stabil == 1) { movAvg_read = movAvg_sum >> 3; } usbPoll(); cli(); coldJunctionReadout[0] = movAvg_read >> 8; coldJunctionReadout[1] = movAvg_read & 0xFF; sei(); /*-------------------------------------------------------------------*/ /* MCP3421: 3.75 SPS + 18 Bits + Initiate new conversion /*-------------------------------------------------------------------*/ usbPoll(); I2C_Start(); I2C_Write(write_address(mcp3421_addr)); I2C_Write((1<<7)|(1<<3)|(1<<2)|gainSetting); I2C_Stop(); /*-------------------------------------------------------------------*/ /* Small delay ... /*-------------------------------------------------------------------*/ timer0_counter = 250; while(timer0_counter) { usbPoll(); } /*-------------------------------------------------------------------*/ /* MCP3421 /*-------------------------------------------------------------------*/ usbPoll(); I2C_Start(); I2C_Write(read_address(mcp3421_addr)); tmpReadout[0] = I2C_Read(ACK); tmpReadout[1] = I2C_Read(ACK); tmpReadout[2] = I2C_Read(ACK); tmpReadout[3] = I2C_Read(NO_ACK); I2C_Stop(); usbPoll(); cli(); thermocoupleReadout[0] = tmpReadout[0]; thermocoupleReadout[1] = tmpReadout[1]; thermocoupleReadout[2] = tmpReadout[2]; thermocoupleReadout[3] = tmpReadout[3]; sei(); }
int main(void) { { // Set up timers, sleep and such cli(); set_sleep_mode(SLEEP_MODE_IDLE); PRR = ((1 << PRTIM1) | (1 << PRUSI) | (1 << PRADC)); // TIMER0 TCCR0A = (1 << WGM01); TCCR0B = ((1 << CS01) | (1 << CS00)); OCR0A = 61; OCR0B = 0; TIMSK = (1 << OCIE0A); // INT0 MCUCR |= (1 << ISC01); GIMSK = (1 << INT0); PORTB = PORTB_NULL; counter = leds = 0; counter_max = MAXIMUM; piezo = 0; stopped = 1; sei(); } { // Set up the counter and start while (stopped < 3) { leds = counter_max; sleep_mode(); } leds = LED_ON; } { // Prepare for the timer cli(); GIMSK = 0; // Stop INT0 stopped = 0; TCNT0 = 0; // Clear TIMER0 sei(); } { // Display the timer while it's running while (counter < counter_max) { leds = counter | LED_ON; sleep_mode(); } stopped = 4; leds = counter; } { // Yell! cli(); GIMSK = (1 << INT0); // Start INT0 sei(); while (stopped == 4) // Sleep! sleep_mode(); GIMSK = 0; // Stop INT0 TCCR0A &= ~((1 << COM0B1) | (1 << COM0B0)); // Stop yelling! } { // Timer finished, sleep forever! cli(); TIMSK = 0; PORTB = 0; // Everything off set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_mode(); } return 0; }
/** * Entry point */ int main(void) { /* Misc variables */ DCPU_registers reg; // CPU registers states (at boot) /* Hardware initialisation */ cli(); led_setup(); spi_setup(SPI_PRESCALER, SPI_MODE, SPI_BITS_ORDER); uart_setup(UART_BAUDRATE); DEBUG_STR("Main init", "UART ready"); button_setup(); buzzer_setup(BUZZER_FREQUENCY, BUZZER_DURATION); ram_setup(); rom_setup(); microvga_setup(); microvga_enable(); dcpu_register_init(®); DEBUG_STR("Main init", "done"); sei(); /* MicroVGA initialisation */ _delay_ms(1000); // MicroVGA boot time microvga_clear_screen(); // Clear screen and goto (0, 0) microvga_goto_cursor(0, 0); uart_puts_PSTR(PSTR("SkyWodd DCPU-16 hardware emulator")); // Screen test buzzer_beep(); DEBUG_STR("Main init", "MicroVGA ready"); /* Hardware self-test */ DEBUG_STR("Main init", "self-test run"); led_run_write(1); // Led test _delay_ms(250); led_run_write(0); led_cpu_write(1); _delay_ms(250); led_cpu_write(0); led_rom_write(1); _delay_ms(250); led_rom_write(0); led_ram_write(1); _delay_ms(250); led_ram_write(0); DEBUG_STR("Main init", "self-test done"); /* Keyboard & MicroVGA api test */ DEBUG_STR("Main init", "waiting for keypress"); microvga_goto_cursor(0, 1); uart_puts_PSTR(PSTR("Press any key to boot ...")); keyboard_wait(); uart_puts_PSTR(PSTR("Loading please wait ...")); dcpu_setup(reg); buzzer_beep(); microvga_clear_screen(); microvga_goto_cursor(0, 0); DEBUG_STR("Main init", "ready to run"); /* Infinite loop */ for(;;) { /* Handle pause */ while(!button_get_state()); #ifdef SERIAL_DEBUG_SUPPORT /* Debug */ dcpu_registers_dump(); #endif /* Fetch opcode from ROM */ dcpu_step(); } }
static void bluetooth_parse_command(uint8_t len) { uint8_t response = RESPONSE_OK; sei(); if (len == 0) { response = RESPONSE_NO_RESPONSE; } else if (strncmp(rxbuff, BLUETOOTH_CMD_HELP, len) == 0) { uint8_t i = 0; for (i = 1; i < sizeof(commands) / sizeof(commands[0]); i ++) { uart_puts(commands[i]); if ((i % 3) == 0) { uart_puts("\r\n"); } else { uint8_t padding = 0, j = 0; padding = 26 - strlen(commands[i]); for (j = 0; j < padding; j++) { uart_putc(' '); } } } if (((i - 1) % 3) != 0) { uart_puts("\r\n"); } response = RESPONSE_NO_RESPONSE; } else if (strncmp(rxbuff, BLUETOOTH_CMD_BATTERY, len) == 0) { uint8_t capacity = 0; char resp[16]; capacity = battery_get_capacity(); itoa(capacity, resp, 10); uart_puts(BLUETOOTH_CMD_BATTERY); uart_puts(": "); uart_puts(resp); uart_puts("%\r\n"); response = RESPONSE_NO_RESPONSE; } else if (strncmp(rxbuff, BLUETOOTH_CMD_ECHO, len) == 0) { echo = TRUE; uart_puts("\r\n"); response = RESPONSE_NO_RESPONSE; } else if (strncmp(rxbuff, BLUETOOTH_CMD_EYES, strlen(BLUETOOTH_CMD_EYES)) == 0) { char *param = rxbuff + strlen(BLUETOOTH_CMD_EYES) + 1; if (len == strlen(BLUETOOTH_CMD_EYES) + strlen(BLUETOOTH_PARAM_ON) + 1) { if (strncmp(param, BLUETOOTH_PARAM_ON, strlen(BLUETOOTH_PARAM_ON)) == 0) { power_on(EYES); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_EYES) + strlen(BLUETOOTH_PARAM_OFF) + 1) { if (strncmp(param, BLUETOOTH_PARAM_OFF, strlen(BLUETOOTH_PARAM_OFF)) == 0) { power_off(EYES); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_EYES)) { uint8_t state = power_state(EYES); uart_puts(BLUETOOTH_CMD_EYES); uart_puts(": "); if (state == POWER_ON) { uart_puts(BLUETOOTH_PARAM_ON); } else { uart_puts(BLUETOOTH_PARAM_OFF); } uart_puts("\r\n"); response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else if (strncmp(rxbuff, BLUETOOTH_CMD_HELMET, strlen(BLUETOOTH_CMD_HELMET)) == 0) { char *param = rxbuff + strlen(BLUETOOTH_CMD_HELMET) + 1; if (len == strlen(BLUETOOTH_CMD_HELMET) + strlen(BLUETOOTH_PARAM_OPEN) + 1) { if (strncmp(param, BLUETOOTH_PARAM_OPEN, strlen(BLUETOOTH_PARAM_OPEN)) == 0) { helmet_open(); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_HELMET) + strlen(BLUETOOTH_PARAM_CLOSE) + 1) { if (strncmp(param, BLUETOOTH_PARAM_CLOSE, strlen(BLUETOOTH_PARAM_CLOSE)) == 0) { helmet_close(); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_HELMET)) { uint8_t state = helmet_state(); uart_puts(BLUETOOTH_CMD_HELMET); uart_puts(": "); if (state == HELMET_OPEN) { uart_puts(BLUETOOTH_PARAM_OPEN); } else { uart_puts(BLUETOOTH_PARAM_CLOSE); } uart_puts("\r\n"); response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else if (strncmp(rxbuff, BLUETOOTH_CMD_INTENSITY, strlen(BLUETOOTH_CMD_INTENSITY)) == 0) { uint8_t device = 0; char *param = rxbuff + strlen(BLUETOOTH_CMD_INTENSITY) + 1; if (strncmp(param, BLUETOOTH_CMD_EYES, strlen(BLUETOOTH_CMD_EYES)) == 0) { if (len == strlen(BLUETOOTH_CMD_INTENSITY) + strlen(BLUETOOTH_CMD_EYES) + 3) { device = EYES; } else if (len == strlen(BLUETOOTH_CMD_INTENSITY) + strlen(BLUETOOTH_CMD_EYES) + 1) { device = EYES; response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else if (strncmp(param, BLUETOOTH_CMD_REPULSORS, strlen(BLUETOOTH_CMD_REPULSORS)) == 0) { if (len == strlen(BLUETOOTH_CMD_INTENSITY) + strlen(BLUETOOTH_CMD_REPULSORS) + 3) { device = REPULSORS_POWER; } else if (len == strlen(BLUETOOTH_CMD_INTENSITY) + strlen(BLUETOOTH_CMD_REPULSORS) + 1) { device = REPULSORS_POWER; response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else if (strncmp(param, BLUETOOTH_CMD_UNIBEAM, strlen(BLUETOOTH_CMD_UNIBEAM)) == 0) { if (len == strlen(BLUETOOTH_CMD_INTENSITY) + strlen(BLUETOOTH_CMD_UNIBEAM) + 3) { device = UNIBEAM; } else if (len == strlen(BLUETOOTH_CMD_INTENSITY) + strlen(BLUETOOTH_CMD_UNIBEAM) + 1) { device = UNIBEAM; response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else { response = RESPONSE_ERROR; } if (response == RESPONSE_OK) { // convert number in ascii to integer uint8_t intensity = rxbuff[len - 1] - '0'; if ((intensity >= 0) && (intensity <= 9)) { power_set_intensity(device, intensity); } else { response = RESPONSE_ERROR; } } else if (response == RESPONSE_NO_RESPONSE) { int8_t intensity = power_get_intensity(device); uart_puts(BLUETOOTH_CMD_INTENSITY); uart_puts(": "); uart_putc('0' + intensity); uart_puts("\r\n"); } } else if (strncmp(rxbuff, BLUETOOTH_CMD_QUOTE, len) == 0) { if (voice_is_playing()) { voice_stop_playback(); } else { voice_play_quote(); } } else if (strncmp(rxbuff, BLUETOOTH_CMD_REBOOT, len) == 0) { response = RESPONSE_NO_RESPONSE; // stop reporting of battery status battery_reporting_stop(); voice_play_sound(SOUND_SLEEP_0); _delay_ms(1000); voice_play_sound(SOUND_SLEEP_2); voice_play_sound_no_wait(SOUND_POWER_DOWN); // turn off all devices power_off(ALL); // restart mcu wdt_reboot(); } else if (strncmp(rxbuff, BLUETOOTH_CMD_REPULSORS, strlen(BLUETOOTH_CMD_REPULSORS)) == 0) { char *param = rxbuff + strlen(BLUETOOTH_CMD_REPULSORS) + 1; if (len == strlen(BLUETOOTH_CMD_REPULSORS) + strlen(BLUETOOTH_PARAM_ON) + 1) { if (strncmp(param, BLUETOOTH_PARAM_ON, strlen(BLUETOOTH_PARAM_ON)) == 0) { power_on(REPULSORS_POWER); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_REPULSORS) + strlen(BLUETOOTH_PARAM_OFF) + 1) { if (strncmp(param, BLUETOOTH_PARAM_OFF, strlen(BLUETOOTH_PARAM_OFF)) == 0) { power_off(REPULSORS_POWER); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_REPULSORS)) { uint8_t state = power_state(REPULSORS_POWER); uart_puts(BLUETOOTH_CMD_REPULSORS); uart_puts(": "); if (state == POWER_ON) { uart_puts(BLUETOOTH_PARAM_ON); } else { uart_puts(BLUETOOTH_PARAM_OFF); } uart_puts("\r\n"); response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else if (strncmp(rxbuff, BLUETOOTH_CMD_REPULSOR, strlen(BLUETOOTH_CMD_REPULSOR)) == 0) { char *param = rxbuff + strlen(BLUETOOTH_CMD_REPULSOR) + 1; if (len == strlen(BLUETOOTH_CMD_REPULSOR) + strlen(BLUETOOTH_PARAM_LEFT) + 1) { if (strncmp(param, BLUETOOTH_PARAM_LEFT, strlen(BLUETOOTH_PARAM_LEFT)) == 0) { power_blast(REPULSOR_LEFT); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_REPULSOR) + strlen(BLUETOOTH_PARAM_RIGHT) + 1) { if (strncmp(param, BLUETOOTH_PARAM_RIGHT, strlen(BLUETOOTH_PARAM_RIGHT)) == 0) { power_blast(REPULSOR_RIGHT); } else { response = RESPONSE_ERROR; } } else { response = RESPONSE_ERROR; } } else if (strncmp(rxbuff, BLUETOOTH_CMD_UNIBEAM, strlen(BLUETOOTH_CMD_UNIBEAM)) == 0) { char *param = rxbuff + strlen(BLUETOOTH_CMD_UNIBEAM) + 1; if (len == strlen(BLUETOOTH_CMD_UNIBEAM) + strlen(BLUETOOTH_PARAM_ON) + 1) { if (strncmp(param, BLUETOOTH_PARAM_ON, strlen(BLUETOOTH_PARAM_ON)) == 0) { power_on(UNIBEAM); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_UNIBEAM) + strlen(BLUETOOTH_PARAM_OFF) + 1) { if (strncmp(param, BLUETOOTH_PARAM_OFF, strlen(BLUETOOTH_PARAM_OFF)) == 0) { power_off(UNIBEAM); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_UNIBEAM)) { uint8_t state = power_state(UNIBEAM); uart_puts(BLUETOOTH_CMD_UNIBEAM); uart_puts(": "); if (state == POWER_ON) { uart_puts(BLUETOOTH_PARAM_ON); } else { uart_puts(BLUETOOTH_PARAM_OFF); } uart_puts("\r\n"); response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else if (strncmp(rxbuff, BLUETOOTH_CMD_VERSION, len) == 0) { uart_puts(BLUETOOTH_RESPONSE_VERSION); uart_puts("\r\n"); response = RESPONSE_NO_RESPONSE; } else if (strncmp(rxbuff, BLUETOOTH_CMD_VOLUME, strlen(BLUETOOTH_CMD_VOLUME)) == 0) { if (len == strlen(BLUETOOTH_CMD_VOLUME) + 2) { // convert number in ascii to integer uint8_t volume = rxbuff[len - 1] - '0'; if ((volume >= 0) && (volume <= 7)) { voice_set_volume(SOUND_VOLUME_0 + volume); } else { response = RESPONSE_ERROR; } } else if (len == strlen(BLUETOOTH_CMD_VOLUME)) { uint8_t volume = voice_get_volume() - SOUND_VOLUME_0; uart_puts(BLUETOOTH_CMD_VOLUME); uart_puts(": "); uart_putc('0' + volume); uart_puts("\r\n"); response = RESPONSE_NO_RESPONSE; } else { response = RESPONSE_ERROR; } } else { response = RESPONSE_ERROR; } if (response == RESPONSE_OK) { uart_puts(BLUETOOTH_RESPONSE_OK); uart_puts("\r\n"); } else if (response == RESPONSE_ERROR) { uart_puts(BLUETOOTH_RESPONSE_ERROR); uart_puts("\r\n"); } if (echo) { uart_puts(BLUETOOTH_PROMPT); } }
/* * //~ uart_puts_P("G21\n"); //~ get_grbl_response(); //~ uart_puts_P("G90\n"); //~ get_grbl_response(); //~ uart_puts_P("G94\n"); //~ get_grbl_response(); //~ uart_puts_P("G17\n"); //~ get_grbl_response(); //~ uart_puts_P("M3 S1000\n"); //~ get_grbl_response(); //~ uart_puts_P("F800.00\n"); //~ get_grbl_response(); //~ uart_puts_P("G0 Z1.00\n"); //~ get_grbl_response(); //~ uart_puts_P("G0 X15 Y15\n"); //~ get_grbl_response(); //~ uart_puts_P("G1 Z-1\n"); //~ get_grbl_response(); //~ uart_puts_P("G2 X25 Y25 I10\n"); //~ get_grbl_response(); //~ uart_puts_P("G0 Z1\n"); //~ get_grbl_response(); //~ uart_puts_P("G0 X35 Y15\n"); //~ get_grbl_response(); //~ uart_puts_P("G1 Z-1\n"); //~ get_grbl_response(); //~ uart_puts_P("G2 X25 Y5 I-10\n"); //~ get_grbl_response(); //~ uart_puts_P("G0 Z1\n"); //~ get_grbl_response(); //~ uart_puts_P("G0 X15 Y15\n"); //~ get_grbl_response(); //~ uart_puts_P("M5\n"); //~ get_grbl_response(); //~ uart_puts_P("M30\n"); */ int main(void) { stdout = &mystdout; //uart_init(UART_BAUD_SELECT_DOUBLE_SPEED(UART_BAUD_RATE,F_CPU)); uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU)); lcd_init(LCD_DISP_ON_CURSOR); lcd_clrscr(); lcd_gotoxy(0,0); lcd_puts_P("Needler v0.7\n"); lcd_gotoxy(0,1); lcd_puts_P(__DATE__" aw"); //Delay for Splash for(uint8_t i=0;i<160;++i) _delay_ms(15); //PD2: IN : Z_DIR //PD3: IN : Enable/FEED HOLD. 0=betätigt //PD6: OUT: Relais Pneumatikventil. 1=EIN DDRD |= _BV(PD6); PORTD |= _BV(PD2) | _BV(PD3) | _BV(PD4) | _BV(PD5) | _BV(PD7); //PB1: IN: Z_STEP PORTB |= _BV(PB1); lcd_clrscr(); clr_text_buffer(); strncpy(font_name,"rowmans",10); /*** TIMER0 ***/ OCR0=250; //CTC = Clear Timer on Compare match S.80 //Normal port operation, OC0 disconnected //Prescaler=64 -> clk=250kHz TCCR0 = _BV(WGM01) | _BV(CS01) | _BV(CS00); //On Compare match Interrupt Enable for timer 0 TIMSK |= _BV(OCIE0); /** TIMER1 **/ //PWM Phase correct 10bit //Set OC1A+OC1B on match when upcounting (page 108) //TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(COM1A0) | _BV(COM1B0) | _BV(WGM11) | _BV(WGM10); //Prescaler = 1 (page 110) //TCCR1B = _BV(CS10); /** TIMER1 **/ //External clock source on T1 pin. Clock on rising edge. TCCR1B = _BV(CS12) | _BV(CS11) | _BV(CS10); //OCR1x=5; /** External Interrupt INT0 PD2 **/ //Any logical change on INT0 generates an interrupt request. MCUCR = _BV(ISC00); GICR = _BV (INT0); //enable global interrupts sei(); uint8_t debounce_key=0, last_key=0; uint8_t key, event=0; for (;;) /* main event loop */ { key=key_get(); if(key==last_key) debounce_key++; else debounce_key=0; if(debounce_key>50) { event=process_menu(key); debounce_key=0; } last_key=key; if(do_update_lcd || event) { update_lcd(); do_update_lcd=0; } if (bit_is_clear(PIND,3) && !running) { grbl_num_err=0; grbl_num_ok=0; //empty read while(uart_getc()!=UART_NO_DATA); running=1; update_status_lcd(); uart_puts_P("$X\n"); get_grbl_response(); strncpy(grbl_error_msg, "$H:Referenzfahrt",17); update_status_lcd(); uart_puts_P("$H\n"); get_grbl_response(); strncpy(grbl_error_msg, "Gravur laeuft...",17); update_status_lcd(); //int init_get_gcode_line ( char *font, char *text, double X0, double Y0, double Z_up, double Z_down, double yinc, double scale, //double feed, int precision, char verbose, char align, char use_inch); //int r = init_get_gcode_line("rowmans", "Hello world!", 1, 1, 1, -1, 7, 0.3, 1100, 3, 0, 'l', 0); uint8_t line_nr; double scale=font_size*0.047619; double x0, y0; char line[BUFFER_WIDTH]; for(line_nr=0; line_nr<BUFFER_HEIGHT; line_nr++) { strncpy(line, get_text_buffer(line_nr), BUFFER_WIDTH); //Leerzeichen am Ende mit 0 füllen int8_t len = BUFFER_WIDTH-1; while(len>=0 && line[len]==' ') line[len--]=0; //Positionsberechnung //Die Alukärtchen haben 85x54mm x0 = 7; //10mm vorerst fix, wie einstellbar? y0 = 50 - (line_nr+1) * (font_size*1.7); //70% der Zeichenhöhe als Zeilenabstand //~ uart_puts_P("-"); //~ uart_puts(line); //~ uart_puts_P("-"); //~ char xtemp[5]; //~ itoa(len,xtemp,10); //~ uart_puts(xtemp); //~ uart_puts_P("----"); if(len>=0) { init_get_gcode_line(font_name, line, x0, y0, 1, -1, 0, scale, 1300, 2, 0, 'l', 0); char buf[200]; while((g_line = get_gcode_line (buf, 200))!=-1) { uart_puts(buf); uart_putc('\n'); get_grbl_response(); } } } strncpy(grbl_error_msg, "*** BEENDET ***",17); update_status_lcd(); PORTD &= (uint8_t) ~_BV(PD6); uart_puts_P("G0X1Y1\n"); uart_puts_P("M30\n"); //empty read while(uart_getc()!=UART_NO_DATA); //BEENDET etwas stehen lassen for(uint8_t i=0;i<200;++i) _delay_ms(10); grbl_error_msg[0]=0; do_update_lcd=1; running=0; } } return 0; }
void HardwareSerial::flush() { cli(); _rxfifo->idx_r = _rxfifo->idx_w = 0; sei(); }
/* * Do all the startup-time peripheral initializations. */ static void ioinit(void) { uint16_t pwm_from_eeprom; /* * Set up the 16-bit timer 1. * * Timer 1 will be set up as a 10-bit phase-correct PWM (WGM10 and * WGM11 bits), with OC1A used as PWM output. OC1A will be set when * up-counting, and cleared when down-counting (COM1A1|COM1A0), this * matches the behaviour needed by the STK500's low-active LEDs. * The timer will runn on full MCU clock (1 MHz, CS10 in TCCR1B). */ TCCR1A = _BV(WGM10) | _BV(WGM11) | _BV(COM1A1) | _BV(COM1A0); TCCR1B = _BV(CS10); OCR1A = 0; /* set PWM value to 0 */ /* enable pull-ups for pushbuttons */ CONTROL_PORT = _BV(TRIGGER_DOWN) | _BV(TRIGGER_UP) | _BV(TRIGGER_ADC); /* * Enable Port D outputs: PD6 for the clock output, PD7 for the LED * flasher. PD1 is UART TxD but not DDRD setting is provided for * that, as enabling the UART transmitter will automatically turn * this pin into an output. */ CONTROL_DDR = _BV(CLOCKOUT) | _BV(FLASH); /* * As the location of OC1A differs between supported MCU types, we * enable that output separately here. Note that the DDRx register * *might* be the same as CONTROL_DDR above, so make sure to not * clobber it. */ PWMDDR |= _BV(PWMOUT); UCSRA = _BV(U2X); /* improves baud rate error @ F_CPU = 1 MHz */ UCSRB = _BV(TXEN)|_BV(RXEN)|_BV(RXCIE); /* tx/rx enable, rx complete intr */ UBRRL = (F_CPU / (8 * 9600UL)) - 1; /* 9600 Bd */ /* * enable ADC, select ADC clock = F_CPU / 8 (i.e. 125 kHz) */ ADCSRA = _BV(ADEN) | _BV(ADPS1) | _BV(ADPS0); TIMSK = _BV(TOIE1); sei(); /* enable interrupts */ /* * Enable the watchdog with the largest prescaler. Will cause a * watchdog reset after approximately 2 s @ Vcc = 5 V */ wdt_enable(WDTO_2S); /* * Read the value from EEPROM. If it is not 0xffff (erased cells), * use it as the starting value for the PWM. */ if ((pwm_from_eeprom = eeprom_read_word(&ee_pwm)) != 0xffff) OCR1A = (pwm = pwm_from_eeprom); }
int main( ) { uint8_t frame; static uint8_t i; static uint16_t adcT = 0; //ADC Temp static uint16_t adcP = 0; //ADC Pin static uint8_t last_timercycle = 0; cli(); setup_clock(); //1st let's see how fast we can clock the pin. et_init( MyMAC ); i = 0; //Assumed setup: // // PB2: Disconnect this (I don't know if you can use it at all) // PB1: TX (From this device, out) Put a 47nF capcaitor in series. //Enable ADC. (For reading in pin ADC2) PORTB &= ~_BV(4); PORTB |= _BV(4); ADCSRA = _BV(ADEN) | _BV(ADPS1) | _BV(ADPS0) | _BV(ADSC) | _BV(ADATE); //Enable port B for the WS2812B. WSDDR |= WSPIN; WSPORT &= ~WSPIN; //The burden of configuring the tick timer is on you, the user. //#188 Creates a clock with period ~4ms. ~3.2ms at 31MHz, ~4.8ms at 20 MHz. //Making it lower seems to help. TCCR1 = _BV(CTC1) | _BV(CS13) | _BV(CS12); //HS Clock/2048 OCR1C = 255; OCR1A = 1; TIMSK = _BV(OCIE1A); //Enable Pin Change Interrupt. //(For if we have some RX data) PCMSK |= _BV(PCINT0); GIMSK |= _BV(PCIE); sei(); OSCCAL = OSCHIGH; PORTB |= _BV(0); while(1) { if( last_timercycle != timercycle ) { last_timercycle = timercycle; //i++; i = timercycle & 0x0f; if( i == 0 ) { ADMUX = 2; } if( i == 1 ) { adcP = ADC; ADMUX = _BV(REFS1) | 0x0f; } if( i == 2 ) { adcT = ADC; } if( i == 14 ) { frame++; //How to send a UDP Packet. cli(); OSCCAL = OSC20; et_stopop(); et_startsend( 0 ); memset( macfrom, 0xff, 6 ); send_etherlink_header( 0x0800 ); send_ip_header( 0, (unsigned char*)"\xff\xff\xff\xff", 17 ); //UDP Packet to 255.255.255.255 et_push16( 13313 ); //to port et_push16( 13312 ); //from port et_push16( 0 ); //length for later et_push16( 0 ); //csum for later et_pushpgmstr( PSTR( "TPIN" ) ); //csum for later et_push16( adcT ); et_push16( adcP ); et_push16( icmp_out ); et_push16( hict ); et_push16( lowct ); util_finish_udp_packet(); OSCCAL = OSCHIGH; sei(); i = 0; } } } return 0; }
/****************************************************************************** * File: main.c * Author: Kevin Day * Date: February, 2005 * Description: * Main program for audi radio interface * * Copyright (c) 2005 Kevin Day * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * *******************************************************************************/ #include <avr/interrupt.h> #include <avr/pgmspace.h> #include <avr/io.h> #include <avr/wdt.h> #include "types.h" #include "tasks.h" #include "comms_generic.h" #include "timers.h" #include "adc.h" #include "persist.h" #include "hcms.h" #include "gpsavr.h" #include "hud.h" #include "spimaster.h" #include "avrcan.h" #include "avrms2.h" #include "swuart.h" #include "hwi2c.h" #include "adcgauges.h" #include "miscgpio.h" #include "sensors.h" #define LED_PORT PORTG #define LED_DIR DDRG #define LED_PIN PING #define LED_BIT 0 #define ANT_PORT PORTB #define ANT_DIR DDRB #define ANT_PIN PINB #define ANT_BIT 2 void debug_led(u8 val); static inline void start_blink_timer(); void bufferpool_init(); task_t* comms_task_create(); task_t *radio_input_task_create(); #define STACK_CANARY 0xC5 void StackPaint(void) __attribute__ ((naked)) __attribute__ ((section (".init1"))); void StackPaint(void) { #if 0 uint8_t *p = &_end; while(p <= &__stack) { *p = STACK_CANARY; p++; } #else __asm volatile (" ldi r30,lo8(_end)\n" " ldi r31,hi8(_end)\n" " ldi r24,lo8(0xc5)\n" /* STACK_CANARY = 0xc5 */ " ldi r25,hi8(__stack)\n" " rjmp .cmp\n" ".loop:\n" " st Z+,r24\n" ".cmp:\n" " cpi r30,lo8(__stack)\n" " cpc r31,r25\n" " brlo .loop\n" " breq .loop"::); #endif } extern uint8_t __heap_start; /* not _end because of .bufferpool */ extern uint8_t __stack; uint16_t StackCount(void) { const uint8_t *p = &__heap_start; uint16_t c = 0; while(*p == STACK_CANARY && p <= &__stack) { p++; c++; } return c; } #define ADC_CONTEXTS 8 adc_context_t adc_context[ADC_CONTEXTS]; u8 num_adc; u16 stack_high; #define DISPAVR_RESET_PIN 4 /* on port B */ int main() { u8 mcusr_rst = MCUSR; MCUSR = 0; wdt_disable(); wdt_enable(WDTO_2S); /* Disable JTAG so the ADC pins are available. * Don't do this if the JTAG reset flag is set -- * presumably the jtag pod is connected in that * case. */ if (! (mcusr_rst & (1<<JTRF))) { MCUCR |= (1<<JTD); } /* Assert remote AVR reset */ PORTB &= ~(1<<DISPAVR_RESET_PIN); DDRB |= (1<<DISPAVR_RESET_PIN); bufferpool_init(); init_persist_data(); systimer_init(); //fuel_gauge_init(&adc_context[num_adc++]); num_adc = sensors_init(&adc_context[num_adc], num_adc); adc_init_adc(ADC_DIV128, num_adc, adc_context); /* Deassert remote AVR reset */ PORTB |= (1<<DISPAVR_RESET_PIN); spimaster_init(); init_avrms2(); // swuart_init(); /* Enable interrupts */ sei(); /* Populate the tasklist in priority order */ tasklist[num_tasks++] = comms_task_create(); tasklist[num_tasks++] = gps_task_create(); tasklist[num_tasks++] = can_task_create(); tasklist[num_tasks++] = hud_task_create(); // tasklist[num_tasks++] = i2c_task_create(); tasklist[num_tasks++] = gpio_task_create(); // start_blink_timer(); /* non-preemptive static priority scheduler */ while(1) { wdt_reset(); u8 taskidx; u8 r; for(taskidx=0; taskidx<num_tasks; taskidx++) { r = tasklist[taskidx]->taskfunc(); if (r) break; } if (r == 0) { stack_high = StackCount(); /* only run this after all tasks run */ } } }
int main (void) { // disable unused functions for powersaving PRR = (1<<PRUSI) | (1<<PRUSART); DDRA = 0xff; change_clock_prescale( 0x01 ); // full speed 4MHz led_init_port(); // brownout @1.8V if device is started with insuficcient bats. if ( mcusr_mirror == (1<<BORF) ) { blink_red_powersave(); sleep_powerdown(); } uint8_t i=0; // selected pattern; uint8_t pwrhyst = 0; // switch on stepup, change frequency after short delay POWER_DDR |= (1<<POWER_PIN); POWER_PORT |= (1<<POWER_PIN); // bat comparator ACSR = (1<<ACBG); DIDR |= (1<<AIN1D); // init pwm counter led_init_timer(); key_init_timer_port(); // alive signal pled_on( (1<<PLED_RED) | (1<<PLED_GREEN) ); led_set_mode_r( 0x11, 0x11, 0 ); _delay_ms(50); led_set_mode_r( 0x00, 0x00, 0 ); _delay_ms(500); pled_off( (1<<PLED_RED) ); // check initial bat state for undervolt if ( (ACSR & (1<<ACO)) ) pwrhyst = 0xFF; sei(); for(;;) { for(uint8_t r=0; r< (*light_patterns[i]).rotate; r++) { // if there is a change to measure with leds off, then here // => check bat voltage if ( ACSR & (1<<ACO) ) { if ( pwrhyst == 0x0f ) { pled_on( 1<<PLED_RED); pled_off(1<<PLED_GREEN); } else { pwrhyst++; } } else { if ( pwrhyst == 0x00 ) { pled_on(1<<PLED_GREEN); pled_off( 1<<PLED_RED); } else { pwrhyst--; } } for(uint8_t p=0; p<(*light_patterns[i]).nr_elements; p++) { if ( key_press & ALL_KEYS ) { pwrhyst = 0; led_set_mode_r(0x00,0x00,0); if( get_key_short( 1<<KEY0 )) { r = 0; p = 0; i++; if ( i >= sizeof(light_patterns)/sizeof(light_patterns[0]) ) i = 0; } if( get_key_long( 1<<KEY0 )) { pled_off( (1<<PLED_RED) | (1<<PLED_GREEN) ); // wait for key release (with pullup=>1) loop_until_bit_is_set( KEY_PIN, KEY0 ); sleep_powerdown(); } } else { led_set_mode_r( (*light_patterns[i]->lp_elements)[p]->l12, (*light_patterns[i]->lp_elements)[p]->l34, r); key_wait_times_5ms( (*light_patterns[i]->lp_elements)[p]->duration ); } } } } }
int main(void) { char c; unsigned short cnt = 0; #if (F_CPU > 4000000UL) #define CNTHALLO (unsigned int)(0xFFFF) #else #define CNTHALLO (unsigned int)(0xFFFF/3) #endif unsigned short mycnt=0; CLKPR=_BV(CLKPCE); CLKPR=0; pir=0; DDRA |= 0xe2; PORTA |= 0x81; adc_init(); softuart_init(); TCCR1A=_BV(COM0B1)|_BV(WGM00); TCCR1B=_BV(CS00); softuart_turn_rx_on(); /* redundant - on by default */ sei(); #if WITH_STDIO_DEMO stdio_demo_func(); #endif OCR1A=0x10; OCR1B=0xf0; for (;;) { if((PINB&4)==4 ) pir=1; if ( softuart_kbhit() ) { c = softuart_getchar(); //softuart_putchar( '[' ); //softuart_putchar( c ); //softuart_putchar( ']' ); if(c=='g') { c=softuart_getchar(); if(c==C_ID(ID)) { softuart_putchar(3); softuart_putchar(2); send(); pir=0; } } else if( c=='s') { unsigned int pwm; c=softuart_getchar(); if(c==C_ID(ID)) { sprintf(line,"made it"); // char line[32]; for(cnt=0;cnt<=31;cnt++) { c=softuart_getchar(); if(c=='\n') {line[cnt]=0; break;} else line[cnt]=c; } int ret=sscanf_P(&line[0],PSTR("inTopic/pwm/"STD_ID(ID)" %d"),&pwm); sprintf_P(dbg,PSTR("%dpwm:%d"),ret,pwm); OCR1B=pwm; } } } } return 0; /* never reached */ }
void set_date(){ clear_pixelMatrix(); print_date(POS_DATE_SET); print_year(); print_symbol(16,17, hakenSymb,108,46); print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, get_dateXPos() + get_dayWidth() / 2 - 4, POS_DATE_SET - 10); update_LCD(); int old_selectedItem = 0; int item = 0; while (item != 3){ cli(); btn_drehenc_pushed = false; sei(); while(!btn_drehenc_pushed){ if(rotary != 0){ item += rotary; cli(); rotary = 0; sei(); item = item % 4; if(item<0){ item += 4; } switch (old_selectedItem){ case 0: for(int x = 0; x<128; x++){ for(int y = 0; y<10; y++) reset_pixel(x,y); } break; case 1: for(int x = 0; x<128; x++){ for(int y = 0; y<10; y++) reset_pixel(x,y); }break; case 2: for(int x = 0; x<128; x++){ for(int y = 30; y<40; y++) reset_pixel(x,y); }break; case 3: for(int x = 94; x<104; x++){ for(int y = 2+3*15+5; y<2+3*15+5+8; y++) reset_pixel(x,y); }break; } switch (item) { case 0: print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, get_dateXPos() + get_dayWidth() / 2 - 4, POS_DATE_SET - 10); break; //-4 = halbe Länge Herz case 1: print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, get_dateXPos() + get_dayWidth() + get_monthWidth() / 2 - 4, POS_DATE_SET - 10); break; case 2: print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, get_yearXPos() + get_yearWidth() / 2 - 4, YPOS_YEAR - 10);break; case 3: print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, 94, 2+3*15+5);break; } old_selectedItem = item; update_LCD(); } goodNight(); check_light(); } cli(); btn_drehenc_pushed = false; sei(); switch (item) { case 0: { print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinOffenSymb, get_dateXPos() + get_dayWidth() / 2 - 4, POS_DATE_SET - 10); update_LCD(); set_day(); print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, get_dateXPos() + get_dayWidth() / 2 - 4, POS_DATE_SET - 10); break; } case 1:{ print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinOffenSymb, get_dateXPos() + get_dayWidth() + get_monthWidth() / 2 - 4, POS_DATE_SET - 10); update_LCD(); set_month(); print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, get_dateXPos() + get_dayWidth() + get_monthWidth() / 2 - 4, POS_DATE_SET - 10); break; } case 2: { print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinOffenSymb, get_yearXPos() + get_yearWidth() / 2 - 4, YPOS_YEAR - 10); update_LCD(); set_year(); print_symbol(8, HERZ_KLEIN_WIDTH, herzKleinSymb, get_yearXPos() + get_yearWidth() / 2 - 4, YPOS_YEAR - 10); break; } default: break; } update_LCD(); } }
int main(void) { #ifndef HOST_VERSION /* brake */ BRAKE_DDR(); BRAKE_OFF(); /* CPLD reset on PG3 */ DDRG |= 1<<3; PORTG &= ~(1<<3); /* implicit */ /* LEDS */ DDRJ |= 0x0c; DDRL = 0xc0; LED1_OFF(); LED2_OFF(); LED3_OFF(); LED4_OFF(); #endif memset(&gen, 0, sizeof(gen)); memset(&mainboard, 0, sizeof(mainboard)); mainboard.flags = DO_ENCODERS | DO_CS | DO_RS | DO_POS | DO_POWER | DO_BD | DO_ERRBLOCKING; ballboard.lcob = I2C_COB_NONE; ballboard.rcob = I2C_COB_NONE; /* UART */ uart_init(); uart_register_rx_event(CMDLINE_UART, emergency); #ifndef HOST_VERSION #if CMDLINE_UART == 3 fdevopen(uart3_dev_send, uart3_dev_recv); #elif CMDLINE_UART == 1 fdevopen(uart1_dev_send, uart1_dev_recv); #endif /* check eeprom to avoid to run the bad program */ if (eeprom_read_byte(EEPROM_MAGIC_ADDRESS) != EEPROM_MAGIC_MAINBOARD) { int c; sei(); printf_P(PSTR("Bad eeprom value ('f' to force)\r\n")); c = uart_recv(CMDLINE_UART); if (c == 'f') eeprom_write_byte(EEPROM_MAGIC_ADDRESS, EEPROM_MAGIC_MAINBOARD); wait_ms(100); bootloader(); } #endif /* ! HOST_VERSION */ /* LOGS */ error_register_emerg(mylog); error_register_error(mylog); error_register_warning(mylog); error_register_notice(mylog); error_register_debug(mylog); #ifndef HOST_VERSION /* SPI + ENCODERS */ encoders_spi_init(); /* this will also init spi hardware */ /* I2C */ i2c_init(I2C_MODE_MASTER, I2C_MAINBOARD_ADDR); i2c_protocol_init(); i2c_register_recv_event(i2c_recvevent); i2c_register_send_event(i2c_sendevent); /* TIMER */ timer_init(); timer0_register_OV_intr(main_timer_interrupt); /* PWM */ PWM_NG_TIMER_16BITS_INIT(1, TIMER_16_MODE_PWM_10, TIMER1_PRESCALER_DIV_1); PWM_NG_TIMER_16BITS_INIT(4, TIMER_16_MODE_PWM_10, TIMER4_PRESCALER_DIV_1); PWM_NG_INIT16(&gen.pwm1_4A, 4, A, 10, PWM_NG_MODE_SIGNED, &PORTD, 4); PWM_NG_INIT16(&gen.pwm2_4B, 4, B, 10, PWM_NG_MODE_SIGNED | PWM_NG_MODE_SIGN_INVERTED, &PORTD, 5); PWM_NG_INIT16(&gen.pwm3_1A, 1, A, 10, PWM_NG_MODE_SIGNED, &PORTD, 6); PWM_NG_INIT16(&gen.pwm4_1B, 1, B, 10, PWM_NG_MODE_SIGNED, &PORTD, 7); /* servos */ PWM_NG_TIMER_16BITS_INIT(3, TIMER_16_MODE_PWM_10, TIMER1_PRESCALER_DIV_256); PWM_NG_INIT16(&gen.servo1, 3, C, 10, PWM_NG_MODE_NORMAL, NULL, 0); PWM_NG_TIMER_16BITS_INIT(5, TIMER_16_MODE_PWM_10, TIMER1_PRESCALER_DIV_256); PWM_NG_INIT16(&gen.servo2, 5, A, 10, PWM_NG_MODE_NORMAL, NULL, 0); PWM_NG_INIT16(&gen.servo3, 5, B, 10, PWM_NG_MODE_NORMAL, NULL, 0); PWM_NG_INIT16(&gen.servo4, 5, C, 10, PWM_NG_MODE_NORMAL, NULL, 0); support_balls_deploy(); /* init pwm for servos */ #endif /* !HOST_VERSION */ /* SCHEDULER */ scheduler_init(); #ifdef HOST_VERSION hostsim_init(); robotsim_init(); #endif #ifndef HOST_VERSION scheduler_add_periodical_event_priority(do_led_blink, NULL, 100000L / SCHEDULER_UNIT, LED_PRIO); #endif /* !HOST_VERSION */ /* all cs management */ microb_cs_init(); /* TIME */ time_init(TIME_PRIO); /* sensors, will also init hardware adc */ sensor_init(); #ifndef HOST_VERSION /* start i2c slave polling */ scheduler_add_periodical_event_priority(i2c_poll_slaves, NULL, 8000L / SCHEDULER_UNIT, I2C_POLL_PRIO); #endif /* !HOST_VERSION */ /* strat */ gen.logs[0] = E_USER_STRAT; gen.log_level = 5; /* strat-related event */ scheduler_add_periodical_event_priority(strat_event, NULL, 25000L / SCHEDULER_UNIT, STRAT_PRIO); #ifndef HOST_VERSION /* eeprom time monitor */ scheduler_add_periodical_event_priority(do_time_monitor, NULL, 1000000L / SCHEDULER_UNIT, EEPROM_TIME_PRIO); #endif /* !HOST_VERSION */ sei(); strat_db_init(); printf_P(PSTR("\r\n")); printf_P(PSTR("Respect et robustesse.\r\n")); #ifndef HOST_VERSION { uint16_t seconds; seconds = eeprom_read_word(EEPROM_TIME_ADDRESS); printf_P(PSTR("Running since %d mn %d\r\n"), seconds/60, seconds%60); } #endif #ifdef HOST_VERSION strat_reset_pos(400, COLOR_Y(400), COLOR_A(-90)); #endif cmdline_interact(); return 0; }
int main(void) { uint8_t i1, i2, i3, i4, i5; int16_t x, y, z; uint8_t rx_count, rx_length, rx_type, rx_timeout, rx_starve; uint8_t addr; uint8_t rx[80]; // usb input buffer uint8_t d[80]; uint8_t awake; uint8_t found_sub[4] = {0,0,0,0}; uint8_t offset_x[4] = {0,8,0,8}; uint8_t offset_y[4] = {0,0,8,8}; uint8_t lookup_sub[2][2] = { {100,102} , {104,106} }; uint8_t size_x, size_y; char id[32]; uint8_t output_buffer[OUTPUT_BUFFER_LENGTH]; uint8_t output_write; uint8_t output_read; uint8_t input_buffer[INPUT_BUFFER_LENGTH]; i1 = i2 = i3 = i4 = 0; rx_count = rx_type = rx_timeout = 0; rx_length = 1; input_check = 0; awake = 1; output_read = output_write = 0; DDRB = 0; DDRC = C3_WR | C2_RD; DDRD = 0; TCCR0A = 0; TCCR0B = (1<<CS02) | (1<<CS00); TIMSK0 = (1 << OCIE0A); OCR0A = GATHER_RATE; // TCCR1A = 0; // TCCR1B = (1<<CS10) | (1<<CS12); // TIMSK1 = (1<<TOIE1); sei(); twi_init(); //twi_setAddress(0); // twi_attachSlaveRxEvent(processRx); //// scan i2c bus ////////////////////////////////////////////////////// // for(i1=0;i1<4;i1++) { // addr = 100 + (i1*2); // d[0] = _LED_ALL1; // twi_writeTo(addr, d, 1, 1); // } /* _delay_ms(50); for(i1=0;i1<4;i1++) { addr = 100 + (i1*2); d[0] = _QUERY; i2 = twi_writeTo(addr, d, 1, 1); if(!i2) { found_sub[i1] = addr; // lookup_sub[offset_x[i1]>>8][offset_y[i1>>8]] = addr; //d[0] = _LED_ALL0; //twi_writeTo(addr, d, 1, 1); } } */ for(i1=0;i1<32;i1++) id[i1]=0; i1 = 0; for(i2=0;i2<4;i2++) { if(found_sub[i2]) i1++; } size_x = 0; size_y = 0; if(i1==0) { strcpy(id,"monome"); } else if(i1==1) { size_x = 8; size_y = 8; strcpy(id,"monome 64"); } else if(i1==2) { size_x = 16; size_y = 8; strcpy(id,"monome 128"); } else if(i1==4) { size_x = 16; size_y = 16; strcpy(id,"monome 256"); } // tilt setup addr = 0x53; d[0] = 0x2D; // write to power ctl d[1] = (1<<3); // set measure bit on d3 twi_writeTo(addr, d, 2, 1); /* // startup animation addr = 100; d[0] = _LED_COL; d[1] = 0; d[2] = 6; twi_writeTo(addr, d, 3, 1); _delay_ms(50); d[0] = _LED_COL; d[2] = 9; twi_writeTo(addr, d, 3, 1); d[1] = 1; d[2] = 6; twi_writeTo(addr, d, 3, 1); d[0] = _LED_INT; d[1] = 12; twi_writeTo(addr, d, 2, 1); _delay_ms(50); d[0] = _LED_COL; d[1] = 0; d[2] = 16; twi_writeTo(addr, d, 3, 1); d[1] = 1; d[2] = 9; twi_writeTo(addr, d, 3, 1); d[1] = 2; d[2] = 6; twi_writeTo(addr, d, 3, 1); d[0] = _LED_INT; d[1] = 7; twi_writeTo(addr, d, 2, 1); _delay_ms(50); d[0] = _LED_COL; d[1] = 1; d[2] = 16; twi_writeTo(addr, d, 3, 1); d[1] = 2; d[2] = 9; twi_writeTo(addr, d, 3, 1); d[1] = 3; d[2] = 6; twi_writeTo(addr, d, 3, 1); d[0] = _LED_INT; d[1] = 2; twi_writeTo(addr, d, 2, 1); _delay_ms(50); d[0] = _LED_ALL0; twi_writeTo(addr, d, 1, 1); d[0] = _LED_INT; d[1] = 15; twi_writeTo(addr, d, 2, 1); */ //// main loop ///////////////////////////////////////////////////////// while(1) { i1 = (PINB & B0_PWREN); if(i1 != awake) { if(i1) { addr = 100; d[0] = _SLEEP; twi_writeTo(addr, d, 1, 1); } else { addr = 100; d[0] = _WAKE; twi_writeTo(addr, d, 1, 1); } awake = i1; } // ====================== check/read incoming serial PORTD = 0; // setup PORTD for input DDRD = 0; // input w/ tristate if(rx_timeout > 40 ) { rx_count = 0; } else rx_timeout++; rx_starve = 0; while((PINC & C1_RXF) == 0 && rx_starve < RX_STARVE_THRESH) { rx_starve++; // make sure we process keypad data... // if we process more input bytes than RX_STARVE // we'll jump to sending out waiting keypad bytes // and then continue PORTC &= ~(C2_RD); _delay_us(1); // wait for valid data rx[rx_count] = PIND; PORTC |= C2_RD; if(rx_count == 0) { // get packet length if reading first byte rx_type = rx[0]; rx_length = usb_packet_length[rx_type]; rx_count++; rx_timeout = 0; } else rx_count++; if(rx_count == rx_length) { rx_count = 0; if(rx_type == _SYS_QUERY) { i1 = 0; for(i2=0;i2<4;i2++) { if(found_sub[i2]) i1++; } output_buffer[output_write] = _SYS_QUERY_RESPONSE; output_write++; output_buffer[output_write] = 1; output_write++; output_buffer[output_write] = i1; output_write++; output_buffer[output_write] = _SYS_QUERY_RESPONSE; output_write++; output_buffer[output_write] = 2; output_write++; output_buffer[output_write] = i1; output_write++; } else if(rx_type == _SYS_QUERY_ID) { output_buffer[output_write] = _SYS_ID; output_write++; for(i1=0;i1<32;i1++) { output_buffer[output_write] = id[i1]; output_write++; } } else if(rx_type == _SYS_WRITE_ID) { } else if(rx_type == _SYS_GET_GRID_OFFSET) { } else if(rx_type == _SYS_SET_GRID_OFFSET) { } else if(rx_type == _SYS_GET_GRID_SIZE) { output_buffer[output_write] = _SYS_REPORT_GRID_SIZE; output_write++; output_buffer[output_write] = size_x; output_write++; output_buffer[output_write] = size_y; output_write++; } else if(rx_type == _SYS_SET_GRID_SIZE) { } else if(rx_type == _SYS_SCAN_ADDR) { } else if(rx_type == _SYS_SET_ADDR) { } else if(rx_type == _SYS_QUERY_VERSION) { output_buffer[output_write] = _SYS_REPORT_VERSION; output_write++; output_buffer[output_write] = FIRMWARE_VERSION; output_write++; } else if(rx_type == _LED_SET0) { // _LED_SET0 ////////////////////////////////////////////// i1 = rx[1] >> 3; i2 = rx[2] >> 3; i3 = rx[1] & 0x07; i4 = rx[2] & 0x07; addr = lookup_sub[i2][i1]; d[0] = _LED_SET0; d[1] = (i3 << 4) + i4; twi_writeTo(addr, d, 2, 1); } else if(rx_type == _LED_SET1) { // _LED_SET1 ////////////////////////////////////////////// i1 = rx[1] >> 3; i2 = rx[2] >> 3; i3 = rx[1] & 0x07; i4 = rx[2] & 0x07; addr = lookup_sub[i2][i1]; d[0] = _LED_SET1; d[1] = (i3 << 4) + i4; twi_writeTo(addr, d, 2, 1); }
void processor_idle() { sleep_enable(); set_sleep_mode(SLEEP_MODE_IDLE); sei(); // Just in case, if this is called form an ISR sleep_cpu(); }
int main( void ) { uint32_t val = 0; char textbuf [ (2*16) + 1 ]; // lcd /* setup */ // LCD lcd_init(); // Timer: enable a timer so we can measure passage of time // // Given: 20MHz clock // --> if we want resolution of ms (1/1000th second) .. actually, we want us (1/10th of a ms) so we can measure partial ms // --> and we have 1/20000000 clock resolution // -----> 2000 ticks will get us there (20,000 will get us ms) // // Goal: Use CTC interupt mode (CTC -> Clear on Timer Compare) // So a compare matches, it clears to zero and triggers interupt TCCR1B |= (1 << WGM12); // Configure timer 1 for CTC mode OCR1A = 2000; // number to compare against TIMSK1 |= (1 << OCIE1A); // Enable CTC interrupt TCCR1B |= (1 << CS10); // Set up timer , with no prescaler (works at full MHz of clock) // Receiver setup - set up pin change interupt #if 1 EICRA &= ~ ( (1 << ISC01) | (1 << ISC01) ); // clear ISC01+ISC00 EICRA |= ( (1 << ISC00) ); // 00 set and 01 unset means any edge will make event PCMSK0 |= ( (1 << PCINT0) | (1 << PCINT1) ); // Pins to monitor: PA0 and PA1 PCICR |= (1 << PCIE0); // PA is monitored #endif // Serial - setup (for motor controller) mc_setup(); // TWI - set up unsigned char twibuf [ TWI_BUFFER_SIZE ]; unsigned char TWI_slaveAddress; TWI_slaveAddress = 0x10; // our TWI address TWI_Slave_Initialise( (unsigned char)((TWI_slaveAddress<<TWI_ADR_BITS) | (TRUE<<TWI_GEN_BIT) )); // Initialise TWI module as slave; include addr+general unsigned char twi_heartbeat_counter = 0; // setup done - kick up interupts sei(); // lets burn the first couple of seconds, so the receiver can get some signal // before we start blasting stuff into the motor controllers { unsigned int start_sec = g_time_s; while ( g_time_s - start_sec < 3 ) { nop(); } } // Start the TWI transceiver to enable reseption of the first command from the TWI Master. TWI_Start_Transceiver(); #if 1 // timer test .. show per-second counter update on lcd if ( 1 ) { unsigned int last_sec = g_time_s; unsigned int last_us = _g_time_us_tick; unsigned char sent_l = 0, sent_r = 0; char message [ 17 ]; while(1) { unsigned int ch1 = g_ch1_duration; unsigned int ch2 = g_ch2_duration; // 100ms has past? if ( _g_time_us_tick - last_us > 1000 ) { if ( g_control_twi ) { // we're on TWI control, but if nothing comes in.. revert back to RC if ( g_time_s - g_control_last_s > 2 ) { g_control_twi = 0; } } else { mc_set_by_receiver ( ch1, ch2, &sent_l, &sent_r, message ); } last_us = _g_time_us_tick; } // .1sec tick // one second has past? update lcd if ( g_time_s != last_sec ) { //sprintf ( textbuf, "recv %2d %2d ", g_ch1_duration, g_ch2_duration ); sprintf ( textbuf, "m %2d %2d th %2d %2d #", sent_l, sent_r, ch1, ch2 ); lcd_xy ( 0, 0 ); lcd_puts( textbuf ); // display number right adjusted //sprintf ( textbuf, "t%2d #", g_time_s ); sprintf ( textbuf, "t%2d # %s", g_time_s, message ); lcd_xy ( 0, 1 ); lcd_puts( textbuf ); // display number right adjusted last_sec = g_time_s; } // 1 sec tick // TWI/I2C stuff, talk to r-pi // // Check if the TWI Transceiver has completed an operation. if ( ! TWI_Transceiver_Busy() ) { // Check if the last operation was successful if ( TWI_statusReg.lastTransOK ) { // Check if the last operation was a reception if ( TWI_statusReg.RxDataInBuf ) { TWI_Get_Data_From_Transceiver ( twibuf, 3 ); // Check if the last operation was a reception as General Call if ( TWI_statusReg.genAddressCall ) { // don't care } else { // Ends up here if the last operation was a reception as Slave Address Match // Example of how to interpret a command and respond. #if 0 // TWI_CMD_MASTER_WRITE stores the data to PORTB if (twibuf[0] == TWI_CMD_MASTER_WRITE) { PORTB = twibuf[1]; } #endif // TWI_CMD_MASTER_READ prepares the data from PINB in the transceiver buffer for the TWI master to fetch. if ( twibuf[0] == tc_heartbeat ) { twibuf [ 0 ] = 1; twibuf [ 1 ] = twi_heartbeat_counter++; TWI_Start_Transceiver_With_Data ( twibuf, TWI_BUFFER_SIZE ); } else if ( twibuf[0] == tc_gethello ) { sprintf ( twibuf + 1, "hello" ); twibuf [ 0 ] = strlen ( twibuf + 1 ); // len TWI_Start_Transceiver_With_Data ( twibuf, TWI_BUFFER_SIZE ); } else if ( twibuf[0] == tc_setmotors ) { g_control_last_s = g_time_s; mc_speed ( mcm_left, twibuf [ 1 ] ); mc_speed ( mcm_right, twibuf [ 2 ] ); } else if ( twibuf[0] == tc_takeover ) { g_control_last_s = g_time_s; g_control_twi = 1; } else if ( twibuf[0] == tc_release ) { g_control_twi = 0; } else { twibuf [ 0 ] = 1; twibuf [ 1 ] = 0xde; twibuf [ 2 ] = 0xad; twibuf [ 3 ] = 0xbe; twibuf [ 4 ] = 0xef; TWI_Start_Transceiver_With_Data ( twibuf, TWI_BUFFER_SIZE ); } } } else { // Ends up here if the last operation was a transmission // don't care } // Check if the TWI Transceiver has already been started. // If not then restart it to prepare it for new receptions. if ( ! TWI_Transceiver_Busy() ) { TWI_Start_Transceiver(); } } else { // Ends up here if the last operation completed unsuccessfully TWI_Act_On_Failure_In_Last_Transmission ( TWI_Get_State_Info() ); } // success/fail } // TWI busy? // spin _delay_ms ( 20 ); } // while forever } // if 1 #endif /* churn forever */ while(1); return ( 0 ); }
/** * \brief This is main... */ int main(void) { lcd_init(); key_init(); uart_init(); eeprom_init(); temp_init(); timer_init(); sei(); lcd_symbol_set(LCD_SYMBOL_RAVEN); lcd_symbol_set(LCD_SYMBOL_IP); /* Start with main menu */ read_menu(0); /* and draw it */ lcd_puts_P(menu.text); timer_start(); for (;;){ /* Make sure interrupts are always on */ sei(); /* The one second timer has fired. */ if(timer_flag){ timer_flag = false; /* Check if main menu needs toggled. */ check_main_menu(); /* Update LCD with temp data. */ if(temp_flag){ menu_display_temp(); } /* Auto send temp data to 1284p. */ if(auto_temp){ menu_send_temp(); } /* If ping mode, send 4 ping requests and then stop. */ if(ping_mode){ if((PING_ATTEMPTS == count) && !timeout_flag){ count = 0; timeout_count = 0; menu_stop_ping(); } else if(timeout_flag){ timeout_flag = false; timeout_count++; /* Display timeout message if all PING_ATTEMPTS were not successful. */ if(PING_ATTEMPTS == timeout_count){ lcd_puts_P(PSTR("PINGS FAILED")); } } else{ count = menu_send_ping(); } } } /* Check for button press and deal with it */ if (is_button()){ /* Dispatch the button pressed */ switch (get_button()){ case KEY_UP: read_menu(menu.up); lcd_puts_P(menu.text); break; case KEY_DOWN: read_menu(menu.down); lcd_puts_P(menu.text); break; case KEY_LEFT: read_menu(menu.left); lcd_puts_P(menu.text); break; case KEY_RIGHT: /* * Check to see if we should show another menu or * run a function */ if (!menu.enter_func){ /* Just another menu to display */ read_menu(menu.right); lcd_puts_P(menu.text); break; } /* Drop through here */ case KEY_ENTER: /* Call the menu function on right or enter buttons */ if (menu.enter_func){ menu.enter_func(menu.state); if (menu.state){ /* * We just called a selection menu (not a test), * so re-display the text for this menu level */ lcd_puts_P(menu.text); } /* After enter key, check the right button menu and display. */ read_menu(menu.right); lcd_puts_P(menu.text); } break; default: break; } /* After button press, check for menus... */ check_menu(); } /* Process any progress frames */ uart_serial_rcv_frame(false); } /* end for(). */ } /* end main(). */
void main(void) { //adc_init();//initialize the LDR input DDRB |= _BV(PB0); DDRB |= _BV(PB1); DDRB |= _BV(PB2); //DDRB |= _BV(PB4); DDRB |= _BV(PB3); //CONTROL_DDR = 0xFF; // Set the Control DDR (i.e. DDRB) to be all outputs int i; // initialize for loop variables //int j; // Loop variable for OPTION 2 - If you use OPTION 1 you should comment this out or you will get a warning upon compiling //reset_SR(); // Toggle the Reset Pin on the 595 to clear out SR Set_Enable; // Set the Output Enable Pin on the 595 (PB1 in this case) LOW to allow data to show on the outputs upon being latched /* interrup setup */ // call ISR(TIM0_COMPA_vect) every 103us (for 9600 bauds) // set CTC mode : clear timer on comapre match // -> reset TCNTO (timer 0) when TCNTO == OCR0A sbi(TCCR0A, WGM01); // prescaler : clk/8 (1 tic = 1us for 8MHz clock) sbi(TCCR0B, CS01); // compare register A at 103 us OCR0A = 103; // interrupt on compare match OCROA == TCNT0 sbi(TIMSK, OCIE0A); // Enable global interrupts sei(); old_millis = millis() + 500; int numberOfTimes = rng(2, 5); for (int j=0; j<numberOfTimes; j++) myCircleLoop(); while(1) // infinite loop { //idea is to have flashes now and then, and then now and the the whole circle //int an4 = adc_read(2); if ( old_millis < millis()) { //myCircleLoop(); if ( dir == 0 ) dir = 1; else dir = 0; old_millis = millis() + 500*rng(1, 5); int myChoice = rng(0, 15); if ( myChoice == 0 ) myCircleLoop(); if ( (myChoice > 0) && (myChoice < 8) ) { int numberOfTimes = rng(2, 10); for (int j=0; j<numberOfTimes; j++) { resetOutputArray(myChoice); doLoopThing(4); for (int j2=40; j2<(40 + rng(0,10)); j2++) delay(10); resetOutputArray(10);//all zero's doLoopThing(4); for (int j2=20; j2<(20 + rng(0,10)); j2++) delay(10); } } resetOutputArray(10);//all zero's } //oldVal = an4; } // end while } // end main
int main (void) { #ifdef BOOTLOADER_SUPPORT _IVREG = _BV (IVCE); /* prepare ivec change */ _IVREG = _BV (IVSEL); /* change ivec to bootloader */ #endif /* Default DDR Config */ #if IO_HARD_PORTS >= 4 && DDR_MASK_A != 0 DDRA = DDR_MASK_A; #endif #if DDR_MASK_B != 0 DDRB = DDR_MASK_B; #endif #if DDR_MASK_C != 0 DDRC = DDR_MASK_C; #endif #if DDR_MASK_D != 0 DDRD = DDR_MASK_D; #endif #if IO_HARD_PORTS >= 6 #if DDR_MASK_E != 0 DDRE = DDR_MASK_E; #endif #if DDR_MASK_F != 0 DDRF = DDR_MASK_F; #endif #endif #if IO_HARD_PORTS >= 7 #if DDR_MASK_G != 0 DDRG = DDR_MASK_G; #endif #endif #ifdef STATUSLED_POWER_SUPPORT PIN_SET(STATUSLED_POWER); #endif //FIXME: zum ethersex meta system hinzufügen, aber vor allem anderem initalisieren debug_init(); debug_printf("ethersex " VERSION_STRING_LONG " (Debug mode)\n"); #ifdef DEBUG_RESET_REASON if (bit_is_set (mcusr_mirror, BORF)) debug_printf("reset: Brown-out\n"); else if (bit_is_set (mcusr_mirror, PORF)) debug_printf("reset: Power on\n"); else if (bit_is_set (mcusr_mirror, WDRF)) debug_printf("reset: Watchdog\n"); else if (bit_is_set (mcusr_mirror, EXTRF)) debug_printf("reset: Extern\n"); else debug_printf("reset: Unknown\n"); #endif #ifdef BOOTLOADER_SUPPORT /* disable interrupts */ cli (); wdt_disable(); #endif //BOOTLOADER_SUPPORT /* enable interrupts */ sei (); #ifdef USE_WATCHDOG debug_printf("enabling watchdog\n"); #ifdef DEBUG /* for debugging, test reset cause and jump to bootloader */ if (MCU_STATUS_REGISTER & _BV (WDRF)) { debug_printf("bootloader...\n"); jump_to_bootloader(); } #endif /* set watchdog to 2 seconds */ wdt_enable(WDTO_2S); wdt_kick(); #else //USE_WATCHDOG debug_printf("disabling watchdog\n"); wdt_disable(); #endif //USE_WATCHDOG #if defined(RFM12_SUPPORT) || defined(ENC28J60_SUPPORT) \ || defined(DATAFLASH_SUPPORT) spi_init(); #endif ethersex_meta_init(); /* must be called AFTER all other initialization */ #ifdef PORTIO_SUPPORT portio_init(); #elif defined(NAMED_PIN_SUPPORT) np_simple_init(); #endif #ifdef ENC28J60_SUPPORT debug_printf ("enc28j60 revision 0x%x\n", read_control_register (REG_EREVID)); debug_printf ("mac: %02x:%02x:%02x:%02x:%02x:%02x\n", uip_ethaddr.addr[0], uip_ethaddr.addr[1], uip_ethaddr.addr[2], uip_ethaddr.addr[3], uip_ethaddr.addr[4], uip_ethaddr.addr[5]); #endif #ifdef STATUSLED_BOOTED_SUPPORT PIN_SET(STATUSLED_BOOTED); #endif ethersex_meta_startup(); /* main loop */ while (1) { wdt_kick(); ethersex_meta_mainloop(); #ifdef SD_READER_SUPPORT if (sd_active_partition == NULL) { if (!sd_try_init()) { #ifdef VFS_SD_SUPPORT vfs_sd_try_open_rootnode(); #endif } wdt_kick(); } #endif #ifdef BOOTLOADER_JUMP if (status.request_bootloader) { #ifdef MBR_SUPPORT mbr_config.bootloader = 1; write_mbr(); #endif #ifdef CLOCK_CRYSTAL_SUPPORT TC2_INT_OVERFLOW_OFF; #endif #ifdef DCF77_SUPPORT ACSR &= ~_BV (ACIE); #endif cli(); jump_to_bootloader(); } #endif #ifndef TEENSY_SUPPORT if (status.request_wdreset) { cli(); wdt_enable(WDTO_15MS); for (;;); } #endif if (status.request_reset) { cli(); void (*reset) (void) = NULL; reset(); } } }
int main (void) { int tmp,i,res; CLKPR = 0x80; CLKPR = 0x00; // Clock prescaler Reset /*-----------------------------------------------------------------* *------------------------- Gear buttoms setup---------------------* *-----------------------------------------------------------------*/ DDRC&=~(1<<PC7); // Neutral PORTC |= (1<<PC7); // Neutral pull-up DDRE&=~(1<<PE6); // Knap1 DDRE&=~(1<<PE7); // Knap2 /* Buttoms interrupt */ EICRB |= (1<<ISC71|1<<ISC70|1<<ISC61|1<<ISC60); /* Rising edge */ EIMSK |= (1<<INT7 | 1<<INT6); uint8_t test_rx[8]; int8_t data; char streng[10]; // Recieve buffer st_cmd_t msg; // Init CAN, UART, I/O init(); uartinit(); sendtekst("UART initialized\n\r"); TWI_init(); sendtekst("TWI initialized\n\r"); sei(); /* Interrupt enable */ sendtekst("Interrupt enabled\n\r"); /*-----------------------------------------------------------------* *----------------------------Display setup -----------------------* *-----------------------------------------------------------------*/ /* Set blink rates */ set_blink_rate(LED0_7_ADDR, LED_BLINK1, 20, 100); set_blink_rate(LED0_7_ADDR, LED_BLINK2, 0, RPM_LED_DUTYCYCLE*2.56); set_blink_rate(LED8_15_ADDR, LED_BLINK1, (1.0/RPM16_RATE)*252, RPM16_DUTYCYCLE*2.56); set_blink_rate(LED8_15_ADDR, LED_BLINK2, 0, RPM_LED_DUTYCYCLE*2.56); set_blink_rate(SEG_ADDR, LED_BLINK1, 20, 100); set_blink_rate(SEG_ADDR, LED_BLINK2, 0, SEG_DUTYCYCLE*2.56); set_blink_rate(LED_BUTTONS_ADDR, LED_BLINK1, 20, 100); set_blink_rate(LED_BUTTONS_ADDR, LED_BLINK2, 0, SEG_DUTYCYCLE*2.56); /*-----------------------------------------------------------------* *----------------------------CAN interrupt setup -----------------* *-----------------------------------------------------------------*/ Can_sei(); /* Enable general can interrupt */ Can_set_tx_int(); /* Enable can tx interrupt */ Can_set_rx_int(); /* Enable can rx interrupt */ /* * Kode til hurtig test af can */ sendtekst("Config 3 mailboxes for rpm_msgid...\n\r"); msg.id.std = rpm_msgid; msg.dlc = 8; res = can_config_rx_mailbox(&msg, 3); if (res == CAN_CMD_ACCEPTED) { sendtekst("SUCCESS\n\r"); } else { sendtekst("FAIL\n\r"); } // --- Init variables /* Init user led 0 & 1 */ DDRB |= (1<<PB6 | 1<<PB5); PORTB |= (1<<PB6 | 1<<PB5); sendtekst("Beep\n\r"); display_test(); params.GearEst = 0; char dataout[] = {gear,0}; while (1) { _delay_ms(20); /* Display selected parameter */ if (mode == RPM_MODE) { set_rpm(params.rpm, LED_ON); } else if (mode == VOLTAGE_MODE) { set_voltage(params.batteryV, LED_ON); } else if (mode == WATER_TEMP_MODE) { set_water_temp(params.waterTemp, LED_ON); } // Geat buttons to CAN dataout[1] = 0; /* Format buttom states for sending */ dataout[1] |= (params.GearButDown*GEARDOWNBUT | GEARUPBUT*params.GearButUp | params.GearButNeutral*GEARNEUBUT); /* Send buttom states */ if(dataout[1] != 0) { // Hack, sender gearskiftesignal et par gange, sådan at det går igennem // Symptombehandling, sygdommen skal kureres... if (dataout[1] & (GEARDOWNBUT) == GEARDOWNBUT) indi_leds_state |= (LED_BLINK2<<LED_BUTTON_1); if (dataout[1] & (GEARUPBUT) == GEARUPBUT) indi_leds_state |= (LED_BLINK2<<LED_BUTTON_1); set_leds(LED_BUTTONS_ADDR, indi_leds_state); for(j=0;j<1;j++){ can_send_non_blocking(gear_msgid, dataout, 2); _delay_ms(5); } indi_leds_state &= ~(LED_BLINK2<<LED_BUTTON_2); indi_leds_state &= ~(LED_BLINK2<<LED_BUTTON_1); set_leds(LED_BUTTONS_ADDR, indi_leds_state); } /* Clear buttom states */ params.GearButDown = 0; params.GearButUp = 0; params.GearButNeutral = 0; /* Display bottons code */ buttons_state = get_buttons(LED_BUTTONS_ADDR) & (BUTTON1 | BUTTON2); if (buttons_state == 2) { indi_leds_state |= (LED_BLINK2<<LED_BUTTON_1); indi_leds_state &= ~(LED_BLINK2<<LED_BUTTON_2); mode = VOLTAGE_MODE; } else if (buttons_state == 1) { indi_leds_state |= (LED_BLINK2<<LED_BUTTON_2); indi_leds_state &= ~(LED_BLINK2<<LED_BUTTON_1); mode = WATER_TEMP_MODE; } else if (buttons_state == 0) { indi_leds_state |= (LED_BLINK2<<LED_BUTTON_1 | LED_BLINK2<<LED_BUTTON_2); } else { indi_leds_state &= ~(LED_BLINK2<<LED_BUTTON_1 | LED_BLINK2<<LED_BUTTON_2); mode = RPM_MODE; } /* Indicator for water temp */ if (params.waterTemp <= WATER_OK) { indi_leds_state |= (LED_BLINK2<<LED_INDI1); indi_leds_state &= ~(LED_BLINK2<<LED_INDI4); } else if (params.waterTemp > WATER_OK) { indi_leds_state |= (LED_BLINK2<<LED_INDI4); indi_leds_state &= ~(LED_BLINK2<<LED_INDI1); } /* Indicator for batt ok */ if (params.batteryV <= VOLTAGE_OK) { indi_leds_state |= (LED_BLINK2<<LED_INDI2); indi_leds_state &= ~(LED_BLINK2<<LED_INDI5); } else if (params.batteryV > VOLTAGE_OK) { indi_leds_state |= (LED_BLINK2<<LED_INDI5); indi_leds_state &= ~(LED_BLINK2<<LED_INDI2); } /* Indicator for oil pressure ok */ if (params.oilPressure <= OILPRESS_OK) { indi_leds_state |= (LED_BLINK2<<LED_INDI3); indi_leds_state &= ~(LED_BLINK2<<LED_INDI6); } else if (params.oilPressure > OILPRESS_OK) { indi_leds_state |= (LED_BLINK2<<LED_INDI6); indi_leds_state &= ~(LED_BLINK2<<LED_INDI3); } /* Indicator for Gear */ if (params.GearNeutral < 0) { SEG_N(LED_ON); } else { if (params.GearEst > 6) { SEG_OFF(); } else { switch (params.GearEst) { case 0: SEG_N(LED_ON); break; case 1: SEG_1(LED_ON); break; case 2: SEG_2(LED_ON); break; case 3: SEG_3(LED_ON); break; case 4: SEG_4(LED_ON); break; case 5: SEG_5(LED_ON); break; case 6: SEG_6(LED_ON); break; default: break; } } } /* if (params.GearNeutral == 0) { SEG_OFF(); } else if (params.GearNeutral > 0) { SEG_N(LED_BLINK2); } */ /* Set indicator leds */ set_leds(LED_BUTTONS_ADDR, indi_leds_state); /* itoa(params.batteryV, streng, 10);*/ /* sendtekst(streng);*/ /* sendtekst("\n\r"); */ PORTB ^= (1<<PB6); } return 0; }
int main(void){ uint16_t plen; uint16_t dat_p; //uint8_t cmd_pos=0; int8_t cmd; //uint8_t payloadlen=0; //char str[20]; //char cmdval; //char req[16]; //char i; DATA_DAIKIN daikin; // set the clock speed to "no pre-scaler" (8MHz with internal osc or // full external speed) // set the clock prescaler. First write CLKPCE to enable setting // of clock the next four instructions. // Note that the CKDIV8 Fuse determines the initial // value of the CKKPS bits. CLKPR=(1<<CLKPCE); // change enable CLKPR=0; // "no pre-scaler" _delay_loop_1(0); // 60us /*initialize enc28j60*/ enc28j60Init(mymac); //enc28j60clkout(2); // change clkout from 6.25MHz to 12.5MHz _delay_loop_1(0); // 60us /* Magjack leds configuration, see enc28j60 datasheet, page 11 */ // LEDB=yellow LEDA=green // // 0x476 is PHLCON LEDA=links status, LEDB=receive/transmit // enc28j60PhyWrite(PHLCON,0b0000 0100 0111 01 10); enc28j60PhyWrite(PHLCON,0x476); //DDRB|= (1<<DDB1); // enable PB1, LED as output // the transistor on PD7: //DDRD|= (1<<DDD7); //PORTD &= ~(1<<PORTD7);// transistor off //PORTB = 0xff; //DDRB = 0xff; init_power_settings(); uart_init(); init_ir(); init_airController(&daikin); sei(); xfunc_out = (void (*)(char))uart_put; xputs(PSTR("AVR-Ethernet test monitor\n")); xprintf(PSTR("ENC28J60 Rev.%d\n"), enc28j60getrev()); xprintf(PSTR("PRR=%02X\n"),PRR); //init the web server ethernet/ip layer: init_ip_arp_udp_tcp(mymac,myip,MYWWWPORT); while(1){ // handle ping and wait for a tcp packet plen=enc28j60PacketReceive(BUFFER_SIZE, buf); buf[BUFFER_SIZE]='\0'; dat_p=packetloop_icmp_tcp(buf,plen); if(dat_p==0){ // check if udp otherwise continue goto UDP; } // send data everytime we get a http request xprintf(PSTR("get http request\n")); if (strncmp("GET ",(char *)&(buf[dat_p]),4)!=0){ xprintf(PSTR("'GET \n'")); // head, post and other methods: // // for possible status codes see: // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html plen=http200ok(); plen=fill_tcp_data_p(buf,plen,PSTR("<h1>200 OK</h1>")); goto SENDTCP; } if (strncmp("/ ",(char *)&(buf[dat_p+4]),2)==0){ plen=http200ok(); plen=fill_tcp_data_p(buf,plen,PSTR("<p>Usage: http://host_or_ip/pc or m</p>\n")); goto SENDTCP; } if ((strncmp("/pc ",(char *)&(buf[dat_p+4]),4)==0) || (strncmp("/pc/ ",(char *)&(buf[dat_p+4]),5)==0)){ plen=http200ok(); plen=fill_tcp_data_p(buf,plen,pc_html); goto SENDTCP; } if ((strncmp("/m ",(char *)&(buf[dat_p+4]),3)==0) || (strncmp("/m/ ",(char *)&(buf[dat_p+4]),4)==0)){ plen=http200ok(); plen=fill_tcp_data_p(buf,plen,mobile_html); goto SENDTCP; } // GET /ir?power=on&temp=28 if (strncmp("/ir?",(char *)&(buf[dat_p+4]),4)==0){ if(find_key_val( (char *)&(buf[dat_p+8]), gStrbuf, 5, "power" ) ) { xprintf(PSTR("power=%s\n"),gStrbuf); if(strncmp("on", gStrbuf, 2) == 0){ airController_on(&daikin); setData(DAIKIN, daikin.buf, 35*8); }else if(strncmp("off", gStrbuf, 3) == 0){ airController_off(&daikin); setData(DAIKIN, daikin.buf, 35*8); } } if(find_key_val( (char *)&(buf[dat_p+8]), gStrbuf, 4, "temp" ) ) { xprintf(PSTR("temp=%s\n"),gStrbuf); airController_setTemp(&daikin, atoi(gStrbuf)); setData(DAIKIN, daikin.buf, 35*8); } plen=http200ok(); plen=fill_tcp_data_p(buf,plen,PSTR("Done\n")); goto SENDTCP; } cmd=analyse_get_url((char *)&(buf[dat_p+4])); // for possible status codes see: // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html if (cmd==-1){ plen=fill_tcp_data_p(buf,0,PSTR("HTTP/1.0 401 Unauthorized\r\nContent-Type: text/html\r\n\r\n<h1>401 Unauthorized</h1>")); goto SENDTCP; } if (cmd==1){ //PORTD|= (1<<PORTD7);// transistor on } if (cmd==0){ //PORTD &= ~(1<<PORTD7);// transistor off } if (cmd==2){ // favicon: //plen=moved_perm(buf,0); goto SENDTCP; } if (cmd==-2){ // redirect to the right base url (e.g add a trailing slash): plen=moved_perm(buf,1); goto SENDTCP; } // if (cmd==-2) or any other value // just display the status: //plen=print_webpage(buf,/*(PORTD & (1<<PORTD7))*/0); // SENDTCP: www_server_reply(buf,plen); // send data continue; // tcp port www end // ------------------------------- // udp start, we listen on udp port 1200=0x4B0 UDP: // xprintf(PSTR("here is UDP:\n")); // check if ip packets are for us: if(eth_type_is_ip_and_my_ip(buf,plen)==0){ // xprintf(PSTR("here is eth_type_is_ip_andd_my_ip\n")); continue; } /*if (buf[IP_PROTO_P]==IP_PROTO_UDP_V&&buf[UDP_DST_PORT_H_P]==(MYUDPPORT>>8)&&buf[UDP_DST_PORT_L_P]==(MYUDPPORT&0xff)){ payloadlen=buf[UDP_LEN_L_P]-UDP_HEADER_LEN; // you must sent a string starting with v // e.g udpcom version 10.0.0.24 if (verify_password((char *)&(buf[UDP_DATA_P]))){ // find the first comma which indicates // the start of a command: cmd_pos=0; while(cmd_pos<payloadlen){ cmd_pos++; if (buf[UDP_DATA_P+cmd_pos]==','){ cmd_pos++; // put on start of cmd break; } } // a command is one char and a value. At // least 3 characters long. It has an '=' on // position 2: if (cmd_pos<2 || cmd_pos>payloadlen-3 || buf[UDP_DATA_P+cmd_pos+1]!='='){ strcpy(str,"e=no_cmd"); goto ANSWER; } // supported commands are // t=1 t=0 t=? if (buf[UDP_DATA_P+cmd_pos]=='t'){ cmdval=buf[UDP_DATA_P+cmd_pos+2]; if(cmdval=='1'){ PORTD|= (1<<PORTD7);// transistor on strcpy(str,"t=1"); goto ANSWER; }else if(cmdval=='0'){ PORTD &= ~(1<<PORTD7);// transistor off strcpy(str,"t=0"); goto ANSWER; }else if(cmdval=='?'){ if (PORTD & (1<<PORTD7)){ strcpy(str,"t=1"); goto ANSWER; } strcpy(str,"t=0"); goto ANSWER; } } strcpy(str,"e=inv_cmd"); goto ANSWER; } strcpy(str,"e=inv_pw"); ANSWER: make_udp_reply_from_request(buf,str,strlen(str),MYUDPPORT); }*/ } return (0); }
int main(void) { DDRC = 0xFF; OUTPUT = 0x00; serialInit(SPEED9600); setupTimer(); sei(); /* byte buf[3]; uint16_t num; while(1) { if(serialAvailable() >= 2) { serialRead(buf,2); memcpy((void*)&num,buf,2); setAngle(num); serialClearBuffer(); } } */ /* uint16_t num; while(1) { serialWaitUntil('\r'); num = serialParseInt(); serialClearBuffer(); setElectricalAngle(num); } */ /* serialWrite("hello max!1 - f, 2 - b, 3 ++,4 --\n"); while(1) { if(serialAvailable()>0) { uint8_t c = serialReadChar(); switch(c) { case '1': if(direction) direction = 1; break; case '2': if(direction) direction = 2; break; case '3': if(userSpeed > 1) userSpeed--; serialWrite("userSpeed:"); serialPrintIntLn(userSpeed); break; case '4': if(userSpeed<255) userSpeed++; serialWrite("userSpeed:"); serialPrintIntLn(userSpeed); break; } } } */ uint16_t i=0; while(1) { for(i=0;;i+=5) { setElectricalAngle(i); _delay_ms(2); } } serialEnd(); return 0; }
int main( void ) { int32_t tmp = 0x0; // uint8_t tmp8; cli(); SetupInterruptPins(); y_pos = 0; x_pos = 0; // DDRC = _BV(PC6); //output pin SetupDriverPins(); setup_clock(); setup_timers(); SetupPrintf(); USB_ZeroPrescaler(); USB_Init(); sei(); printf("hello world"); // motorflags |= 0x01; // set_motor_pwm(PWM_MAX); // forward(); // while(1); //AutoSlop(); /* AutoSlop(); while(1); */ // dec_backward(); // set_dec_pwm(0x1fff); // ra_forward(); // set_ra_pwm(0x3fff); while(1) { cli(); // tmp8 = usbHasEvent; //add accumulated radial encoder output y_pos += y_tmp; y_tmp = 0; x_pos += x_tmp; x_tmp = 0; sei(); if (usbHasEvent) ProcessUSB(); if (jog_value_dec == 0) { tmp = ComputeOffset(&y_pos,&y_dest); //pid error value slew_dec(&tmp); } if (jog_value_ra == 0) { tmp = ComputeOffset(&x_pos,&x_dest); //pid error value slew_ra(&tmp); } } return 0; }