Subscribe
Contact us: info@robocon.in

Blog

Robocon India 2013 Rank List

rank list 2013 (1) rank list 2013 (2) rank list 2013 (3)

2008 after national presentation

download >> 2008 Robocon Presentation 2008 Robocon Presentation >> 4.86 MB, 527 Downloads ppt

Playstation 2 SPI to Serial Data Logger

Playstation 2 SPI to Serial Data Logger – 6/6/2008

Use a PIC184550 to generate commands to a PS2 controller and see what how it responds.
Both the command and response bytes are printed to the serial port.

Download >> Playstation 2 SPI to Serial Data Logger Playstation 2 SPI to Serial Data Logger >> 12.78 kB, 610 Downloads txt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
/*
Playstation 2 SPI to Serial Data Logger - 6/6/2008
 
Use a PIC184550 to generate commands to a PS2 controller and see what how it responds.
Both the command and response bytes are printed to the serial port.
 
*/
 
//------------ DEFINES ------------------------------- //
 
// this is a macro shortcut (this code will replace bitrev(c) at compile time)
// for reversing the bit order 
#define bitrev(c) c = (c & 0x0F) << 4 | (c & 0xF0) >> 4; \
     c = (c & 0x33) << 2 | (c & 0xCC) >> 2; \
     c = (c & 0x55) << 1 | (c & 0xAA) >> 1;
 
//------------ CONFIG ------------------------------- //
 
// Configure the chip in code instead of through MPLAB's Configure--> Configuration Bits... 
// menu.
 
// In summary, using an 8MHz crystal oscillator, these settings will yield
// 4 MIPs (Million Instructions per Sec), and disable the brown-out reset and watch-dog timer
 
// #pragma tells the compiler to write in a specific section of memory, in this case the config section
 
// FOSC and CPUDIV setup up the clock speed and oscillator settings.
// HS = high speed, more power is needed at higher frequencies
// HS = HSPLL_HS uses the built in PLL (Phase Locked Loop--basically a frequency multiplier)
#pragma config FOSC = HSPLL_HS
#pragma config CPUDIV = OSC4_PLL6  // since we're using PLL, it divides the PLL freq (96MHz) by 6 to get 16 MHz.
// (this is a dual purpose setting, if config FOSC = HS, it would divide that freq by 4)
#pragma config PLLDIV = 2 // The PLL is designed to run at 96MHz from a 4MHz crystal, this scales down our 8 MHz first.
#pragma config BOR = OFF // brownout reset disabled (resets chip when power voltage gets too low)
#pragma config WDT = OFF // watch dog timer OFF (resets chip if a certain bit doesn't get set every so often)
 
 
 
 
//------------ INCLUDES ------------------------------- //
 
// load macros and functions for 18 family
#include <p18cxxx.h>
// load macros and functions specific to 4550
#include <p18f4550.h>
#include "main.h"
// the hardward usart overlaps with SPI, so we use the c18 software uart
#include "sw_uart.h"
#include <stdio.h>
#include <portb.h>
#include <delays.h>
#include <string.h>
#include <stdlib.h>
#include <spi.h>
 
 
//------------ Prototypes ------------------------------- //
 
void Initial(void);
void print_ascii( unsigned char);
void print_ascii_r(unsigned char t, unsigned char t2);
void read_spi_to_buf(char*, unsigned char);
void write_buf_to_usart(char*, unsigned char);
void record_to_buffer_then_dump_to_usart(void);
void continuously_read_spi_and_dump_to_usart(void);
void send_commands_to_controller(void);
void print_buffer(void);
// send and receive a byte from the controller via SPI
void ps2_txrx(unsigned char data_out,unsigned char *reg_in);
 
 
 
 
//------------ Global Variables ------------------------------- //
 
int read_buf_index =0;
unsigned char print_buf[80];
unsigned char print_buf_index = 0;
 
uint8 PS2_ID, MSG;
uint8 PS2_byte1, PS2_byte2, PS2_byte3, PS2_byte4, PS2_byte5, PS2_byte6;
uint8 PS2_prev_byte1, PS2_prev_byte2, PS2_prev_byte3, PS2_prev_byte4, PS2_prev_byte5, PS2_prev_byte6;
unsigned char PS2_pressure[12];
 
 
 
 
 
// ---------------  utility functions ---------------- //
 
void ps2_txrx(unsigned char data_out,unsigned char *reg_in){
 char send = data_out;
 bitrev(data_out);
 SSPBUF = (data_out);
 while(!SSPSTATbits.BF);
 *reg_in = SSPBUF;
 bitrev(*reg_in);
 print_ascii_r(send, *reg_in); 
}
 
 
void print_ascii_r(unsigned char t, unsigned char t2) {
 // there's not enough time to send out serial RS-232 back to the computer
 // in between every byte, so output is stored in a buffer until the end 
 // of a packet.
 print_buf[2*print_buf_index] = t;
 print_buf[2*print_buf_index+1] = t2;
 if (print_buf_index < 38)
  print_buf_index++; 
}
 
void print_buffer() {
 char t = 0;
 print_buf_index = print_buf_index *2;
 while (t<print_buf_index) {
  print_ascii(print_buf[t++]);
  //print_ascii(0x7A);
  WriteUART('_');  
  print_ascii(print_buf[t++]);
  WriteUART(0x0D); 
 }
 print_buf_index = 0;
}
 
void print_ascii( unsigned char t) {
 char buf[20]; 
 sprintf((char *)buf, "%02X", t); // the (char *) is there to suppress a type error having to do with the (near / small pointer) memory model used in the compiler...
 putsUART(buf);
}
 
 
 
 
 
 
/*-----------------------------------------------*/
/*------------   M A I N   -----------------------*/
/*-----------------------------------------------*/
 
 
 
void main (void) {  
 
 Initial();  
 
// record_to_buffer_then_dump_to_usart();
 
// continuously_read_spi_and_dump_to_usart();
 
 send_commands_to_controller();
 
    while(1);
}
 
 
void Initial()
{
 
 ADCON0 = 0b00110000; 
 TRISCbits.TRISC7 = 0; // SDO (SPI Output) 
 LATBbits.LATB2 = 1;  //ATT for SPI)
 TRISB = 0b11111001;
 TRISCbits.TRISC6 = 0; // makes TX an output  
 // Fosc = 16 MHz, so the SPI data rate is 250kHz.  The playstation 2 usually
 // talks to controllers at 500kHZ, except the Guitar Hero controller.  Playstation 1 
 // talked at 250kHz.  Going at 500kHZ gave us some noise issues on some controllers.
 
 OpenSPI(SPI_FOSC_64, MODE_11, SMPMID);  //MODE_11 = (CKP, CKE) = (1,0) 
          //CKP=1 (idle clock state is high, active low)  
          //CKE=0 data is read when the clock transitions
          //from active to idle.  This causes the clock
          //to start out going low, and then high mid-cycle.
 OpenUART();    
 
 
 
 // initialize LED ports and set their tris bits
 PORTEbits.RE2 = 0;   
   TRISEbits.TRISE2 = 0;  
}
 
// warning, don't connect to play station as the two clocks will fight each other.
void send_commands_to_controller() {
 unsigned char response; 
 char buf[20]; 
 char t;
 
 
 // 0x42: general purpose poll and command for vibration motors, number of bytes depends on configuration 
 pin_ATT = 0;     // pull ATT low to signal gamepad
 ps2_txrx(0x01, &response);     // send:  Start (0x01 LSBF (order flipped in ps2_tx) 
 ps2_txrx(0x42, &PS2_ID.byte); // send:  Request Data (0x42 LSBF)      
 ps2_txrx(0x00, &MSG.byte);// receive gamepad ID: should be '0x5A' for 'ready to send'   
 ps2_txrx(0x00, &PS2_byte1.byte);   // receive: 1st byte of button states
 ps2_txrx(0x00, &PS2_byte2.byte);   // receive: 2nd byte of button states 
 ps2_txrx(0x00, &PS2_byte3.byte);   // receive: 3rd byte of button states 
 ps2_txrx(0x00, &PS2_byte4.byte);   // receive: 4th byte of button states
 ps2_txrx(0x00, &PS2_byte5.byte);   // receive: 5th byte of button states
 ps2_txrx(0x00, &PS2_byte6.byte);   // receive: 6th byte of button states 
 pin_ATT = 1; // reset the ATTention line... can't just leave it low 
 Delay100TCYx(255); // not sure how much delay is necessary after each packet, but it seems to work inconsistently without these
 WriteUART(0x0D); // CR Carriage Return (new line)
 
 // 0x43: go in 'escape mode' or 'config mode'
 //01/ff 43/41 00/5a | 01/ff 00/ff
 pin_ATT = 0;
 ps2_txrx(0x01,&response);
 ps2_txrx(0x43, &PS2_ID.byte);
 ps2_txrx(0x00, &MSG.byte);
 ps2_txrx(0x01,&PS2_byte1.byte);
 ps2_txrx(0x00,&PS2_byte2.byte); 
 pin_ATT = 1;
 Delay100TCYx(255);
 WriteUART(0x0D);
 
/*
 // 0x41 get a bit map that shows which buttons are being returned in 0x42 calls.
  pin_ATT = 0;     // pull ATT low to signal gamepad
 ps2_txrx(0x01, &response);     // send:  Start (0x01 LSBF (order flipped in ps2_tx) 
 ps2_txrx(0x41, &PS2_ID.byte); // send:  Request Data (0x42 LSBF)      
 ps2_txrx(0x00, &MSG.byte);// receive gamepad ID: should be '0x5A' for 'ready to send'   
 ps2_txrx(0x00, &PS2_byte1.byte);   // receive: 1st byte of button states
 ps2_txrx(0x00, &PS2_byte2.byte);   // receive: 2nd byte of button states 
 ps2_txrx(0x00, &PS2_byte3.byte);   // receive: 3rd byte of button states 
 ps2_txrx(0x00, &PS2_byte4.byte);   // receive: 4th byte of button states
 ps2_txrx(0x00, &PS2_byte5.byte);   // receive: 5th byte of button states
 ps2_txrx(0x00, &PS2_byte6.byte);   // receive: 6th byte of button states  
 pin_ATT = 1;
 Delay100TCYx(60);
 WriteUART(0x0D);
 
*/
 
 // turn dual shock mode, or 'analog' mode on
 // 01/ff 44/f3 00/5a | 01/00 03/00 00/00 00/00 00/00 00/00 
 pin_ATT = 0;
 ps2_txrx(0x01,&response);
 ps2_txrx(0x44, &PS2_ID.byte);
 ps2_txrx(0x00, &MSG.byte);
 ps2_txrx(0x01,&PS2_byte1.byte);
 ps2_txrx(0x03,&PS2_byte2.byte);
 ps2_txrx(0x00,&PS2_byte3.byte);
 ps2_txrx(0x00,&PS2_byte4.byte);
 ps2_txrx(0x00,&PS2_byte5.byte);
 ps2_txrx(0x00,&PS2_byte6.byte);  
 pin_ATT = 1; 
 Delay100TCYx(255); // this delay was necessary for a Sony brand controller... delays may be necessary after
 // other commands, also,... not sure.
 
 WriteUART(0x0D);
 
 
 // setup motor mapping
 // 01/ff 4d/f3 00/5a | 00/00 01/01 ff/ff ff/ff ff/ff ff/ff
 pin_ATT = 0;
 ps2_txrx(0x01,&response);
 ps2_txrx(0x4d, &PS2_ID.byte);
 ps2_txrx(0x00, &MSG.byte);
 ps2_txrx(0x00,&PS2_byte1.byte); // whichever command byte has 00 will be the stop in the 0x42 poll cammand that triggers the smaller motor
 ps2_txrx(0x01,&PS2_byte2.byte); // applied to larger motor, which can be controlled with an 8 bit speed. smaller motor is just 0xFF for on, otherwise off.
 ps2_txrx(0xff,&PS2_byte3.byte);
 ps2_txrx(0xff,&PS2_byte4.byte);
 ps2_txrx(0xff,&PS2_byte5.byte);
 ps2_txrx(0xff,&PS2_byte6.byte);  
 pin_ATT = 1;
 
 
 WriteUART(0x0D);
 
 
 // request pressure sensing data
 // 01/ff 4f/f3 00/5a | ff/00 ff/00 03/00 00/00 00/00 00/5a 
 pin_ATT = 0;
 ps2_txrx(0x01,&response);
 ps2_txrx(0x4f, &PS2_ID.byte);
 ps2_txrx(0x00, &MSG.byte);
 ps2_txrx(0xff,&PS2_byte1.byte);
 ps2_txrx(0xff,&PS2_byte2.byte);
 ps2_txrx(0x03,&PS2_byte3.byte);
 ps2_txrx(0x00,&PS2_byte4.byte);
 ps2_txrx(0x00,&PS2_byte5.byte);
 ps2_txrx(0x00,&PS2_byte6.byte);  
 pin_ATT = 1;
 Delay100TCYx(255); // requires large delay here? maybe
 
 WriteUART(0x0D);
 
 
 // 0x41 get a bit map that shows which buttons are being returned in 0x42 calls.
 pin_ATT = 0;     // pull ATT low to signal gamepad
 ps2_txrx(0x01, &response);    // send:  Start (0x01 LSBF (order flipped in ps2_tx) 
 ps2_txrx(0x41, &PS2_ID.byte); // send:  Request Data (0x42 LSBF)      
 ps2_txrx(0x00, &MSG.byte);// receive gamepad ID: should be '0x5A' for 'ready to send'   
 ps2_txrx(0x00, &PS2_byte1.byte);   // receive: 1st byte of button states
 ps2_txrx(0x00, &PS2_byte2.byte);   // receive: 2nd byte of button states 
 ps2_txrx(0x00, &PS2_byte3.byte);   // receive: 3rd byte of button states 
 ps2_txrx(0x00, &PS2_byte4.byte);   // receive: 4th byte of button states
 ps2_txrx(0x00, &PS2_byte5.byte);   // receive: 5th byte of button states
 ps2_txrx(0x00, &PS2_byte6.byte);   // receive: 6th byte of button states  
 pin_ATT = 1;
 Delay100TCYx(255);
 WriteUART(0x0D);
 
 
 
 // exit escape mode 2nd method by lynxmotion: "CONFIG_MODE_EXIT_DS2_NATIVE" ... using only the first 2 bytes with 0's doesn't work on China knockoffs
 //CMD=01,43,00,00,5A (5A,5A,5A,5A)
 // on the guitar hero controller, the 5A's seemed to be necessary (as oppsed to 0x00's).  not lots of testing on this
 pin_ATT = 0;
 ps2_txrx(0x01,&response);
 ps2_txrx(0x43, &PS2_ID.byte);
 ps2_txrx(0x00, &MSG.byte);
 
 ps2_txrx(0x00,&PS2_byte1.byte); 
 ps2_txrx(0x5A,&PS2_byte2.byte);
 ps2_txrx(0x5A,&PS2_byte3.byte);
 ps2_txrx(0x5A,&PS2_byte4.byte);
 ps2_txrx(0x5A,&PS2_byte5.byte);
 ps2_txrx(0x5A,&PS2_byte6.byte); 
 pin_ATT = 1;
 Delay100TCYx(255);
 
 WriteUART(0x0D);
 
 
 
 while(1) {
  // poll and command
  pin_ATT = 0;     // pull ATT low to signal gamepad
  ps2_txrx(0x01, &response);     // send:  Start (0x01 LSBF (order flipped in ps2_tx)    
  ps2_txrx(0x42, &PS2_ID.byte); // send:  Request Data (0x42 LSBF)      
  ps2_txrx(0x00, &MSG.byte);// receive gamepad ID: should be '0x5A' for 'ready to send'   
 
  ps2_txrx(PS2_pressure[0], &PS2_byte1.byte);   // receive: 1st byte of button states and set big (left) motor to Left arrow pressure
  ps2_txrx(PS2_pressure[1], &PS2_byte2.byte);   // receive: 2nd byte of button states and turn on small (right) motor if Right arrow pressure = 0xFF
  ps2_txrx(0x00,&PS2_byte3.byte);   // receive: 3rd byte of button states 
  ps2_txrx(0x00,&PS2_byte4.byte);   // receive: 4th byte of button states
  ps2_txrx(0x00,&PS2_byte5.byte);   // receive: 5th byte of button states
  ps2_txrx(0x00,&PS2_byte6.byte);   // receive: 6th byte of button states 
 
  ps2_txrx(0x00, &PS2_pressure[0]);
  ps2_txrx(0x00, &PS2_pressure[1]);
  ps2_txrx(0x00, &PS2_pressure[2]);
  ps2_txrx(0x00, &PS2_pressure[3]);
  ps2_txrx(0x00, &PS2_pressure[4]);
  ps2_txrx(0x00, &PS2_pressure[5]);
  ps2_txrx(0x00, &PS2_pressure[6]);
  ps2_txrx(0x00, &PS2_pressure[7]);
  ps2_txrx(0x00, &PS2_pressure[8]);
  ps2_txrx(0x00, &PS2_pressure[9]);
  ps2_txrx(0x00, &PS2_pressure[10]);
  ps2_txrx(0x00, &PS2_pressure[11]);   
  pin_ATT = 1;
 
  print_buffer(); 
  WriteUART(0x0D); 
  Delay1KTCYx(20);
  Delay1KTCYx(255);
  Delay1KTCYx(255);
  Delay1KTCYx(255);
 
 } 
}

Robocon 2009 Traveller Robot Code

We are now releasing our 2009 Traveller Robot Code. Its written in C for atmega. Its old and primitive in nature but can help lot of new teams.

Download >> Robocon 2009 Traveller Robot Code Robocon 2009 Traveller Robot Code >> 10.01 kB, 1210 Downloads c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
 
//red zone done
// working at high speed...
//code freazed////// 
 
#include <avr/io.h>
#include <util/delay.h>
#include<avr\interrupt.h>
#include<avrlibdefs.h>
#define keypad_PORT L     ///////////keypad PORT SHOULD BE SPECIFIED HERE///////////////////
#define HD44780_PORT J    ////////////LCD PORT SHOULD BE SPECIFIED HERE INSTEAD OF INSIDE defines.h///////////
#include <mit_tech/keypad.h>
#include <mit_tech/lcd.h>
#include <mit_tech/eeprom.h>
 
#define rwall 117  //distance by gp2d for stoping to turn at crossing(!yeeks but there is no line)
#define lwall 115
#define sidewall 75
 
#define error 3
#define sideerror 2
#define turntime 90 //for maxspeed 10
#define centertime 70
#define celltime 160
 
#define acc 4.5
#define wallslow 105
#define dfactor 2
#define nowall 50
#define laststopdelay 15
 
 
 
#define left         PORTD               // PA6 
#define right        PORTK               // PA6 NOW not ulta fulta....
 
volatile unsigned char leftgp=0,rightgp=0,gpflag=0, rightback=0,rightfront=0,sideflag=0;
 
volatile float maxspeed=20; 
 
void menu(void);
void boarding(void);
void red_zone(void);
void blue_zone(void);
int curr=1,choice=0;
 
ISR(INT4_vect, ISR_NOBLOCK)
{
menu();	
}
char mainmenu[][14]={"     MENU",
			  "1)Codes",
			  "2)Config",
			  "3)Help",
			  "4)Exit",
			  };
char codemenu[][14]={"CODE MENU",
			  "1)Boarding",
			  "2)Blue zone",
			  "3)Red zone",
			  "4)Back",
			  };
 
void code_menu(void)
{
curr=1;
while(1)
	{
	 putc('\n',stderr);
	 lcdprintf(codemenu[curr-1]);
	 nextline();
	 lcdprintf(codemenu[curr]);
	 lcdprintf("<<--");
	 choice=get_key();
	 if(choice==2)
		{
		 if(curr!=1)
			curr--;
		}
	 else if(choice==8)
		{
		 if(curr!=4)
			curr++;
		}
	 else if(choice==5)
		{
		 if(curr==1)
			{
			 lcdprintf("\nboarding");
			 delay(1);
			 boarding();
			}
		 if(curr==2)
			{
			 lcdprintf("\nblue zone");
			 delay(1);
			 blue_zone();
			}
		 if(curr==3)
			{
			 lcdprintf("\nred zone");
			 delay(1);
			 red_zone();
			}
		 if(curr==4)
			{
			menu();
			}
		}
	}
}
void menu(void)
{
curr=1;
while(1)
	{
	 putc('\n',stderr);
	 lcdprintf(mainmenu[curr-1]);
	 nextline();
	 lcdprintf(mainmenu[curr]);
	 lcdprintf("<<--");
	 choice=get_key();
	 if(choice==2)
		{
		 if(curr!=1)
			curr--;
		}
	 else if(choice==8)
		{
		 if(curr!=4)
			curr++;
		}
	 else if(choice==5)
		{
		 if(curr==4)
			{
			lcdprintf("\nBye Bye...");
			_delay_ms(1);
			while(1);
			}
		 if(curr==1)
			{
			 code_menu();
			}
		}
	}
}
 
void port_init(void)
{
 
  DDRD=0xFF;                //////left motor//////////////////////////////////////
  PORTD=128;
 
  DDRK=0xFF;               //////////right motor//////////////////////////////////
  PORTK=128;
 
  sbi(DDRL,7);            /////////Left enable/////////////////////////////////////
  sbi(PORTL,7);
 
  sbi(DDRJ,7);           //////////Right enable////////////////////////////////////
  sbi(PORTJ,7);
 
 DDRF  = 0x00; //gp2d left at 0 right at 1
 PORTF = 0x00;	
 
  DDRE|=0XA0;   //intruptsssss....
  PORTE|=0X50;
 
//ab sarvo in pins par
sbi(DDRB,7);
 sbi(DDRB,5);
 cbi(PORTB,7);
 cbi(PORTB,5);
 
 
 
//sari ki sari moters(matlab sare pwm)
 sbi(DDRH,3);
 sbi(DDRE,2);
 sbi(DDRE,3);
 sbi(DDRH,4);
 sbi(DDRF,4);
 sbi(DDRF,5);
 sbi(DDRH,5);
 sbi(DDRF,6);
 sbi(DDRF,7);
 sbi(DDRG,5);
 sbi(DDRH,2);
 sbi(DDRH,6);
//bas etne hi....
 
 
}
 
void init_timer(void)
{
 
 //sari ki sari moters(matlab sare pwm)
 TCCR4A=0xA9;
 TCCR4B=0x01;
 TCCR4C=0x00;
 TCCR0A=0X21;
 TCCR0B=0X01;
 //bas etne hi....
 
 
TCCR1A=0x89;
 TCCR1B=0x05;
 TCCR1C=0x00;
 
 
 
 
}
 
void pole_speed(int a)
{
 
 OCR4CL=a;
 
}
 
void top_servo(int a)
{ 
OCR1A=a;
//min=8 max 16
}
 
void bottom_servo(int a)
{ 
 OCR1C=a;
 //close 18 open 12
}
 
void adc_init(void)
{
	ADCSRA |=0xDF;
	ACSR |=0x80;
	ADMUX =0xE0;
	ADCSRB &=0xF7;
}
 
 
ISR(ADC_vect)
{
 
if(sideflag==0)
{
 if(gpflag==0)	
	{
	leftgp=ADCH;
	gpflag=1;	
	ADMUX =0xE1;
	}
 else
	{
	rightgp=ADCH;
	gpflag=0;	
	ADMUX =0xE0;
	}
	ADCSRA |=0x40;
}
else if(sideflag==1)
{
 if(gpflag==0)	
	{
	rightback=ADCH;
	gpflag=1;	
	ADMUX =0xE2;
	}
 else
	{
	rightfront=ADCH;
	gpflag=0;	
	ADMUX =0xE3;
	}
	ADCSRA |=0x40;
}
 
 
}
 
 
 
 
 
 
 
 
void lower(void)
{
 
	sbi(PORTF,6);
 
}
 
void raise(void)
{
 
	cbi(PORTF,6);
 
}
 
 
void init_all(void)
 
{
int i;
 
	lcd_init();
	key_init();
	stderr = &lcd_str; 
 
	port_init();
	init_timer();
	adc_init();
	EICRB=0X22;
	EIMSK=0X50;	
 
 
	 cbi(DDRE,4);
	 sbi(PORTE,4);
 
	sei();
 
 
	fprintf(stderr, "\nMIT TECH TEAM");
	nextline();
 
for (i = 0; i < 3; i++)
    {
      putc('.', stderr);
      delay_10ms(20);
    }
 
}
 
 
 
void enable_ads(void)
{
 sbi(PORTL,7);
 sbi(PORTJ,7);
 
 PORTD=128;
 PORTK=128;
}
 
 
 
void brake_ads(void)
{
 sbi(PORTL,7);
 sbi(PORTJ,7);
 
 PORTD=128;
 PORTK=128;
}
 
void disable_ads(void)
{
 cbi(PORTL,7);
 cbi(PORTJ,7);
}
 
//+ve for forward -ve for ulta
void set_speed (int a,int b)
 
{
	PORTD=(128+a);
	PORTK=(128+b);
}
 
 
void righthard(void)
{
enable_ads();
set_speed(maxspeed,-maxspeed);
delay_10ms(turntime);
brake_ads();
}
 
void rightcenter(void)
{
enable_ads();
set_speed(maxspeed,-maxspeed);
delay_10ms(centertime);
brake_ads();
}
 
void lefthard(void)
{
enable_ads();
set_speed(-maxspeed,maxspeed);
delay_10ms(turntime);
brake_ads();
}
 
void leftcenter(void)
{
enable_ads();
set_speed(-maxspeed,maxspeed);
delay_10ms(centertime);
brake_ads();
}
 
 
 
void boarding(void)
{
enable_ads();
set_speed(-20,-20);
delay_10ms(celltime);
set_speed(0,0);
while(1);
}
 
void red_zone(void)
{
int leftsp=0,rightsp=0,lf=0,rf=0;
int i;
 
 
bottom_servo(18);
delay_10ms(50);
 
 
//forward at high speed
maxspeed=40;
for(i=0;i<maxspeed;i++)
	{
	 set_speed(i,i);
	 _delay_ms(acc); 
	}
leftsp=maxspeed;
rightsp=maxspeed;
while(rightgp<wallslow && leftgp<wallslow);
////////////////////
 
 
//align with wall
maxspeed=10;
while(1)
	{
_delay_ms(1);
if(rightgp<(rwall-error))
	{
	 rightsp=maxspeed;
	 rf=0;
	}
else if(rightgp>(rwall+error))
	{
	 rightsp=-maxspeed/2;
	 rf=0;
	}
 else
	{
	 rf++;
	 if(rf>10)
		{
		rightsp=0;
		}
	}
 
if(leftgp<(lwall-error))
	{
	 leftsp=maxspeed;
	 lf=0;
	}
else if(leftgp>(lwall+error))
	{
	 leftsp=-maxspeed/2;
	 lf=0;
	}
else
	{
     lf++;
	 if(lf>10)
		{
		 leftsp=0;
		}
	}
set_speed(leftsp,rightsp);
 
 
if(rightsp==0)//sometimes above condition never break....
	{
		if(leftsp==0)
			break;
	}
 
}
////////////
 
 
 
brake_ads();
maxspeed=20;
delay_10ms(20);
sideflag=1;
lefthard();
delay_10ms(20);
 
//forward at v high speed.....
maxspeed=80;
for(i=0;i<maxspeed;i++)
	{
	 set_speed(i,i);
	 _delay_ms(acc); 
	}
leftsp=maxspeed;
rightsp=maxspeed;
////////////
 
//align with side wall till front sensor is gone
while(1)
{
_delay_ms(1);
if(rightfront<(sidewall-sideerror))
	{
	 leftsp=maxspeed;
	 rightsp=maxspeed-((sidewall-rightfront)/dfactor);
	}
else if(rightfront>(sidewall+sideerror))
	{
	 rightsp=maxspeed;
	 leftsp=maxspeed-((rightfront-sidewall)/dfactor);
	}
else
	{
	 leftsp=maxspeed;
	 rightsp=maxspeed;
	}
if(leftsp<2)
	leftsp=2;
if(rightsp<2)
	rightsp=2;
set_speed(leftsp,rightsp);
 
if(rightfront<nowall)//till back sensor is off....
	{
	 maxspeed=30;
	 set_speed(maxspeed,maxspeed);
	 while(rightback>nowall);
	 delay_10ms(laststopdelay);
	 break;
	}
}
//////////////////////////////////////////////////////////////////////////////
 
 
 
set_speed(0,0);
brake_ads();
bottom_servo(12);
maxspeed=10;
delay(1);
rightcenter();
top_servo(12);
 
delay(1);
raise();
pole_speed(150);
delay(2);
pole_speed(00);
 
while(1)
{
top_servo(8);
delay(1);
top_servo(16);
delay(1);
}
 
}
 
void blue_zone(void)
{
int leftsp=0,rightsp=0,lf=0,rf=0;
int i;
 
 
bottom_servo(18);
delay_10ms(50);
 
 
//forward at high speed
maxspeed=40;
for(i=0;i<maxspeed;i++)
	{
	 set_speed(i,i);
	 _delay_ms(acc); 
	}
leftsp=maxspeed;
rightsp=maxspeed;
while(rightgp<wallslow && leftgp<wallslow);
////////////////////
 
 
//align with wall
maxspeed=10;
while(1)
	{
_delay_ms(1);
if(rightgp<(rwall-error))
	{
	 rightsp=maxspeed;
	 rf=0;
	}
else if(rightgp>(rwall+error))
	{
	 rightsp=-maxspeed/2;
	 rf=0;
	}
 else
	{
	 rf++;
	 if(rf>10)
		{
		rightsp=0;
		}
	}
 
if(leftgp<(lwall-error))
	{
	 leftsp=maxspeed;
	 lf=0;
	}
else if(leftgp>(lwall+error))
	{
	 leftsp=-maxspeed/2;
	 lf=0;
	}
else
	{
     lf++;
	 if(lf>10)
		{
		 leftsp=0;
		}
	}
set_speed(leftsp,rightsp);
 
 
if(rightsp==0)//sometimes above condition never break....
	{
		if(leftsp==0)
			break;
	}
 
}
////////////
 
 
 
brake_ads();
maxspeed=20;
delay_10ms(20);
sideflag=1;
righthard();
delay_10ms(20);
 
//forward at v high speed.....
maxspeed=80;
for(i=0;i<maxspeed;i++)
	{
	 set_speed(i,i);
	 _delay_ms(acc); 
	}
leftsp=maxspeed;
rightsp=maxspeed;
////////////
 
//align with side wall till front sensor is gone
while(1)
{
_delay_ms(1);
if(rightfront<(sidewall-sideerror))
	{
	 leftsp=maxspeed;
	 rightsp=maxspeed-((sidewall-rightfront)/dfactor);
	}
else if(rightfront>(sidewall+sideerror))
	{
	 rightsp=maxspeed;
	 leftsp=maxspeed-((rightfront-sidewall)/dfactor);
	}
else
	{
	 leftsp=maxspeed;
	 rightsp=maxspeed;
	}
if(leftsp<2)
	leftsp=2;
if(rightsp<2)
	rightsp=2;
set_speed(leftsp,rightsp);
 
if(rightfront<nowall)//till back sensor is off....
	{
	 maxspeed=30;
	 set_speed(maxspeed,maxspeed);
	 while(rightback>nowall);
	 delay_10ms(laststopdelay);
	 break;
	}
}
//////////////////////////////////////////////////////////////////////////////
 
 
 
set_speed(0,0);
brake_ads();
bottom_servo(12);
maxspeed=10;
delay(1);
leftcenter();
top_servo(12);
 
delay(1);
raise();
pole_speed(150);
delay(2);
pole_speed(00);
 
while(1)
{
top_servo(8);
delay(1);
top_servo(16);
delay(1);
}
 
}
 
int main(void)
{
cli();  
init_all();
sei();
menu();
  return 0;
}

Robocon 2012 Mechanical Report

Manual Robot

When the theme came in September, the main challenge was to make a machine that can take not only the load of a man but also of the collector machine dynamically.
Now the motor was safe to experiment with. Now the next challenge in front of us was the motor which could deliver the power required to move a Man and the machine as fast as we can. The first thing that came into mind was to use 150W DC motor which we usually call as badi motor and it worked. Then came the steering option either to do it manually or electronically. The manual steering was chosen so that to have more control over the BOT.

Design prototypes:

When we first made a prototype of the Manual as shown in the PICTURE, the problem we had was of the steering, the wheel slipped while taking turns as there was less load on it. So as to overcome this problem we used the manual operators weight and shifted one third weight of the operator on the wheel steering it and rest two third was on the driving wheels. This was the second prototype.
Also on making this newer design we thought of a way to decrease the turning radius of the manual robot in order to give it better & easier handling while navigating through obstacles all over the field. This was achieved by making the frame smaller in length as shown. In this way the third prototype was made & slowly by some more modifications, the design was made final.

Prototype1:

Prototype2:

Prototype3:

AUTONOMOUS ROBOT

Robocon 2012 presented a challenging new theme that had a whole new level of difficulty. Three robots were supposed to be made that performed a series of tasks some of which included an operator riding a robot and maneuvering it, one machine carrying the other over a bridge, a machine climbing up a step etc.

Automatic robot was one of the three that were supposed to be made for the contest. It was the connecting link between the other two bots; the manual and the collector.

This automatic robot had to perform a series of tasks some of which included:

  • Lifting the basket from the common zone.
  • Placing the basket in the manual zone.
  • Clamping the collector and carrying it over the bridge.
  • Safely unloading the collector.

There were many problems faced during the process of designing and fabrication of the automatic robot.

Some of the major design challenges faced by the mechanical team were as follows:

  • Building a robot which could pick up the basket faster than the opponents.
  • Designing the robot within the weight constraints.
  • Designing the bots such that it could unload the collector bot without touching the loading area.
  • The bot was supposed to ascend and descend a ramp of an inclination of about 17 degrees with another robot so the design was supposed to have a low centre of gravity and at the same time navigate over the bridge with ease.
  • The design was supposed to be very robust.

With all these design constraints into consideration the mechanical team set out to build the Automatic robot which later crowned as the best three robots in the nation.

THE ACTUAL TASK:

  • When the Token is totally put inside the Token Box, motion of Automatic Robot can be self started or started by “one push button” by a team member after the signal from referees. Automatic Robot may start picking up the Basket in the Common Zone and puts it in any place of Manual Robot Zone. Or, Automatic Robot may start later as the strategy of the team. The task of putting the Basket in Manual Robot Zone will be considered as “Completed” when the Basket is put in Manual Robot Zone and is standing on its own on its bottom base; it means there is no contact between the Basket and neither Automatic Robot nor Manual Robot.
  • Automatic Robot of each team is allowed to touch only one of the two Baskets in the Common Zone and a team can only pick up the same Basket which they have touched before and if it is available.
  • When Collector Robot is completely separated from Manual Robot and transferred to Automatic Robot, motion of Automatic Robot can be self started or be started by a team member by “one push button”. There is no rule to guide the sequence for Automatic Robot to pick up the Basket and the Collector Robot. The team can pick up both items simultaneously.
  • Automatic Robot carries Collector Robot across the Bridge towards Collector Robot Loading Area 2 or Loading Area 3.
  • After transferring Collector Robot to Automatic Robot, Manual Robot is allowed to pick up the Basket when it is placed in Manual Robot Zone and puts the Basket in the Basket Area on the Island. When the Basket was placed at the Basket Area, no robot is allowed to touch the Basket.
  • Automatic Robot must unload Collector Robot inside Loading Area 2

 

In order to fulfill this task the mech team thought of various designs in stages eventually finalizing on one of them.

Three of the many designs that were implemented and tested were as given below:

DESIGN 1:

This was the first prototype of the automatic robot. It could perform the basic tasks of the automatic robot. A 3D drawing of this frame is given below for better understanding.

The actual design of this prototype was as follows:

SALIENT FEATURES

  • THE BASE FRAME:
    • The base frame of this machine was one of the smallest frames.
    • The dimensions of the base frame were 40cm x 40cm x 20cm.
    • The machine was designed keeping into consideration that machine had to carry a load of almost 10 kgs along with its self weight so it was also very sturdy.
    • The base frame was an ‘I’ shaped frame with another box frame on top joined by an array of supporting sections.
    • This platform was kept at a maximum height of 20cm keeping in mind that the machine had to unload the collector at the loading area which was of that dimension.
    • The design being very compact sturdy and lightweight it was also one of the quickest reaching to the basket on almost 1 second.
  • JAW:
    • The distinguishing feature of this jaw was that it lifted the basket with its pole.
    • This jaw was made such that it could pull the basket partially inside the frame for better stability while maneuvering along with the basket.
    • It made use of a piston for gripping purpose.
    • Linear rails and guideways were used to draw the gripping mechanism in and out of the frame.
    • Another piston mounted diagonally was used to lift the basket from its groove.
  • PROBLEMS FACED:
  •  The main problem with this assembly was that it was due to its compactness it was unable to navigate on the ramp along with the collector robot very efficiently.
  • Moreover with the front jaw assembly it had to navigate a lot more than the current design.

Due to this very fact that this design wasn’t able to navigate on the bridge very efficiently it was discarded.

DESIGN 2:
To overcome the problems faced in the previous design this design was made bigger.

An actual picture of this design is as presented below.

SALIENT FEATURES:

  • BASE  FRAME:
    • The base frame of this design had the dimensions of 58cm x 55cm x 20cm.
    • Here too as we see that the height was kept at 20cm as earlier.
    • Special attention was paid for the electronics mounting in this frame.
    • The weight distribution was more equitable and favorable for navigation on the bridge.
    • This design could navigate with greater weight with more ease.
    • The best part of this design was that it could complete the bridge navigation part within 10 seconds (this is a record time within the lab)

This picture shows the automatic bot and the collector bot both on the ramp for the first time.

  • JAW:
    • The jaw assembly of this design was a little different.
    • It consisted of two parts the supporting jaw and the gripper.
    • The supporting jaw supported the basket from the base and the gripper held it from its pole.
    • This gripper assembly slid out from the frame.
    • This assembly could come in and out of the frame by means of a rail guide assembly and the actuation was achieved by means of a rack and pinion.

A picture of this assembly is shown below for better understanding

  • PROBLEMS FACED:
    • This machine was tried for a long time as it seemed nearly perfect for navigation over the ramp.
    • But even this machine posed a lot of problems.
    • The biggest problem of this machine was that because of its huge base frame its momentum would swing on either side of its centre before it could take corrections to keep it on track.
    • With rigorous testing we concluded that we could not control this machine’s speed within a particular point.
    • This was disadvantageous as we had to grab the first basket to save time.
    • Thus after months of testing this machine was discarded due to all these reasons.

Finally we came up with a third design which was a compromise between both the small and the big versions of the AUTO.

 

DESIGN 3:

This design had an array of changes as compared to the earlier designs.

Some of the distinguishing features this design was that its ground clearance was variable and adjusted such that it could navigate over the ramp with ease.

Some of the salient features of this design are as follows:

BASE FRAME:

  • The base frame of this design was very different.
  • Its base was kept at an angle with the ground instead of keeping it parallel to the ground.
  • Also this was the first time that the motors were mounted inverted with respect to the frame.

The 3D drawing below amply illustrates the base frame at an angle

The figure below shows motors’ inverted mounting

JAW :

  • The jaw assembly in this design was much improved than the previous two designs.
  • We were able to drop the basket without the use of an independent gripper as in the earlier designs.
  • This also gave MIT a unique tag that we threw the basket as our placing almost seemed like throwing.
  • With this jaw mechanism we were able to achieve the perfect blend amongst the earlier two designs.
  • MIT had a distinguished honour of having the least basket grabbing time.

        The figure below gives a detailed explanation of the jaw assembly. 

DESIGN CONSIDERTIONS:

  • Various factors were considered while designing this prototype.
  • The most important consideration was that of the CG of the machine as the CG played a very important role in maneuvering of the machine.

The 3D design of the calculations of the CG for the AUTO

  • An important part of the designing was constructing a 3D design of the entire machine so as to have a better understanding of the machine.

  The 3D design of the AUTO made in catia.

  • The design finally chosen was rigorously tested for two months before it was finalized for being used in the competition.
  • As many as 300 complete test runs of the machine were taken before it was finalized.

COLLECTOR ROBOT

The Task:

The collector robot was the second autonomous robot in this theme. The main task of collector robot was picking up the buns from the bun tower and placing them in the basket. Also the strategy demanded the collector robot to climb a 20cm step to climb on the Island where the Bun tower stood. This machine was to be picked by the Manual machine from its Start Zone and placed on the Automatic Machine. The Automatic Robot then carried the Collector from the Automatic Start Zone to the Loading area L2 by passing over The Bridge (Ramp).

There was an alternate strategy possible wherein the Automatic Robot could unload the Collector Robot at Loading Area L3 by maneuvering around the obstacle in the Automatic Zone.  For this strategy, the Collector Robot wouldn’t need to climb the step as the Manual Robot could place it directly on the Island. However that strategy wasn’t used by MIT as it required more navigation for the Automatic Robot and also the Step Climbing strategy was faster.

On the Island, it must pick one bun each from the lower layer and the middle layer and put them in the Basket placed in the basket area of the Island. Only after this is completed, the Manual must pick up the Collector which can then pick up the bun placed on the Top Layer of the Bun Tower. Once this bun was dropped in the basket, the game will get over and the team has achieved “Peng On Dai Gat”.

As this machine was supposed to be carried by both the Manual as well as Automatic Robots, our main aim was to make this machine as robust and as light as possible. Any change in this machine’s structural design directly affected the dynamics of the other two machines. Along with the weight limitation, the machine had to be sufficiently robust so that it could be picked, carried, transferred with sufficient ease and not being affected by slight rough handling.

The Structure:

The main frame of the robot consisted of a T-shaped base frame which was developed in Robocon 2011. The Robot used front wheel drive i.e. the driving wheels were in front of the Robot. On the base frame a central pole was mounted which was almost one meter long. On this central pole the provision for being picked up by the manual robot, place of electronics mounting and the jaws assembly was mounted.

The Manual and Automatic Robots used electromagnets for clamping the Collector and a forklift to support its weight. So an electromagnetic counter was mounted on the back for the Automatic Robot and one on the central pole for the Manual Robot.

The Mechanisms:

  1. Step Climbing

The remarkable mechanism of the Collector Robot was the Step Climbing mechanism. It could climb the 20cm step in motion, quickly without stopping at any instant. The Team tried out 4 different step climbing mechanism in the first 2 days and finally the best mechanism was selected. The mechanism consisted of two folding legs on which the main frame stood; these legs would fold while climbing the step and the machine would then rest on the main driving structure.

For the national event, the legs were mounted on normal hinges which had spring (these hinges are used in cupboards, etc). These hinges fold immediately when they hit the step. Thus the impact with the step folded the hinges and the machine moved forward. The main difficulty was in finding the right hinges. After significant market research we got the hinges of our requirement. Hinges of 3 different manufacturers (Alaska, H’afel and Holz) were used. The hinges needed to be sufficiently rigid to avoid the folding of the legs before reaching the step and also to withstand the impact of hitting the step.

Collector Robot

For the international event, the mechanism was modified. Instead of folding the legs by impact, the legs were folded by pneumatic pistons. Two proximity sensors detected the distance from the step and folded the legs at the appropriate time. This allowed us to increase the speed of the collector on the loading area and also provided more rigidity and stability.

1. The Jaws

There were three jaws which picked up two buns from the lower layer (another unique strategy adopted by the Team) and one bun from the middle layer and dropped it in the basket. The buns were placed on studs of 4cm height so they needed to be raised by at least that height to clear the studs. The jaws were mounted on a rail which allowed vertical motion. The raising was done by pneumatic piston. The buns in the lower layer were at a height of 50cm while the basket had a height of 80cm so the lower layer buns needed to be raised further. This was achieved by rotating the two jaws by servo motor so that the buns were raised above that height.

Pro E design for the jaw

The gripping mechanism used this year was newly developed by using pneumatics. The pneumatic actuation provided sufficient gripping force along with quick actuation. Earlier motors were used in grippers but motor had a few disadvantages – a motor of high rpm didn’t have sufficient torque whereas a motor having sufficient torque didn’t have high speed.

The mechanism used for the international was modified further. In the national event, the jaws were unable to grip the buns properly sometimes. To overcome this, the jaw design was modified to provide better gripping and more tolerance.

Robocon India 2012 Match Result Details

League Matches






Super League Matches



Quarter Final Matches

Semi Final Matches

Final Match

ABU Robocon 2013 Vietnam Theme and rulebook problem statement

ABU Robocon 2013 Vietnam Theme and rulebook problem statement

Download >> ABU Robocon 2013 Vietnam Theme and rulebook PDF ABU Robocon 2013 Vietnam Theme and rulebook PDF >> 11.51 MB, 3725 Downloads pdf


1. OUTLINE OF THE GAME:

  1. Duration of the game is three (3) minutes
  2. Each team will have two (2) robots
  • One (1) Automatic Robot
  • One (1) Manual Robot; Manual Robot is not allowed to move into Earth Zone.
  1. The Manual Robot goes to the “Leaves Storage Area” for taking “Leaves” at the possitions in the Southern Hemisphere in their own game field
  2. The Manual Robot will place three Leaves in the Southern Hemisphere
  3. Then, Manual Robot  loads “Leaves” which have been taken from the ‘Leaves Storage Area’ onto Auto Robot.
  4. Auto Robot takes at least 3 leaves to Northern Hemisphere (including two leaves in its own zone and at least one leaf in the common zone). Then, the Automatic Robot is allowed to touch the Bud in the Northern Hemisphere.
  5. Auto Robot goes to the North Pole for taking the Buds (made by the team) and loading for Manual Robot.
  6. Manual Robot stands below second limit line and shoots the Bud into the moon. If the team’s Bud stands on the moon, the team will get the “Green Planet”.

2. TEAM MEMBERS

  1. Each team shall comprise of four (4) members consisting of three (3) students and one (1) instructor, from the same university, polytechnic or college. However, only these two (2) students are permitted to enter the Game Field.
  2. Team members must be enrolled in their University/Polytechnic at the time of the international contest. Exceptions are allowed for those who were enrolled in a University/Polytechnic at the time of the domestic contest.
  3. Postgraduates are not eligible to enter the competition.

3. GAME FIELD

  • The Game Field is made by plywood, the surface will be emulsion painted. The Game Field is surrounded by a wooden fence (100mm height-30mm thick);
  • The dimension is 13000mm x 13000mm, divided into 3 parts as follows:
  • The Earth Zone  (Sphere Shape) has a diameter of 8500mm with white guidelines (30mm in width) that represent maridian and parallel;
  • The moon is a round plate lays on the cylinder 1500mm height.
  • The part surround two above area.
  • The game field will be splited into 2 parts for 2 teams by a iron fence (along the Meridian) 60mm height, 30mm thick,
  • It includes Auto Robot operating area and Manual Robot operating area.
  • There are two (2) limit lines 1st and 2nd (30mm width); the first limit line is extension of Equator; the second limit line far from the Equator 2950mm
  1. The Manual Robot operating Area
  • Being the area suround the earth; and is painted light cyan
  • The Manual Robot Staring Zone

The dimension is 700 mm x 700 mm which is painted Red and Blue for two teams.

  • The leaves store

The team’s leaves store is located in the end of the game field. Before the Game starts, there will be 12 Leaves arranged at each Leaves Storage Area (See drawing for more details)

  1. The Auto Robot operating Area

Being the Earth Zone and the surrounding area

  • The Auto Robot Staring Zone

The dimension is 700 mm x 700 mm which is painted Red and Blue for two teams.

  • The Earth Zone
  • Being painted light Green. There is a green tree picture inside
  • There are 7 positions for putting the leaf (name: sprout); They have the surrounding boder (50mm height; 25mm thick); the inside diameter is 350mm. (See drawing for more details)
  • Vùng mặt trăng The moon

The moon is a polywood round plate (500mm diameter) lays on the top of steel cylinder (100mm diameter), The total height is 1500mm.

  1. OBJECT
  • Leaves are in the shape of cylinder (Outer diameter = 250mm, Height =        200mm, Weight = 200g). Leaves are made of high-density polystyrene and are coated with green emulsion paint, the top surface is printed the leaf with red pefuncle red for the Red Team, and blue for the Blue Team
  • The Bud will be made by the team themselves.
  • The minimum height of the ‘Bud’ must be 500mm from the bottom surface.
  • The maximum diameter of the ‘Bud’ must be over 300mm. The diameter of the contact surface of the bottom part should be over 150mm.
  • The maximum weight:                                 300 g

4. ROBOT

Each team must design and construct by themselves, Manual and Automatic Robots to compete in the contest. For each match, each team is allowed to have one (1) Manual Robot and one (1) fully Automatic Robot

  1. Manual Robot
  • The Manual Robot has to be operated via remote control using a cable connected to it or remote control using infrared rays, visible rays or sound waves. Controlling using radio waves are also not allowed. Operators are not allowed to ride on their Manual Robot
  • When operating via cable, the connecting point of the cable to the robot must be at least 1000mm from the ground. However, the length of the cable from the Manual Robot to the control box must not exceed 3000mm.
  • There is a size limit (700mm L x 700mm W and 1200mm H) for the Manual Robots at the Manual Robot Start Zones when the game starts
  • Manual Robots are not permitted to separate during the game
  • Only one (1) member of each team is allowed to control the Manual Robot in the Game Field.
  1. Automatic Robot
  • Automatic Robot must be autonomous completely
  • When the Automatic Robot starts, team members are not allowed to touch the Robot.
  • Automatic Robot should fit within the size of 700mm L x 700mm W and 1000mm H at its Start Zone before starting
  1. Retry
  • After a “retry” request is granted by the Referee, team member(s) must bring the Robot(s) that need to be retried back to their Start Zone and restart the Robot(s) as soon as possible. Automatic Robot(s), granted retry should follow Rule 4.2
  • On “Retry”, any parts of the Robots should not be replaced.  Also, power sources of the Robots should not be refilled nor added
  • When a “Retry” results in a change in the score or violation of the rules, it is up to the referees to rule on the situation, including with regard to the validity of the “Retry”
  1. Power Supply
  • Each team shall prepare its own power supply for all its Robots during the games.
  • Allowed power supply for Robot (s) shall not be exceeded 24VDC.
  • Power supply that is considered dangerous or unsuitable by the Contest Committee shall not be permitted
  1. Weight

All Manual and Automatic Robots, including their power sources, cables, remote controller and other parts of each Robot shall be weighed prior to competition. The total allowable weight of all Robots for each team to be used throughout the contest must not exceed 40kg

5. MATCHES

  1. Duration of the Match
  • Before the match begins, setting of the Robots need to be completed within one (1) minute after receiving the signal for setting.
  • Each match shall last for three (3) minutes
  • However, the first team to achieve “GREEN PLANET!” wins the match regardless of the point collected by the opponent. The match ends when “GREEN PLANET ” is achieved
  1. Competition Rules
  • The Manual Robot takes the Leaves in the “Leaves Storage Area” then brings them to 3 positions in the Southern Hemisphere on their own game field.
  • After putting 3 leaves at the Southern Hemisphere, the Manual Robot is allowed to load Auto Robot with leaves
  • Manual Robot is allowed to load Auto Robot with leaves at the Starting Zone or to move the leaves onto the floor of the game field above first limit line
  • Manual Robot is not allowed to pass the first limit line (the extended Horizon)
  • When Manual Robot stop taking and loading the leaves, Auto Robot will be allowed to start
  • Auto Robot goes to put the leaves onto the Northern Hemisphere on their own game field and the common zone.
  • Auto Robot can put maximum 5 leaves onto Northern Hemisphere, including maximum a leaf in the Common Zone in the opponent’s side
  • When Auto Robot attaches at least 3 leaves in the Northern Hemisphere, including 2 leaves outside of Common Zone then:

Auto Robot is allowed to pick the Bud up in the North Pole.

When Auto Robot touches any bud, it is not allowed to take the leaves again.

Manual Robot can enter the game field surrounding the Earth Zone to receive the Bud from Auto Robot.

  • The Manual Robot has to stand behind the second limit line when shooting the Bud to the moon. If the team’s Bud stands on the moon, the team will get the “Green Planet”
  1. Points Award
    1. The team gains point when they successfully put their own leaves onto their assigned Trees (completely right into the hole)
    2. Scoring:
  • Attach the leaf in the Earth zone:                          10 points/leaf
  • Automatic Robot give Manual Robot the bud:    10 points/bud
    1. “GREEN PLANET” is achieved when a team success following action:
  • Shoot the Bud onto the moon;
  • The Bud stands on the moon;
    1. VIOLATIONS AND DEDUCTION OF POINTS

The following actions will be regarded as violations and 5 (five) points will be deducted for each violation:

  1. Robot enters or extends over opponent’s zone (except common zone);
  2. Manual Robot enters planet zone;
  3. Automatic Robot starts before Manual Robot attaches 3 leaves in the Southern Hemisphere and stop moving the leaves
  4. Manual Robot continues to operate when Automatic Robot has started;
  5. Auto Robot continues to attach leaves after giving automatic Robot the buds

6. DISQUALIFICATION

The following behavior shall be considered for disqualification of the whole team by the referees.

  1. Causing or attempting to cause damage to the Game Field, its robots, or the opponent’s robots, including the arrangement of the leaves;
  2. Team’s members touch their own Robots intentionally;
  3. Robots climb up the wall and enter the opponent’s game field.
  4. Start before referee’s whistle or signal more than once
  5. Romove the opponent’s leaf
  6. Use the RF to interfere in opponent’s results
  7. Performing any act against the spirit of fair play;

7. SAFETY

  1. All Robots must be built so that they will not harm the operators, the referees, match officials, audience, equipment and the game field
  2. To ensure safety, when using a laser beam, it must be less than a Class 2 laser, and used in a way that will not harm any operators, the referees, match officials, audience, opponent’s equipment and the game field.
  3. The Bud will be made by the team themselve which will be used soft material and safe for operators, the referees, match officials, audience, opponent’s equipment and the game field.

8. OTHERS

  1. Any other behaviors not specified in the rules, referees are given full authority to make the decision and the decision is final in the event of a dispute
  2. The tolerance about dimension of game field and tools is ± 5% (excluding the tolerance which is mention above)
  3. Any amendments to the rules will be announced by the Contest Committee and be updated on website as the “FAQ”:
  4. All teams are encouraged to decorate two Robots in their own styles.
  5. Robots to take part in the contest must be made by the students themselves.
  6. When requested by the Contest Committee, each participating country will be asked to provide information on their robots, including the videotape, which explains the structure and the movement of the participating teams’ robots, prior to the shipment of the robot.

 

ABU Robocon 2013 Viet Nam theme demo Video

Download >> ABU Robocon 2013 Vietnam Theme and rulebook PDF ABU Robocon 2013 Vietnam Theme and rulebook PDF >> 11.51 MB, 3725 Downloads pdf

ABU Robocon 2012, Hong Kong Final Results

AWARDS

WINNER

NOTES

GRAND PRIX China The CHAMPION of ABU ROBOCON 2012
1ST RUNNER-UP Vietnam The 1st RUNNER-UP of ABU ROBOCON 2012
2ND RUNNER-UP Japan,
Thailand
The two 2nd RUNNER-UP of ABU ROBOCON 2012
ABU ROBOCON AWARD Japan The top honor in the ABU ROBOCON 2012 that commends the most preeminent team in ideas, originality, creativity and technology
BEST IDEA AWARD Hong Kong, China (Team 1) The award commends the team that demonstrates the most excellent idea in terms of structure of machines and strategy
BEST ENGINEERING AWARD Thailand The award commends the team that creates the most technically excellent robot
BEST DESIGN AWARD Malaysia The award commends the team that creates the most excellent robot design in terms of artistic and functional value
Panasonic AWARD Mongolia The award commends the team recommended by Panasonic, one of the Special Sponsors
TOYOTA AWARD Indonesia The award commends the team recommended by TOYOTA, one of the Special Sponsors
MABUCHI MOTOR AWARD India The award commends the team recommended by MABUCHI MOTOR, one of the Special Sponsors

 

Preliminary Match

Match Score
Match Red Team Blue Team Red Blue Winner
1 Hong Kong, China (Team 2) Brunei
Darussalam
80 20 Hong Kong, China (Team 2)
2 China Malaysia 115 80 China
(win by Peng On Dai Gat 37″)
3 Thailand Kazakhstan 95 -20 Thailand
(win by Peng On Dai Gat 1’29”)
4 Japan Russia 115 0 Japan
(win by Peng On Dai Gat 42″)
5 Hong Kong, China (Team 1) Nepal 115 10 Hong Kong, China (Team 1)
(win by Peng On Dai Gat 1′ 05″)
6 Vietnam Indonesia 105 80 Vietnam
(win by Peng On Dai Gat 54″)
7 Brunei
Darussalam
Mongolia 10 95 Mongolia
(win by Peng On Dai Gat 2′ 47″)
8 Malaysia India 95 40 Malaysia
(win by Peng On Dai Gat 1′ 48″)
9 Kazakhstan Fiji 0 10 Fiji
10 Russia Pakistan 0 80 Pakistan
11 Nepal Sri Lanka 40 0 Nepal
12 Indonesia Vietnam 10 115 Vietnam
(win by Peng On Dai Gat 1′ 08″)
13 Mongolia Hong Kong, China (Team 2) 0 80 Hong Kong, China (Team 2)
14 India China 105 40 India
(win by Peng On Dai Gat 1′ 56″)
15 Fiji Thailand 10 95 Thailand
16 Pakistan Japan 10 155 Japan
17 Sri Lanka Hong Kong, China (Team 1) 0 115 Hong Kong, China (Team 1)
(win by Peng On Dai Gat 1′ 07″)

Quarter-Finals, Semi-Finals and Final

Match Score
Match* Red Team Blue Team Red Blue Winner
QF1 Hong Kong, China (Team 2) Vietnam 30 115 Vietnam
(win by Peng On Dai Gat 55″)
QF2 Japan Malaysia 115 0 Japan
(win by Peng On Dai Gat 47″)
QF3 India Thailand 50 115 Thailand
(win by Peng On Dai Gat 1′ 19″)
QF4 Hong Kong, China (Team 1) China 40 115 China
(win by Peng On Dai Gat 38″)
SF1 Vietnam Japan 115 80 Vietnam
(win by Peng On Dai Gat 1′ 35″)
SF2 Thailand China 105 115 China
(win by Peng On Dai Gat 37″)
Final Vietnam China 40 115 China
(win by Peng On Dai Gat 37″)

*QF=Quarter-Final; SF=Semi-Final

Match Groups for Preliminary Round Of Abu Robocon 2012

Game

Red Team

Blue Team

1 Hong Kong, China (Team 2) Brunei Darussalam
2 China Malaysia
3 Thailand Kazakhstan
4 Japan Russia
5 Hong Kong, China (Team 1) Nepal
6 Vietnam Indonesia
7 Brunei Darussalam Mongolia
8 Malaysia India
9 Kazakhstan Fiji
10 Russia Pakistan
11 Nepal Sri Lanka
12 Indonesia Vietnam
13 Mongolia Hong Kong, China (Team 2)
14 India China
15 Fiji Thailand
16 Pakistan Japan
17 Sri Lanka Hong Kong, China (Team 1)
Page 2 of 3123