void Utils::blink_times(int times){
for(int i=0;i<times;i++) blink();
}
/*
* main function
*/
int main(void)
{
/* hardware on port D:
* PD0: RX
* PD1: TX
* PD2: D+
* PD3: INT1/IR_IN
* PD4: D-
* PD5: IR_OUT
* PD7: DF_CS
*/
DDRD = _BV(PD5) | _BV(PD7);
PORTD = _BV(PD7);
/* configure pin change interrupt for button 1 and 2,
* for waking up from sleep mode... */
PCMSK1 = _BV(PCINT12) | _BV(PCINT13);
/* hardware on port B:
* PB0: PUD
* PB1: /LED2
* PB2: /LED1
* PB3: MOSI
* PB4: MISO
* PB5: SCK
*/
DDRB = _BV(PB0) | _BV(PB1) | _BV(PB2) | _BV(PB3) | _BV(PB5);
PORTB = _BV(PB1) | _BV(PB2);
/* hardware on port C:
* PC0: IR_IN2
* PC1: POWER
* PC2: BTN4
* PC3: BTN3
* PC4: BTN2
* PC5: BTN1
*/
DDRC = 0;
PORTC = _BV(PC2) | _BV(PC3) | _BV(PC4) | _BV(PC5);
/* init analog to digital converter,
* convert on PC1(ADC1)
* prescaler 64 => 250khz frequency */
ADMUX = _BV(REFS0) | _BV(ADLAR) | _BV(ADIF) | _BV(MUX0);
ADCSRA = _BV(ADEN) | _BV(ADPS1);
/* init spi */
SPCR = _BV(SPE) | _BV(MSTR);
SPSR |= _BV(SPI2X);
/* init timer2 for key debouncing, CTC, prescaler 1024,
* timeout after 10ms */
TCCR2A = _BV(WGM21);
TCCR2B = _BV(CS22) | _BV(CS21) | _BV(CS20);
TIMSK2 = _BV(OCIE2A);
OCR2A = F_CPU/100/1024;
/* configure sleep mode */
set_sleep_mode(SLEEP_MODE_STANDBY);
#ifdef DEBUG_UART
/* uart */
UBRR0H = 0;
UBRR0L = 8;
UCSR0C = _BV(UCSZ00) | _BV(UCSZ01);
UCSR0B = _BV(TXEN0);
UDR0 = 'b';
while(!(UCSR0A & _BV(UDRE0)));
#endif
/* read dataflash status */
df_select();
SPDR = 0xd7;
while(!(SPSR & _BV(SPIF)));
SPDR = 0;
while(!(SPSR & _BV(SPIF)));
uint8_t df_status = SPDR;
/* read battery voltage */
uint8_t bat = battery_voltage();
#ifdef DEBUG_UART
UDR0 = 'D';
while(!(UCSR0A & _BV(UDRE0)));
UDR0 = df_status;
while(!(UCSR0A & _BV(UDRE0)));
UDR0 = 'V';
while(!(UCSR0A & _BV(UDRE0)));
UDR0 = bat;
while(!(UCSR0A & _BV(UDRE0)));
#endif
df_release();
sei();
#ifdef BLINK_START
/* blink start sequence */
blink(BLINK_START);
#endif
if (df_status == DF_STATUS_IDLE)
blink(BLINK_DF_SEEN);
else
blink(BLINK_DF_ERROR);
if (bat >= MIN_BAT_VOLTAGE)
blink(BLINK_BAT_OK);
else
blink(BLINK_BAT_FAIL);
uint8_t pos;
uint8_t button_sum = 0;
while (1)
{
/* if a button has been pressed and we're idle, wait some more time to determine mode */
if (state == IDLE && (button_press[0] > 0 || button_press[1] > 0)) {
/* wait one second via timer1, using prescaler 1024 */
TIFR1 = TIFR1;
OCR1A = F_CPU/1024/2;
TCCR1B = _BV(CS12) | _BV(CS10);
button_sum = 0;
state = READ_COMMAND;
}
/* if we're waiting for a command, and some button has been pressed, reset timeout */
uint8_t sum = button_press[0] + button_press[1];
if (state == READ_COMMAND && sum != button_sum) {
TCNT1 = 0;
button_sum = sum;
}
/* if we're waiting for a command, check if the timer expired */
if (state == READ_COMMAND && (TIFR1 & _BV(OCF1A))) {
/* disable timer1 */
TCCR1B = 0;
TCNT1 = 0;
/* parse button presses */
if (button_press[0] == 1 && button_press[1] == 0) {
if (battery_voltage() < MIN_BAT_VOLTAGE && !options.ignore_bat) {
blink(BLINK_VOLTAGE);
} else {
/* start transmitting */
pos = 0;
current_code = &codes[0];
single_code = &codes[0];
state = LOAD_CODE;
#ifdef BLINK_MODE1
/* blink mode 1 */
blink(BLINK_MODE1);
#endif
if (!options.silent)
PORTB &= ~_BV(PB1);
}
} else if (button_press[0] == 0) {
if (button_press[1] == 1) {
options.silent = !options.silent;
/* blink for silent toggle */
if (options.silent)
blink(BLINK_SILENT);
else
blink(BLINK_NONSILENT);
} else if (button_press[1] == 2) {
options.single_step = !options.single_step;
/* blink for single step toggle */
if (options.single_step)
blink(BLINK_STEP);
else
blink(BLINK_NOSTEP);
} else if (button_press[1] == 3) {
options.ignore_bat = !options.ignore_bat;
/* blink for ignore battery toggle */
if (options.ignore_bat)
blink(BLINK_BAT_IGNORE);
else
blink(BLINK_BAT_HONOR);
} else
blink(BLINK_INVALID);
} else
blink(BLINK_INVALID);
/* reset state, if not yet done */
if (state == READ_COMMAND)
state = IDLE;
/* reset buttons */
button_press[0] = 0;
button_press[1] = 0;
button_press[2] = 0;
}
if (state == LOAD_CODE) {
/* if we're in single-step mode, wait for a keypress */
if (options.single_step) {
while (button_press[0] == 0 && button_press[1] == 0 && button_press[2] == 0);
/* send next code if button1 has been pressed, stop if button2
* has been pressed, resend code if button3 has been pressed */
if (button_press[2]) {
current_code = single_code;
button_press[1] = 0;
} else if (!button_press[1]) {
button_press[1] = 0;
}
/* reset buttons */
button_press[0] = 0;
button_press[2] = 0;
}
/* stop sending if button2 has been pressed */
if (button_press[1] > 0) {
button_press[0] = 0;
button_press[1] = 0;
PORTB |= _BV(PB1);
#ifdef BLINK_MODE1_END
blink(BLINK_MODE1_END);
#endif
state = IDLE;
} else {
#ifdef DEBUG_UART
UDR0 = 'L';
while(!(UCSR0A & _BV(UDRE0)));
#endif
/* if we're in single step mode, remember code address for single-retransmit */
single_code = current_code;
/* load next generating function and generate timing table */
void (*func)(void);
uint16_t ptr = next_word();
func = (void *)ptr;
if (func != NULL) {
#ifdef DEBUG_UART
UDR0 = 'p';
while(!(UCSR0A & _BV(UDRE0)));
UDR0 = pos++;
while(!(UCSR0A & _BV(UDRE0)));
#endif
/* call generating function */
func();
#ifdef DEBUG_UART
UDR0 = 'f';
while(!(UCSR0A & _BV(UDRE0)));
#endif
/* reset timing pointer */
current_timing = &timing[0];
/* update state */
state = TRANSMIT_CODE;
/* init timer1 for initial delay before sending:
* prescaler 256, CTC mode (TOP == OCR1A)
* enable compare interrupts */
OCR1A = DELAY_NEXT_CODE;
OCR1B = 0xffff;
TIFR1 = TIFR1;
TIMSK1 = _BV(OCIE1A) | _BV(OCIE1B);
TCCR1B = _BV(CS12) | _BV(WGM12);
} else {
#ifdef DEBUG_UART
UDR0 = 'E';
while(!(UCSR0A & _BV(UDRE0)));
#endif
PORTB |= _BV(PB1);
#ifdef BLINK_MODE1_END
blink(BLINK_MODE1_END);
#endif
state = IDLE;
}
sleep_counter = 0;
}
}
if (state == SLEEP) {
/* enable pin change interrupt for button 1 and 2,
* for waking up from sleep mode... */
PCICR = _BV(PCIE1);
/* set and enter sleep mode */
sleep_mode();
sleep_counter = SLEEP_COUNTER_VALUE;
state = IDLE;
/* disable pin change interrupt for button 1 and 2,
* for waking up from sleep mode... */
PCICR = 0;
}
}
}
void LiquidCrystal_I2C::blink_on(){
blink();
}
void Minitel::noBlink() {
blink(false);
}
Atm_led& Atm_led::blink( uint32_t duration, uint32_t pause_duration, uint16_t repeat_count /* = ATM_COUNTER_OFF */ ) {
blink( duration ); // Time in which led is fully on
pause( pause_duration );
repeat( repeat_count );
return *this;
}
void animationAccessGranted() {
blink(GREEN);
}
void main(){
setup_oscillator (OSC_8MHZ);
setup_timer_1(T1_DISABLED);
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
// Give indiction that the microcontroller is up and running
for (i=0;i<5;i++){
blink();
}
//On boot interactive mode is on so that the user can use a terminal interface
interactive = 1;
//Main loop starts here...
while(true){ //Waits for a command to come in over the serial port in interactive mode
if (interactive == 1)
printf("Please enter a command (h for help):\n\r");
command = getc();
switch (command){
case 'i': //Turn off interactive mode
printf("Turning Off Interactive...\n\r");
interactive = 0;
printf("Done...\n\r");
break;
case 'r': //Reset DS2482
if (interactive == 1){
printf("Resetting the DS2482\n\r");
}
//Do the Reset
result = ds2482_reset();
if (interactive == 1){
if (result == 1)
printf("...Success...\n\r");
else printf ("...Fail..\n\r");
}
break;
case 'c': //Configure DS2482
//Active pullup should always be selected unless
//there is only a single slave on the 1-Wire line.
//0x01 1WS Disabled, SPU Disabled, 0 NC, APU Active Pullup (Normal Operation for more then one device on onewire bus)
//0x05 1WS Disabled, SPU Active, 0 NC, APU Active Pullup (Strong pullup is commonly used with 1-Wire parasitically powered temperature sensors, eeprom, A/D converters)
if (interactive == 1){
printf("Configuring the DS2482\n\r");
}
//Do the Config
result = ds2482_write_config(0x01);
if (interactive == 1){
if (result == 1)
printf("...Success...\n\r");
else printf ("...Fail..\n\r");
}
break;
case 'R': //Reset One Wire Bus
if (interactive == 1){
printf("Resetting the One Wire\n\r");
}
result = OWreset();
if (interactive == 1){
if (result == 1)
printf("...Success...\n\r");
else printf ("...Fail..\n\r");
}
break;
case 'n': //Read the Network Address
OWreset();
delay_ms(1);
OWWriteByte("33");
//delay_ms(20);
for(i=0; i<=7; i++) {
result = OWReadByte();
printf ("%2X",result);
delay_ms(1);
}
break;
case 's': //Read the OW status register
OWreset();
delay_ms(1);
OWWriteByte(204); //Transmit skip Rom Command CC = 204
OWWriteByte(105); //0x69 Transmit Read RAM command
OWWriteByte(1); //Transmit Read start address
result=OWReadByte();
break;
case 'f': //Fix the floating power switch
OWreset();
OWWriteByte(0xCC);
OWWriteByte(0x6C); //Write Data Command
OWWriteByte(0x31); //Eeprom address but actually gets written to Shadow Ram
OWWriteByte(0xE7); //Value to make PMOD1 SWEN=0 RNAOP=0
//Copy the shadow Ram written above over to actual EEPROM
OWreset();
OWWriteByte(0xCC);
OWWriteByte(0x48); //send the copy command
OWWriteByte(0x30); //copy shadow ram to the block containing 31
break;
default: //Displays help message if you get an 'h' or an unknown command
printf("PyroLogger Board Found and Responding...\n\r");
printf("Firmware Version 2\n\r");
printf("Interactive Mode is ON\n\r");
printf("\n\r");
printf("\n\r");
printf("Command List:\n\r");
printf("h = System Help\n\r");
printf("i = Exit ineractive mode\n\r");
printf("r = Reset DS2482\n\r");
printf("c = Configure DS2482\n\r");
printf("R = Reset One Wire Bus\n\r");
printf("N = Print Net Address\n\r");
}
}
}
void blinkN(int n){
int i;
for (i=0;i<n;i++){
blink(50);
}
}
UserView::UserView()
: UserListBase(NULL)
{
m_bBlink = false;
m_bUnreadBlink = false;
m_bShowOnline = CorePlugin::m_plugin->getShowOnLine();
setBackgroundMode(NoBackground);
viewport()->setBackgroundMode(NoBackground);
mTipItem = NULL;
m_tip = NULL;
m_searchTip = NULL;
m_current = NULL;
setTreeStepSize(0);
tipTimer = new QTimer(this);
connect(tipTimer, SIGNAL(timeout()), this, SLOT(showTip()));
blinkTimer = new QTimer(this);
connect(blinkTimer, SIGNAL(timeout()), this, SLOT(blink()));
unreadTimer = new QTimer(this);
connect(unreadTimer, SIGNAL(timeout()), this, SLOT(unreadBlink()));
topLevelWidget()->installEventFilter(this);
viewport()->installEventFilter(this);
m_dropContactId = 0;
m_dropItem = NULL;
m_searchItem = NULL;
setFrameStyle(QFrame::Panel);
setFrameShadow(QFrame::Sunken);
WindowDef wnd;
wnd.widget = this;
wnd.bDown = true;
Event e(EventAddWindow, &wnd);
e.process();
clear();
setGroupMode(CorePlugin::m_plugin->getGroupMode(), true);
edtGroup = new IntLineEdit(viewport());
edtContact = new IntLineEdit(viewport());
edtGroup->hide();
edtContact->hide();
QFont font(font());
int size = font.pixelSize();
if (size <= 0){
size = font.pointSize();
font.setPointSize(size * 3 / 4);
}else{
font.setPixelSize(size * 3 / 4);
}
font.setBold(true);
edtGroup->setFont(font);
connect(edtGroup, SIGNAL(escape()), this, SLOT(editEscape()));
connect(edtGroup, SIGNAL(returnPressed()), this, SLOT(editGroupEnter()));
connect(edtGroup, SIGNAL(focusOut()), this, SLOT(editGroupEnter()));
connect(edtContact, SIGNAL(escape()), this, SLOT(editEscape()));
connect(edtContact, SIGNAL(returnPressed()), this, SLOT(editContactEnter()));
connect(edtContact, SIGNAL(focusOut()), this, SLOT(editContactEnter()));
}
void blinkQuick(void){
blink(500);
}
void blinkTen(void){
int i;
for (i=0;i<10;i++){
blink(50);
}
}
int main(void)
{
setup();
while(1)
{
// use LED to show if I2C has a bus manager
blink();
// check if character is available to assemble a command, e.g. non-blocking
if ( (!command_done) && uart0_available() ) // command_done is an extern from parse.h
{
// get a character from stdin and use it to assemble a command
AssembleCommand(getchar());
// address is an ascii value, warning: a null address would terminate the command string.
StartEchoWhenAddressed(rpu_addr);
}
// check if a character is available, and if so flush transmit buffer and nuke the command in process.
// A multi-drop bus can have another device start transmitting after getting an address byte so
// the first byte is used as a warning, it is the onlly chance to detect a possible collision.
if ( command_done && uart0_available() )
{
// dump the transmit buffer to limit a collision
uart0_flush();
initCommandBuffer();
}
// delay between ADC burst
adc_burst();
// finish echo of the command line befor starting a reply (or the next part of a reply)
if ( command_done && (uart0_availableForWrite() == UART_TX0_BUFFER_SIZE) )
{
if ( !echo_on )
{ // this happons when the address did not match
initCommandBuffer();
}
else
{
if (command_done == 1)
{
findCommand();
command_done = 10;
}
// do not overfill the serial buffer since that blocks looping, e.g. process a command in 32 byte chunks
if ( (command_done >= 10) && (command_done < 250) )
{
ProcessCmd();
}
else
{
initCommandBuffer();
}
}
}
}
return 0;
}
int robot_begin()
{
int ret = SUCCESS;
int ivalue = 0;
ret = motor_begin();
if (ret != SUCCESS) return ret;
Serial.println("Begin Robot Init");
Serial.println("****************");
lcd.clear();
lcd.print("Begin Robot Init");
pinMode(Led_Green, OUTPUT); // set the pin as output
blink(Led_Green);
pinMode(Led_Red, OUTPUT); // set the pin as output
blink(Led_Red);
pinMode(Led_Blue, OUTPUT); // set the pin as output
blink(Led_Blue);
Serial.println("Init Leds OK");
// initialize the buzzer
pinMode(buzzPin, OUTPUT);
buzz(3);
Serial.println("Init Buzzer OK");
// initialize the Tilt&Pan servos
TiltPan_begin(HSERVO_Pin, VSERVO_Pin);
Serial.println("Init Tilt&Pan servos OK");
// initialize the camera
Serial.println(" ");
Serial.println("Begin Init Camera...");
ret=JPEGCamera.begin();
if (ret != SUCCESS)
{
Serial.print("Error Init Camera, error: ");
Serial.println(ret);
lcd.setCursor(0,1);
lcd.print("Init Camera KO ");
}
else
{
Serial.println("Init Camera OK");
lcd.setCursor(0,1);
lcd.print("Init Camera OK ");
}
delay(5*1000);lcd.clear();
// initialize the SD-Card
ret = initSDCard();
if (ret != SUCCESS)
{
Serial.print("Error Init SD-Card, error: ");
Serial.println(ret);
lcd.print("Init SD-Card KO ");
}
else
{
Serial.println("Init SD-Card OK");
lcd.print("Init SD-Card OK ");
}
// get infos from SD-Card
ret=infoSDCard();
if (ret < 0)
{
Serial.print("Error Infos SD-Card, error: ");
Serial.println(ret);
lcd.setCursor(0,1);
lcd.print("Err Infos SDCard");
}
else
{
no_picture = ret+1;
Serial.print("no_picture starts at: ");
Serial.println(no_picture);
lcd.setCursor(0,1);
lcd.print("Num picture:");lcd.print(no_picture);
}
delay(5*1000);lcd.clear();
// initialize the brightness sensor
TEMT6000.TEMT6000_init(TEMT6000_Pin); // initialize the pin connected to the sensor
Serial.println("Init Brightness sensor OK");
ivalue = TEMT6000.TEMT6000_getLight();
Serial.print("Value between 0 (dark) and 1023 (bright): ");
Serial.println(ivalue);
lcd.print("Lux:");lcd.print(ivalue);lcd.printByte(lcd_pipe);
// initialize the temperature sensor
TMP102.TMP102_init();
Serial.println("Init Temperature sensor OK");
double temperature = TMP102.TMP102_read();
ivalue = (int)(100.0 * temperature);
Serial.print("Temperature: ");
Serial.println(ivalue);
lcd.print("T:");lcd.print(ivalue);lcd.printByte(lcd_celcius);lcd.printByte(lcd_pipe);
// initialize the electret micro
//Micro.Micro_init(MICRO_Pin); // initialize the pin connected to the micro
//Serial.println("Init Micro OK");
// initialize the motion sensor
pinMode(MOTION_PIN, INPUT);
Serial.println("Init Motion sensor OK");
// initialize the IOT Serial 1
IOTSerial.IOTSbegin(1); // initialize the IOT Serial 1 to communicate with IOT WIFClient ESP8266
Serial.println ("Init IOT Serial 1 to communicate with IOT WIFClient ESP8266 OK");
// initialize the IOT Serial 2, interrupt setting
IOTSerial.IOTSbegin(2); // initialize the IOT Serial 2 to communicate with IOT WIFServer ESP8266
Serial.println ("Init IOT Serial 2 to communicate with IOT WIFServer ESP8266 OK");
pinMode(IOT_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(IOT_PIN), IntrIOT, RISING); // set IOT interrupt
interrupts(); // enable all interrupts
Serial.print("Init Interrupts OK, IntIOT: "); Serial.println(IntIOT);
lcd.setCursor(0,1);
lcd.print("End Robot Init");
delay(5*1000);lcd.clear();
Serial.println("End Robot Init");
Serial.println("**************");
Serial.println("");
return SUCCESS;
}
int robot_command (uint16_t *cmd, uint16_t *resp, uint8_t *resplen)
{
unsigned long start = 0;
uint8_t infolen = 0;
int checkdir;
int motor_state_save;
int error = -1;
int ret = SUCCESS;
lcd.clear(); // clear LCD
reset_leds(); // turn off all leds
digitalWrite(Led_Blue, HIGH); // turn on led blue
switch (cmd[0]) {
case CMD_STOP:
Serial.println("CMD_STOP");
lcd.print("STOP");
stop();
motor_state = STATE_STOP;
*resplen = 0;
break;
case CMD_START:
if (cmd[1] == 0)
{
Serial.println("CMD_START");
lcd.print("START");
start_forward();
}
else
{
Serial.print("CMD_START_TEST motor: "); Serial.println((int)cmd[1]);
lcd.print("START motor: "); lcd.print((int)cmd[1]);
start_forward_test(cmd[1]);
}
motor_state = STATE_GO;
*resplen = 0;
break;
case CMD_CHECK_AROUND:
Serial.println("CMD_CHECK_AROUND");
lcd.print("CHECK AROUND");
checkdir = check_around();
lcd.setCursor(0,1);
if (checkdir == DIRECTION_LEFT) lcd.print("LEFT");
else if (checkdir == DIRECTION_RIGHT) lcd.print("RIGHT");
else if (checkdir == OBSTACLE_LEFT) lcd.print("OBSTACLE LEFT");
else if (checkdir == OBSTACLE_RIGHT) lcd.print("OBSTACLE RIGHT");
else if (checkdir == OBSTACLE) lcd.print("OBSTACLE");
else lcd.print("?");
resp[0] = checkdir;
*resplen = 0+1;
break;
case CMD_MOVE_TILT_PAN:
Serial.print("CMD_MOVE_TILT_PAN: "); Serial.print((int)cmd[1]);Serial.print((int)cmd[2]);Serial.print((int)cmd[3]);Serial.println((int)cmd[4]);
if (cmd[2] == 0) HPos = (int)cmd[1] + 90; else HPos = 90 - (int)cmd[1];
if (cmd[4] == 0) VPos = (int)cmd[3] + 90; else VPos = 90 - (int)cmd[3];
Serial.print("CMD_MOVE_TILT_PAN, HPos VPos: "); Serial.print(HPos);Serial.println(VPos);
lcd.print("MOVE TILT&PAN");
lcd.setCursor(0,1);
lcd.print("X: ");
lcd.print(HPos);
lcd.print(" Y: ");
lcd.print(VPos);
TiltPan_move(HPos, VPos);
*resplen = 0;
break;
case CMD_TURN:
if (cmd[1] == 180)
{
Serial.print("CMD_TURN_BACK");
lcd.print("TURN BACK ");
ret = turnback (10); // 10s max
if (ret != SUCCESS){
Serial.print("turnback error"); Serial.println(ret);
lcd.setCursor(0,1);
lcd.print("turnback error: "); lcd.print(ret);
error = 1;
}
}
else if (motor_state == STATE_GO)
{
Serial.print("CMD_TURN, alpha: "); Serial.print((cmd[2] != 1) ? ('+'):('-')); Serial.println((int)cmd[1]);
lcd.print("TURN"); lcd.print((cmd[2] != 1) ? ('+'):('-')); lcd.print((int)cmd[1]);lcd.print((char)223); //degree
ret = turn ((double)((cmd[2] != 1) ? (cmd[1]):(-cmd[1])), 5); // 5s max
if (ret != SUCCESS){
Serial.print("turn error"); Serial.println(ret);
lcd.setCursor(0,1);
lcd.print(" turn error: "); lcd.print(ret);
error = 1;
}
}
*resplen = 0;
break;
case CMD_INFOS:
Serial.println("CMD_INFOS");
ret = infos (resp, &infolen);
if (resp[MOTOR_STATE] == STATE_GO) {
lcd.print("RUNING");
}
else
{
lcd.print("STOPPED");
}
lcd.setCursor(0,1);
lcd.print((int)resp[TEMPERATURE]); lcd.print((byte)lcd_celcius);lcd.write(lcd_pipe);
lcd.print((int)resp[DISTANCE]); lcd.print("cm");lcd.write(lcd_pipe);
lcd.print((int)resp[DIRECTION]); lcd.print((char)223); //degree
*resplen = infolen;
break;
case CMD_PICTURE:
Serial.print("CMD_PICTURE, no_picture: ");
no_picture++;
Serial.println(no_picture);
lcd.print("PICTURE ");
motor_state_save = motor_state;
if (motor_state == STATE_GO) {
Serial.println("Stop");
stop();
motor_state = STATE_STOP;
}
ret = JPEGCamera.makePicture (no_picture);
if (ret == SUCCESS)
{
lcd.setCursor(0,1);
lcd.print("picture: "); lcd.print(no_picture);
}
else
{
Serial.print("makePicture error: "); Serial.println(ret);
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
error = 1;
}
if (motor_state_save == STATE_GO) {
Serial.println("Start");
start_forward();
motor_state = STATE_GO;
}
// byte 0: picture number
resp[0] = no_picture;
*resplen = 0+1;
break;
case CMD_ALERT:
Serial.println("CMD_ALERT");
lcd.print("Alert");
blink(Led_Blue);
buzz(5);
// If motor_state == STATE_GO => Stop
if (motor_state == STATE_GO) {
Serial.println("Stop");
stop();
motor_state = STATE_STOP;
}
// Make 3 pictures left, front and right
if ((HPos != 90) || (VPos !=90))
{
HPos = 90;
VPos = 90;
TiltPan_move(HPos, VPos);
}
Serial.print("makePicture, no_picture: ");
no_picture++;
Serial.println(no_picture);
lcd.print("PICTURE ");
ret = JPEGCamera.makePicture (no_picture);
if (ret == SUCCESS)
{
lcd.setCursor(0,1);
lcd.print("picture: "); lcd.print(no_picture);
}
else
{
Serial.print("makePicture error: "); Serial.println(ret);
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
error = 1;
}
if (ret == SUCCESS)
{
HPos = 0;
VPos = 90;
TiltPan_move(HPos, VPos);
Serial.print("makePicture, no_picture: ");
no_picture++;
Serial.println(no_picture);
lcd.print("PICTURE ");
ret = JPEGCamera.makePicture (no_picture);
lcd.setCursor(0,1);
lcd.print("picture: "); lcd.print(no_picture);
}
else
{
Serial.print("makePicture error: "); Serial.println(ret);
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
error = 1;
}
if (ret == SUCCESS)
{
HPos = 180;
VPos = 90;
TiltPan_move(HPos, VPos);
Serial.print("makePicture, no_picture: ");
no_picture++;
Serial.println(no_picture);
lcd.print("PICTURE ");
ret = JPEGCamera.makePicture (no_picture);
lcd.setCursor(0,1);
lcd.print("picture: "); lcd.print(no_picture);
}
else
{
Serial.print("makePicture error: "); Serial.println(ret);
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
error = 1;
}
// byte 0: last picture number
resp[0] = no_picture;
*resplen = 0+1;
HPos = 90;
VPos = 90;
TiltPan_move(HPos, VPos);
break;
case CMD_CHECK:
Serial.println("CMD_CHECK");
lcd.print("Check");
alert_status = check();
if (alert_status != SUCCESS) {
Serial.print("Alert detected: ");Serial.println(alert_status);
lcd.setCursor(0,1);
lcd.print("Alert: "); lcd.print(alert_status);
}
else
{
Serial.print("No alert detected: ");
lcd.setCursor(0,1);
lcd.print(" No Alert");
}
// byte 0: alert
resp[0] = alert_status;
*resplen = 0+1;
break;
case CMD_GO:
Serial.print("CMD_GO, nb seconds: "); Serial.print((int)cmd[1]);
lcd.print("GO ");lcd.print((int)cmd[1]);lcd.print("secs");
if (motor_state != STATE_GO)
{
Serial.println("start_forward");
start_forward();
motor_state = STATE_GO;
}
error = -1;
GOtimeout = (unsigned long)cmd[1];
start = millis();
while((millis() - start < GOtimeout*1000) && (error == -1)) {
ret = go(GOtimeout);
if ((ret != SUCCESS) && (ret != OBSTACLE) && (ret != OBSTACLE_LEFT) && (ret != OBSTACLE_RIGHT))
{
stop();
motor_state = STATE_STOP;
error = 1;
Serial.print("CMD_GO error: "); Serial.println(ret);
Serial.println("Stop");
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
}
else if ((ret == OBSTACLE) || (ret == OBSTACLE_LEFT) || (ret == OBSTACLE_RIGHT))
{
stop();
motor_state = STATE_STOP;
buzz(3);
blink(Led_Red);
Serial.print("CMD_GO Obstacle: ");Serial.println(ret);
Serial.println("Stop");
lcd.setCursor(0,1);
if (ret == OBSTACLE_LEFT) lcd.print("OBSTACLE LEFT");
else if (ret == OBSTACLE_RIGHT) lcd.print("OBSTACLE RIGHT");
else if (ret == OBSTACLE) lcd.print("OBSTACLE");
else
ret = SUCCESS;
checkdir = check_around();
Serial.print("check_around, direction: "); Serial.println(checkdir);
lcd.clear();
lcd.print("check around");
lcd.setCursor(0,1);
if (checkdir == DIRECTION_LEFT) lcd.print("LEFT");
else if (checkdir == DIRECTION_RIGHT) lcd.print("RIGHT");
else if (checkdir == OBSTACLE_LEFT) lcd.print("OBSTACLE LEFT");
else if (checkdir == OBSTACLE_RIGHT) lcd.print("OBSTACLE RIGHT");
else if (checkdir == OBSTACLE) lcd.print("OBSTACLE");
else lcd.print("?");;
if (checkdir == DIRECTION_LEFT) {
start_forward();
motor_state = STATE_GO;
ret = turn (-45, 5); // turn -45 degrees during 5s max
if (ret != SUCCESS)
{
stop();
motor_state = STATE_STOP;
error = 1;
Serial.print("turn error: "); Serial.println(ret);
Serial.println("Stop");
lcd.clear();
lcd.print("turn left");
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
}
else
{
lcd.clear();
lcd.print("turn left OK");
}
}
else if (checkdir == DIRECTION_RIGHT) {
start_forward();
motor_state = STATE_GO;
ret = turn (+45, 5); // turn +45 degrees during 5s max
if (ret != SUCCESS)
{
stop();
motor_state = STATE_STOP;
error = 1;
Serial.print("turn error: "); Serial.println(ret);
Serial.println("Stop");
lcd.clear();
lcd.print("turn right");
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
}
else
{
lcd.clear();
lcd.print("turn right OK");
}
}
else
{
buzz(3);
blink(Led_Red);
motor_state = STATE_GO;
ret = turnback (10); // turn back during 10s max
if (ret != SUCCESS)
{
stop();
motor_state = STATE_STOP;
error = 1;
Serial.print("turnback error"); Serial.println(ret);
Serial.println("Stop");
lcd.clear();
lcd.print("turnback");
lcd.setCursor(0,1);
lcd.print("error: "); lcd.print(ret);
}
else
{
lcd.clear();
lcd.print("turnback OK");
}
}
}
else
{
Serial.println("GO OK");
lcd.clear();
lcd.print("GO OK");
error = 0;
}
} // end while
ret = infos (resp, &infolen);
if (error == 0) {
if (resp[MOTOR_STATE] == STATE_GO) {
lcd.print("RUNNING");
}
else
{
lcd.print("STOPPED");
}
lcd.setCursor(0,1);
lcd.print((int)resp[TEMPERATURE]); lcd.print((byte)lcd_celcius);lcd.write(lcd_pipe);
lcd.print((int)resp[DISTANCE]); lcd.print("cm");lcd.write(lcd_pipe);
lcd.print((int)resp[DIRECTION]); lcd.print((char)223); //degree
}
*resplen = infolen;
break;
case CMD_PI:
Serial.print("CMD_PI activated, type: "); Serial.print((int)cmd[1]); Serial.print(" - freq: ");Serial.println((int)cmd[2]);
lcd.print("PI activated ");lcd.print((int)cmd[1]);
PI_activated = (int)cmd[1];
if (PI_activated <> PI_NO_COMM) PI_freqInfos = (int)cmd[2]* 1000;
Serial.print("PI_activated: "); Serial.println(PI_activated);
Serial.print("PI_freqInfos: ");Serial.println(PI_freqInfos);
*resplen = 0;
break;
default:
Serial.println("invalid command");
lcd.print("invalid command");
*resplen = 0;
break;
} //end switch
if (error == 1) {
blink(Led_Red);
blink(Led_Red);
buzz(7);
*resplen = 0;
}
reset_leds(); // turn off all leds
return ret;
}
//************************************************************************************************************************************************
void checkDoorState()
{
//the master controller will send values to this analog pin when the doors are open. When closed, the value will be 0
//will need to have 4 door state values.
// door 1 = open, door 1 & 2 open, door 2 open. all doors closed
d1LimVal = analogRead(door1LimitPin);
d2LimVal = analogRead(door2LimitPin);
//Serial.print("Limit1Val: ");
//Serial.print(d1LimVal);
//Serial.print(" Limit2Val: ");
//Serial.println(d2LimVal);
if ((d1LimVal >= 1000) && (d2LimVal >= 1000)) //both door limit switches are closed. 1023
{
d1S = 1;
d2S = 1;
blink(NotOKLedPin, 100, 1);
msgOut(doorStatLEDPin, 1);
}
else if ((d1LimVal >= 1000) && (d2LimVal < 50))
{
d1S = 1;
d2S = 0;
blink(NotOKLedPin, 100, 1);
msgOut(doorStatLEDPin, 1);
}
else if ((d1LimVal < 50) && (d2LimVal >= 1000))
{
d1S = 0;
d2S = 1;
blink(NotOKLedPin, 100, 1);
msgOut(doorStatLEDPin, 1);
}
else
{
d1S = 0;
d2S = 0;
msgOut(doorStatLEDPin, 0);
}
Blynk.virtualWrite(1, d1S); //sends the state of Garage door 1 - if 1, then open
Blynk.virtualWrite(3, d2S); // sends the state of Garage door 2 - if 1, then open
//reset the timer values used for pwd entry
if (millis() - pwdEntryStartTime > interval)
{
door_p1 = false, door_p2 = false, door_p3 = false, door_p4 = false;
//reset the sliders in the Blynk app - do this after the interval time has elapsed.
Blynk.virtualWrite(9, 0); //pwd is no longer valid - update LED to OFF state
Blynk.virtualWrite(5, 0); //reset the pwd sliders to 0
Blynk.virtualWrite(6, 0); //reset the pwd sliders to 0
Blynk.virtualWrite(7, 0); //reset the pwd sliders to 0
Blynk.virtualWrite(8, 0); //reset the pwd sliders to 0
pwdEntryStartTime = 0;
}
if (door_p1 && door_p2 && door_p3 && door_p4)
{
Blynk.virtualWrite(9, 1); //pwd is correct - illuminate LED
}
else
{
Blynk.virtualWrite(9, 0); //pwd is no longer correct - illuminate LED
}
}
CmdPrompt::CmdPrompt(QWidget* parent) : QWidget(parent)
{
qDebug("CmdPrompt Constructor");
setObjectName("Command Prompt");
promptInput = new CmdPromptInput(this);
promptHistory = new CmdPromptHistory();
promptDivider = new QFrame(this);
promptVBoxLayout = new QVBoxLayout(this);
promptSplitter = new CmdPromptSplitter(this);
this->setFocusProxy(promptInput);
promptHistory->setFocusProxy(promptInput);
promptDivider->setLineWidth(1);
promptDivider->setFrameStyle(QFrame::HLine);
promptDivider->setMaximumSize(QWIDGETSIZE_MAX, 1);
promptVBoxLayout->addWidget(promptSplitter);
promptVBoxLayout->addWidget(promptHistory);
promptVBoxLayout->addWidget(promptDivider);
promptVBoxLayout->addWidget(promptInput);
promptVBoxLayout->setSpacing(0);
promptVBoxLayout->setContentsMargins(0,0,0,0);
this->setLayout(promptVBoxLayout);
styleHash = new QHash<QString, QString>();
styleHash->insert("color", "#000000"); // Match -------|
styleHash->insert("background-color", "#FFFFFF"); // |
styleHash->insert("selection-color", "#FFFFFF"); // |
styleHash->insert("selection-background-color", "#000000"); // Match -------|
styleHash->insert("font-family", "Monospace");
styleHash->insert("font-style", "normal");
styleHash->insert("font-size", "12px");
updateStyle();
blinkState = false;
blinkTimer = new QTimer(this);
connect(blinkTimer, SIGNAL(timeout()), this, SLOT(blink()));
this->show();
connect(promptInput, SIGNAL(stopBlinking()), this, SLOT(stopBlinking()));
connect(promptInput, SIGNAL(appendHistory(const QString&)), promptHistory, SLOT(appendHistory(const QString&)));
connect(this, SIGNAL(appendTheHistory(const QString&)), promptHistory, SLOT(appendHistory(const QString&)));
//For use outside of command prompt
connect(promptInput, SIGNAL(startCommand(const QString&)), this, SIGNAL(startCommand(const QString&)));
connect(promptInput, SIGNAL(runCommand(const QString&, const QString&)), this, SIGNAL(runCommand(const QString&, const QString&)));
connect(promptInput, SIGNAL(deletePressed()), this, SIGNAL(deletePressed()));
connect(promptInput, SIGNAL(tabPressed()), this, SIGNAL(tabPressed()));
connect(promptInput, SIGNAL(escapePressed()), this, SIGNAL(escapePressed()));
connect(promptInput, SIGNAL(F1Pressed()), this, SIGNAL(F1Pressed()));
connect(promptInput, SIGNAL(F2Pressed()), this, SIGNAL(F2Pressed()));
connect(promptInput, SIGNAL(F3Pressed()), this, SIGNAL(F3Pressed()));
connect(promptInput, SIGNAL(F4Pressed()), this, SIGNAL(F4Pressed()));
connect(promptInput, SIGNAL(F5Pressed()), this, SIGNAL(F5Pressed()));
connect(promptInput, SIGNAL(F6Pressed()), this, SIGNAL(F6Pressed()));
connect(promptInput, SIGNAL(F7Pressed()), this, SIGNAL(F7Pressed()));
connect(promptInput, SIGNAL(F8Pressed()), this, SIGNAL(F8Pressed()));
connect(promptInput, SIGNAL(F9Pressed()), this, SIGNAL(F9Pressed()));
connect(promptInput, SIGNAL(F10Pressed()), this, SIGNAL(F10Pressed()));
connect(promptInput, SIGNAL(F11Pressed()), this, SIGNAL(F11Pressed()));
connect(promptInput, SIGNAL(F12Pressed()), this, SIGNAL(F12Pressed()));
connect(promptInput, SIGNAL(cutPressed()), this, SIGNAL(cutPressed()));
connect(promptInput, SIGNAL(copyPressed()), this, SIGNAL(copyPressed()));
connect(promptInput, SIGNAL(pastePressed()), this, SIGNAL(pastePressed()));
connect(promptInput, SIGNAL(selectAllPressed()), this, SIGNAL(selectAllPressed()));
connect(promptInput, SIGNAL(undoPressed()), this, SIGNAL(undoPressed()));
connect(promptInput, SIGNAL(redoPressed()), this, SIGNAL(redoPressed()));
connect(promptInput, SIGNAL(shiftPressed()), this, SIGNAL(shiftPressed()));
connect(promptInput, SIGNAL(shiftReleased()), this, SIGNAL(shiftReleased()));
}
void loop(){
blink(2, 500); // blink led 2 times, 500 ms interval
delay(1000); // wait 1 sec
}
int
main (void)
{
/* accelerometer readings fifo */
TFifoEntry acc_lowpass;
TFifoEntry fifo_buf[FIFO_DEPTH];
int fifo_pos;
TFifoEntry *fifo;
uint32_t SSPdiv;
uint16_t oid_last_seen;
uint8_t cmd_buffer[64], cmd_pos, c;
uint8_t volatile *uart;
int x, y, z, moving;
volatile int t;
int i;
/* wait on boot - debounce */
for (t = 0; t < 2000000; t++);
/* Initialize GPIO (sets up clock) */
GPIOInit ();
/* initialize pins */
pin_init ();
/* fire up LED 1 */
GPIOSetValue (1, 1, 1);
/* initialize SPI */
spi_init ();
/* read device UUID */
bzero (&device_uuid, sizeof (device_uuid));
iap_read_uid (&device_uuid);
tag_id = crc16 ((uint8_t *) & device_uuid, sizeof (device_uuid));
random_seed =
device_uuid[0] ^ device_uuid[1] ^ device_uuid[2] ^ device_uuid[3];
/************ IF Plugged to computer upon reset ? ******************/
if (GPIOGetValue (0, 3))
{
/* wait some time till Bluetooth is off */
for (t = 0; t < 2000000; t++);
/* Init 3D acceleration sensor */
acc_init (1);
/* Init Flash Storage with USB */
storage_init (TRUE, tag_id);
g_storage_items = storage_items ();
/* Init Bluetooth */
bt_init (TRUE, tag_id);
/* switch to LED 2 */
GPIOSetValue (1, 1, 0);
GPIOSetValue (1, 2, 1);
/* set command buffer to empty */
cmd_pos = 0;
/* spin in loop */
while (1)
{
/* reset after USB unplug */
if (!GPIOGetValue (0, 3))
NVIC_SystemReset ();
/* if UART rx send to menue */
if (UARTCount)
{
/* blink LED1 upon Bluetooth command */
GPIOSetValue (1, 1, 1);
/* execute menue command with last character received */
/* scan through whole UART buffer */
uart = UARTBuffer;
for (i = UARTCount; i > 0; i--)
{
UARTCount--;
c = *uart++;
if ((c < ' ') && cmd_pos)
{
/* if one-character command - execute */
if (cmd_pos == 1)
main_menue (cmd_buffer[0]);
else
{
cmd_buffer[cmd_pos] = 0;
debug_printf
("Unknown command '%s' - please press H+[Enter] for help\n# ",
cmd_buffer);
}
/* set command buffer to empty */
cmd_pos = 0;
}
else if (cmd_pos < (sizeof (cmd_buffer) - 2))
cmd_buffer[cmd_pos++] = c;
}
/* reset UART buffer */
UARTCount = 0;
/* un-blink LED1 */
GPIOSetValue (1, 1, 0);
}
}
} /* End of if plugged to computer*/
/***************** IF UNPLUGGED TO PC ........********/
/* Init Bluetooth */
bt_init (FALSE, tag_id);
/* shut down up LED 1 */
GPIOSetValue (1, 1, 0);
/* Init Flash Storage without USB */
storage_init (FALSE, tag_id);
/* get current FLASH storage write postition */
g_storage_items = storage_items ();
/* initialize power management */
pmu_init ();
/* blink once to show initialized flash */
blink (1);
/* Init 3D acceleration sensor */
acc_init (0);
blink (2);
/* Initialize OpenBeacon nRF24L01 interface */
if (!nRFAPI_Init(CONFIG_TRACKER_CHANNEL, broadcast_mac, sizeof (broadcast_mac), 0))
for (;;)
{
GPIOSetValue (1, 2, 1);
pmu_sleep_ms (500);
GPIOSetValue (1, 2, 0);
pmu_sleep_ms (500);
}
/* set tx power power to high */
nRFCMD_Power (1);
/* blink three times to show flash initialized RF interface */
blink (3);
/* blink LED for 1s to show readyness */
GPIOSetValue (1, 1, 0);
GPIOSetValue (1, 2, 1);
pmu_sleep_ms (1000);
GPIOSetValue (1, 2, 0);
/* disable unused jobs */
SSPdiv = LPC_SYSCON->SSPCLKDIV;
i = 0;
oid_last_seen = 0;
/* reset proximity buffer */
prox_head = prox_tail = 0;
bzero (&prox, sizeof (prox));
/*initialize FIFO */
fifo_pos = 0;
bzero (&acc_lowpass, sizeof (acc_lowpass));
bzero (&fifo_buf, sizeof (fifo_buf));
moving = 0;
g_sequence = 0;
while (1)
{
pmu_sleep_ms (500);
LPC_SYSCON->SSPCLKDIV = SSPdiv;
acc_power (1);
pmu_sleep_ms (20);
acc_xyz_read (&x, &y, &z);
acc_power (0);
fifo = &fifo_buf[fifo_pos];
if (fifo_pos >= (FIFO_DEPTH - 1))
fifo_pos = 0;
else
fifo_pos++;
acc_lowpass.x += x - fifo->x;
fifo->x = x;
acc_lowpass.y += y - fifo->y;
fifo->y = y;
acc_lowpass.z += z - fifo->z;
fifo->z = z;
nRFAPI_SetRxMode (0);
bzero (&g_Beacon, sizeof (g_Beacon));
g_Beacon.pkt.proto = RFBPROTO_BEACONTRACKER_EXT;
g_Beacon.pkt.flags = moving ? RFBFLAGS_MOVING : 0;
g_Beacon.pkt.oid = htons (tag_id);
g_Beacon.pkt.p.tracker.strength = (i & 1) + TX_STRENGTH_OFFSET;
g_Beacon.pkt.p.tracker.seq = htonl (LPC_TMR32B0->TC);
g_Beacon.pkt.p.tracker.oid_last_seen = oid_last_seen;
g_Beacon.pkt.p.tracker.time = htons ((uint16_t)g_sequence++);
g_Beacon.pkt.p.tracker.battery = 0;
g_Beacon.pkt.crc = htons (
crc16(g_Beacon.byte, sizeof (g_Beacon) - sizeof (g_Beacon.pkt.crc))
);
nRFCMD_Power (0);
nRF_tx (g_Beacon.pkt.p.tracker.strength);
nRFCMD_Power (1);
nRFAPI_PowerDown ();
LPC_SYSCON->SSPCLKDIV = 0x00;
blink (10);
}
return 0;
}
void animationAccessDenied() {
blink(RED);
}
void loop()
{
blink();
blink_rebirth();
}
void Minitel::blink() {
blink(true);
}
void DachisLed::blinkSlow()
{
blink(1000);
}
/*Message Receiver*/
void waitMsg()
{
uint8_t key;
unsigned char buf[32];
char sender_nick[10];
int n,i;
int index=0;
int rcv =0;
int try=0;
do
{
key = getInput();
if(1)
{
nrf_config_set(&config);
n = nrf_rcv_pkt_time(100,32,buf);
getInputWaitTimeout(100);
if(n == 32)
{
index=buf[0];
for(i=0; i<10; i++)
sender_nick[i]=buf[i+1];
lcdClear();
lcdPrintln("");
lcdPrintln("CCC MSN 0.1b");
lcdPrintln("---------------");
lcdPrintln(msgs[index]);
lcdPrintln("");
lcdPrintln("Received");
lcdPrintln("");
lcdPrintln("_______________");
lcdPrintln(sender_nick);
lcdRefresh();
blink();
rcv=1;
try=0;
} else if(rcv)
{
lcdClear();
lcdPrintln("");
lcdPrintln("CCC MSN 0.1b");
lcdPrintln("-----------------");
lcdPrintln("Waiting...");
lcdPrint("Try ");
lcdPrintln(IntToStr(try,5,0));
lcdPrintln("");
lcdPrintln(msgs[index]);
lcdPrintln("_______________");
lcdPrintln(sender_nick);
lcdRefresh();
}
try++;
}
if(!rcv)
{
lcdClear();
lcdPrintln("");
lcdPrintln("CCC MSN 0.1b");
lcdPrintln("-----------------");
lcdPrintln("Waiting...");
lcdPrintln("");
lcdPrint("Try ");
lcdPrintln(IntToStr(try,5,0));
lcdPrintln("");
lcdPrintln("_______________");
lcdPrintln("W8 Users Auto");
lcdRefresh();
}
void DachisLed::blinkFast()
{
blink(100);
}
int main(void)
{
StandartMessage TxMessage;
StandartMessage RxMessage;
TxMessage.OutputBuffer = 0;
TxMessage.Priority = 0;
TxMessage.StdIdentifier = DEVICE_ID;
TxMessage.MessageLength = 4;
TxMessage.RemoteTransmission = 0;
TxMessage.Messages[0] = 0xA0;
TxMessage.Messages[1] = 0x0A;
TxMessage.Messages[2] = 0x50;
TxMessage.Messages[3] = 0x05;
DDRD = 0xff;
PORTD = 0xff;
uint8_t OutTable[8];
SPI_Init();
CAN_Reset();
CAN_Init();
PORTD = ~(CAN_GetBuffer(CANSTAT_ADR));
_delay_ms(1000);
//CAN_SetLoopbackMode();
CAN_SetNormalMode();
_delay_ms(100);
PORTD = ~(CAN_GetBuffer(CANSTAT_ADR));
_delay_ms(1000);
//CAN_TransmitMessage(&TxMessage);
int counter = 0;
while(1)
{
//if(counter > 2)
//{
//CAN_TransmitMessage(&TxMessage);
//counter = 0;
//}
//else
//{
//counter++;
//}
if(CAN_GetBuffer(CANINTF_ADR)&RX0IF)
{
CAN_ReceiveMessage(0,&RxMessage);
blink();
PORTD = ~RxMessage.StdIdentifier;
_delay_ms(2000);
blink();
PORTD = ~RxMessage.MessageLength;
_delay_ms(2000);
if(RxMessage.RemoteTransmission)
PORTD = ~RxMessage.RemoteTransmission;
else
{
for(int i=0; i<RxMessage.MessageLength; i++)
{
blink();
PORTD = ~RxMessage.Messages[i];
_delay_ms(2000);
}
}
}
else
{
blink();
PORTD = ~(0b11000011);
_delay_ms(2000);
}
}
}
void setup() {
// Init serial and wait for it to be up
// (Required for Leonardo)
Serial.begin( SERIAL_RATE );
while( !Serial );
pinMode( LED_PIN, OUTPUT );
pinMode( 2, INPUT );
digitalWrite( LED_PIN, LOW );
Radio.addChannel( 0 );
Radio.addChannel( 1 );
Radio.addChannel( 2 );
Radio.addChannel( 3 );
Radio.addChannel( 4 );
Radio.addChannel( 5 );
Serial.println( "Init" );
// Setup the engines first to reset the channels for ECM
for( int i = 0; i < 4; i++ )
{
FlightModel.addEngine( &engines[i] );
if( !engines[i].setup() )
STOP_ERROR( "Failed to initialize engine");
}
if( !PinStatus::setup() )
STOP_ERROR( "Failed to initialize pin change interrupts");
if( !IMU.setup() || !IMU.setupInterrupt() ) {
STOP_ERROR( "Failed to initialize IMU" );
}
// Wait for the TX to give valid values
Serial.println( "Waiting radio" );
while( true )
{
if( !Radio.update() ) { continue; }
for( uint8_t i = 0; i < Radio.channelCount; i++ )
{
if( Status.channelData[ i ].raw < 750 || Status.channelData[ i ].raw > 2250 )
{
continue;
}
}
break;
}
// If elevator is pulled down when the thing is reset, enter calibration mode.
bool calibrationSaved = false;
#ifdef ENABLE_CALIBRATION
if( Status.channelData[ 1 ].raw < 1400 )
{
INFO( "Calibration started" );
unsigned long canExitCalibration = millis() + 4000;
while( millis() < canExitCalibration )
{
blink( 100 );
Radio.update();
Radio.calibrate();
// When the elevator isn't centered, postpone the calibration ending.
if( Status.channelData[ 1 ].raw < 1400 || Status.channelData[ 1 ].raw > 1600 )
canExitCalibration = millis() + 4000;
}
// Sticks are centered. Record the zero values.
digitalWrite( LED_PIN, HIGH );
delay( 500 );
Radio.update();
Radio.recordCenterPositions();
digitalWrite( LED_PIN, LOW );
// Now allow for 1 second for the user to make a choice whether to save values or not.
delay( 1000 );
Radio.update();
if( Status.channelData[ 1 ].raw > 1700 )
{
// Elevator was up
// -> this calibration was intended and should be saved.
Radio.saveCalibration();
INFO( "Calibration saved" );
calibrationSaved = true;
}
}
#endif
if( !calibrationSaved )
{
// Calibration didn't happen or it did but elevator wasn't up
// -> Ignore calibration and load old values.
Radio.loadCalibration();
INFO( "Calibration loaded" );
}
Serial.println( "OK" );
}
void main()
{
disable_interrupts(GLOBAL);
setup_spi(SPI_MASTER | SPI_MODE_0_0 | SPI_CLK_DIV_16 );
setup_spi2(SPI_MASTER | SPI_MODE_0_0 | SPI_CLK_DIV_16 );
setup_adc_ports(sAN0|sAN1|sAN2|sAN3|sAN4|VSS_4V096);
setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0);
// TIMER 0 is being used to service the WTD
setup_timer_0(T0_INTERNAL|T0_DIV_256);
/* sets the internal clock as source and prescale 256.
At 10 Mhz timer0 will increment every 0.4us (Fosc*4) in this setup and overflows every
6.71 seconds. Timer0 defaults to 16-bit if RTCC_8_BIT is not used.
Fosc = 10 MHz, Fosc/4 = 2.5 Mhz, div 256 = 0.0001024 s, 65536 increments = 6.71 sec
Fosc = 64 MHz, Fosc/4 = 16 Mhz, div 256 = 0.000016 s, 65536 increments = 1.05 sec
.. pre-load with 3036 to get exact 1.0000 sec value
*/
// TIMER 1 is used to extinguish the LED
setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
/* sets the internal clock as source and prescale 4.
At 10Mhz timer0 will increment every 0.4us in this setup and overflows every
104.8 ms. Timer1 is 16-bit.
Fosc = 10 Mhz ... 2.5 MHz / div 4 = 0.00000160 s * 65536 = 0.104858 sec
Fosc = 64 Mhz ... 16 MHz / div 4 = 0.00000025 s * 65536 = 0.016384 sec
Fosc = 64 Mhz ... 16 MHz / div 8 = 0.00000200 s * 65536 = 0.032768 sec
*/
setup_stepper_pwm(); // Uses TIMER 2
// TIMER 3 is used for stepper motor intervals
setup_timer_3(T3_INTERNAL | T3_DIV_BY_1); // 16 bit timer
// TIMER 4 is use for serial time-outs. 8-bit timer.
setup_timer_4(T4_DIV_BY_4, 127, 1);
setup_comparator(NC_NC_NC_NC);
setup_oscillator(OSC_16MHZ | OSC_PLL_ON); // Fosc = 64 MHz
ext_int_edge(0, H_TO_L); // Set up PIC18 EXT0
enable_interrupts(INT_EXT);
start_heartbeat();
enable_interrupts(GLOBAL);
init_hardware();
motor_sleep_rdy();
sleep_mode = FALSE;
busy_set();
init_nv_vars();
get_step_vars();
init_aws();
blink();
//Add for TCP/IP interface
//delay_ms(15000);
signon();
RTC_read();
RTC_last_power();
RTC_reset_HT();
RTC_read();
RTC_read_flags();
if(nv_sd_status>0) fprintf(COM_A,"@SD=%Lu\r\n", nv_sd_status);
init_rtc(); // This is the FAT RTC
sd_status = init_sdcard();
if(sd_status>0) msg_card_fail();
reset_event();
if(m_error[0] > 0 || m_error[1] > 0) msg_mer();
if (m_comp[0]==FALSE) {
e_port[0]=0;
write16(ADDR_E1_PORT,0);
fprintf(COM_A, "@MC1,%Lu,%Ld\r\n", m_comp[0],e_port[0]);
}
if (m_comp[1]==FALSE) {
m_lin_pos[1]=-1;
write16(ADDR_M2_LIN_POS, -1);
fprintf(COM_A, "@MC2,%Lu,%Ld\r\n", m_comp[1],m_lin_pos[1]);
}
if (nv_cmd_mode == FALSE){
for(dt=0; dt<100; ++dt){
blip();
if (nv_cmd_mode == TRUE) {
busy_clear();
fputs("@OK!", COM_A);
command_prompt();
dt = 100;
}
}
}
else command_prompt();
user_quit = auto_sample_ready();
reset_cpu();
}
// unlimited times
void Light::blink(unsigned long on_time, unsigned long off_time) {
_forever = true;
blink(on_time, off_time, 0);
}
/**
* Alive object : blink a led (led_id) every second.
*/
boolean Alive::init() {
blink(5);
}
void PCF8574_HD44780_I2C::blink_on(){
blink();
}
