mca25_pgm_buggy.c

ENC28J60 System HTTP

				case 1:
					// wait for end of 256 Byte packet:
					// [F9 83 EF 11 ** ** ** ** ** ** ** ** 3F F9 ]
#if CAM_BUFFER_LEN == 256
					if ( (memcmp_P(buf,PSTR("\xF9\x83\xEF\x11"),4) == 0) ||
					     (memcmp_P(buf,PSTR("\xF9\x83\xEF\x1D"),4) == 0) ) {
#else
					if ( (memcmp_P(buf,PSTR("\xF9\x83\xEF\x21"),4) == 0) ||
				     (memcmp_P(buf,PSTR("\xF9\x83\xEF\x31"),4) == 0) ) {
#endif
						state =0;
	
						if (datapos == 3){
							//pic finished -> exit
							state = 100;
						}
					}
					break;
			}
		}
		//preview image #i has been grabbed.
	}	
	//disable uart:
	mca25_uart_disabled=1;
}


/*======================================================================
| configure the camera
| (mca25_init() has to be called first !)
`======================================================================*/
void mca25_configure(){
	unsigned char state=0;
	unsigned char buf[MCA25_COMM_BUFFER_LEN];
	
	//enable uart:
	mca25_uart_disabled=0;
	
	while (state != 100){
		mca25_read_mux_packet(buf); //read MUX packet
		switch (state){
			case 0:
				mca25_pgm_send(MCA25_CONFIG_640x480);
				state = 1;
				break;
			case 1:
				// wait for cam ACK:
				// [F9 83 EF 07 A0 00 03 C7 F9
				if (memcmp_P(buf,PSTR("\xF9\x83\xEF\x07\xA0\x00\x03\xC7\xF9"),9) == 0){
					// request camera info:
					// [F9 81 EF 2F 83 00 17 42 00 14 78 2D 62 74 2F 63 
					//  61 6D 65 72 61 2D 69 6E 66 6F 00 90 F9]
					printf_P(PSTR("\xF9\x81\xEF\x2F\x83"));
					uart_putchar('\x00');
					printf_P(PSTR("\x17\x42"));
					uart_putchar('\x00');
					printf_P(PSTR("\x14\x78\x2D\x62\x74\x2F\x63\x61\x6D\x65\x72\x61"));  
					printf_P(PSTR("\x2D\x69\x6E\x66\x6F"));  
					uart_putchar('\x00');
					printf_P(PSTR("\x90\xF9"));
					
					state = 2;
				}
				break;
			case 2:
				// ignore camera info ...
				// -> wait for last info packet:
				// [F9 83 EF 33 79 65 72 3D 22 31 30 22 2F 3E 3C 2F 
				//  63 61 6D 65 72 61 2D 69 6E 66 6F 3E 00 E4 F9]
				if (memcmp_P(buf,PSTR("\xF9\x83\xEF\x33\x79\x65\x72\x3D\x22\x31\x30\x22"
											 "\x2F\x3E\x3C\x2F\x63\x61\x6D\x65\x72\x61\x2D\x69"
											 "\x6E\x66\x6F\x3E\x00\xE4\xF9"),31)){
						//CAM READY !
						state = 100;
				}
				break;
		}
		
	}
	//disable uart:
	mca25_uart_disabled=1;
}


/*======================================================================
| initialise the camera
| this has to be done at first, it activates the mux mode also
`======================================================================*/
void mca25_init(void){
	unsigned char state=0;
	unsigned char buf[MCA25_COMM_BUFFER_LEN];
	
	//enable uart:
	mca25_uart_disabled=0;
	
	MCA25_RESET_PORT_DIR |=  (1<<MCA25_RESET_PIN); //make camreset pin output
	mca25_reset_cam();
	
	printf_P(PSTR("CAM_RUNNING\n"));
	
	while (state != 100){
		if (state<10)
			mca25_read_at_command(buf); //read AT command
		else{
			mca25_read_mux_packet(buf); //read MUX packet
		  //printf_P(PSTR("read[%s]\n",buf);
		}
		
		switch (state){
			case 0:
				//we have to wait for AT&F:
				if (memcmp_P(buf,PSTR("AT&F"),4) == 0){
					//puts("AT&F");
					mca25_send_ok();
					state = 1;
				}
				break;
				
			case 1:
				//wait for AT+IPR
				if (memcmp_P(buf,PSTR("AT+IPR=?"),8) == 0){
					printf_P(PSTR("+IPR: (),(1200,2400,4800,9600,19200,38400,57600,460800)\r\n\r\nOK\r\n"));
					state = 2;
				}
				break;
			
			case 2:
				//wait for AT+IPR SET command
				if (memcmp_P(buf,PSTR("AT+IPR=460800"),13) == 0){
					printf_P(PSTR("\r\nOK\r\n")); //bubug: here only 1 \r befor OK!
					//set higher baudrate:
					mca25_set_460800baud();
					//wait ...
					state = 3;
				}
				break;

			case 3:
				//wait for mux info req
				if (memcmp_P(buf,PSTR("AT+CMUX=?"),9) == 0){
					printf_P(PSTR("\r\r\n+CMUX: (0),(0),(1-7),(31),(10),(3),(30),(10),(1-7)\r"));
					state = 4;
				}
				break;

			case 4:
				//wait for mux enable request
				if (memcmp_P(buf,PSTR("AT+CMUX=0,0,7,31"),16) == 0){
					mca25_send_ok();
					state = 10;
				}
				break;

				case 10:
					// wait for mux ch0 request:
					// [F9 03 3F 01 1C F9]
					if (memcmp_P(buf,PSTR("\xF9\x03\x3F\x01\x1C\xF9"),6) == 0){
						// send mux ch0 ack/open packet:
						// [F9 03 73  01 D7 F9]
						printf_P(PSTR("\xF9\x03\x73\x01\xD7\xF9"));
					  state = 11;
					}
					break;

				case 11:
					// wait for mux ch3 request:
					// [F9 23 3F 01 C9 F9]
					if (memcmp_P(buf,PSTR("\xF9\x23\x3F\x01\xC9\xF9"),6) == 0){
						// send mux ch3 ack/open packet:
						// [F9 23 73 01 02 F9]
						printf_P(PSTR("\xF9\x23\x73\x01\x02\xF9"));
					  state = 12;
					}
					break;

				case 12:
					// wait for config mux ch0 request:
					// [F9 03 EF 09 E3 05 23 8D FB F9]
					if (memcmp_P(buf,PSTR("\xF9\x03\xEF\x09\xE3\x05\x23\x8D\xFB\xF9"),10) == 0){
						// send mux ch0 config ack/open packet:
						// [F9 01 EF 0B E3 07 23 0C 01 79 F9]
						printf_P(PSTR("\xF9\x01\xEF\x0B\xE3\x07\x23\x0C\x01\x79\xF9"));
					  state = 13;
					}
					break;

				case 13:
					// wait for config mux ch3 request:
					// [F9 03 EF 09 E1 07 23 0C 01 FB F9]
					if (memcmp_P(buf,PSTR("\xF9\x03\xEF\x09\xE1\x07\x23\x0C\x01\xFB\xF9"),11) == 0){
						// send mux ch3 config ack/open packet:
						// [F9 01 EF 09 E1 05 23 8D 9A F9]
						printf_P(PSTR("\xF9\x01\xEF\x09\xE1\x05\x23\x8D\x9A\xF9"));
					  state = 14;
					}
					break;

				case 14:
					// wait for AT*EACS.17.1.r:
					// [F9 23 EF 1B 41 54 2A 45 41 43 53 3D 31 37 2C 31 0D D1 F9]
					//if (memcmp_P(buf,PSTR("\xF9\x23\xEF\x1BAT*EACS=17,1\r\xD1\xF9",19) == 0){
						if (memcmp_P(buf,PSTR("\xF9\x23\xEF\x1B\x41\x54\x2A\x45\x41\x43"
													 "\x53\x3D\x31\x37\x2C\x31\x0D\xD1\xF9"),19) == 0){
						// send mux "\r\nOK\r\n" packet:
						// [F9 21 EF 0D 0D 0A 4F 4B 0D 0A 48  F9]
						printf_P(PSTR("\xF9\x21\xEF\x0D\x0D\x0A\x4F\x4B\x0D\x0A\x48\xF9"));
					  state = 15;
					}
					break;
					
				case 15:
					// wait for AT+CSCC=1,199\r5 peripheral AUTH req:
					// [F9 23 EF 1D 41 54 2B 43 53 43 43 3D 31 2C 31 39 39 0D 35 F9]
					if (memcmp_P(buf,PSTR("\xF9\x23\xEF\x1D\x41\x54\x2B\x43\x53\x43\x43"
												 "\x3D\x31\x2C\x31\x39\x39\x0D\x35\xF9"),20) == 0){
						// send response token:
						//DONT// [F9 21 EF 1D 41 54 2B 43 53 43 43 3D 31 2C 31 39 39 0D 54 F9]
						// [F9 21 EF 1B 0D 0A 2B 43 53 43 43 3A 20 45 33 0D 0A B0 F9 ]
						//printf_P(PSTR("\xF9\x21\xEF\x1D\x41\x54\x2B\x43\x53\x43"
						//			 "\x43\x3D\x31\x2C\x31\x39\x39\x0D\x54\xF9"); 
						printf_P(PSTR("\xF9\x21\xEF\x1B\x0D\x0A\x2B\x43\x53\x43"
									 "\x43\x3A\x20\x45\x33\x0D\x0A\xB0\xF9"));
									 
						//append ok:
						printf_P(PSTR("\xF9\x21\xEF\x0D\x0D\x0A\x4F\x4B\x0D\x0A\x48\xF9"));
					  state = 16;
					}
					break;
					
				case 16:
					// wait for AT+CSCC=2,199.B9\r AUTH2 req:
					// AT+CSCC.2.199.B9.r|
					// [F9 23 EF 23 41 54 2B 43 53 43 43 3D 32 2C 31 39 39 2C 42 39 0D FB F9]
					if (memcmp_P(buf,PSTR("\xF9\x23\xEF\x23\x41\x54\x2B\x43\x53\x43\x43"
												 "\x3D\x32\x2C\x31\x39\x39\x2C\x42\x39\x0D\xFB\xF9"),23) == 0){
						// send response token: (OK)
						// [F9 21 EF 0D 0D 0A 4F 4B 0D 0A 48  F9]
						printf_P(PSTR("\xF9\x21\xEF\x0D\x0D\x0A\x4F\x4B\x0D\x0A\x48\xF9"));
						
						// now request data mux channel (ch1):
						// [F9 81 3F 01 AB F9]
						printf_P(PSTR("\xF9\x81\x3F\x01\xAB\xF9"));
					  state = 17;
					}
					break;
					
				case 17:
					// wait for mux ch1 ack:
					// [F9 81 73 01 60 F9]
					if (memcmp_P(buf,PSTR("\xF9\x81\x73\x01\x60\xF9"),6) == 0){
						// channel1 is now open!
					  state = 18;
					}
					break;
					
				case 18:
					// wait for ch1 mux config:
					// [F9 03 EF 09 E3 05 83 8D FB F9]
					if (memcmp_P(buf,PSTR("\xF9\x03\xEF\x09\xE3\x05\x83\x8D\xFB\xF9"),10) == 0){
						// send config response:
						// [F9 01 EF 09 E1 05 83 8D 9A F9]
						printf_P(PSTR("\xF9\x01\xEF\x09\xE1\x05\x83\x8D\x9A\xF9"));
						
						// now configure cam mode:
						// [ F9 81 EF 37 80 00 1A 10 00 01 00 46 00 13 E3 3D
						//   95 45 83 74 4A D7 9E C5 C1 6B E3 1E DE 8E 61 82 F9 ]
						// F9 81 EF 37 			= mux header
						// 80 00 1A 10 00 	= ???
						// 01 00 						= (256-6)Byte data, then wait for ACK
						// 46  00 13 E3 3D 95 45 83 74 4A D7 9E C5 C1 6B E3 1E DE 8E 61 ???
						printf_P(PSTR("\xF9\x81\xEF\x37\x80"));
						uart_putchar('\x00');
						printf_P(PSTR("\x1A\x10"));
						uart_putchar('\x00');
						
						//buffsize
						printf_P(PSTR("\x02"));
						uart_putchar('\x00');
						
						printf_P(PSTR("\x46"));
						uart_putchar('\x00');
						printf_P(PSTR("\x13\xE3\x3D\x95\x45\x83\x74\x4A\xD7"));
						printf_P(PSTR("\x9E\xC5\xC1\x6B\xE3\x1E\xDE\x8E\x61\x82\xF9"));

						printf_P(PSTR("\xF9\x21\xEF\x0D\x0D\x0A\x4F\x4B\x0D\x0A\x48\xF9"));	  
						
						
						state = 19;
					}
					break;
					
				case 19:
					// cam should now accept our settings:
					// [F9 83 EF 3F A0 00 1F 10 00 20 00 CB 00 00 00 01 4A 00
					//  13 E3 3D 95 45 83 74 4A D7 9E C5 C1 6B E3 1E DE 8E ED F9
					if (memcmp_P(buf,PSTR("\xF9\x83\xEF\x3F\xA0\x00\x1F\x10\x00\x20\x00\xCB\x00"
						             "\x00\x00\x01\x4A\x00\x13\xE3\x3D\x95\x45\x83\x74\x4A"
												 "\xD7\x9E\xC5\xC1\x6B\xE3\x1E\xDE\x8E\xED\xF9"),37) == 0){
						state = 100; //-> exit init loop.
					}
					break;			

			default:
				break;
		}
	}
	//disable uart:
	mca25_uart_disabled=1;
}


/*======================================================================
| resets the camera (hw reset !)
`======================================================================*/
void mca25_reset_cam(){
	unsigned char j;
	MCA25_RESET_LO();
	
	//wait some time:
	unsigned long i;
	for (j=0; j<20; j++){
		i = 0;
		while (i < 60000 * 20) i++;
	}
	
	MCA25_RESET_HI();
}



/************************** HELPER ***********************************/
void mca25_send_data_ack(){
	printf_P(PSTR("\xF9\x81\xEF\x07\x83"));
	uart_putchar('\x00');
	printf_P(PSTR("\x03\xA6\xF9"));
}

void mca25_set_460800baud(){
	unsigned long i = 0;
	while (i < 60000 * 20) i++;
	UBRR=(F_CPU / (460800 * 16L) - 1);
}

void mca25_send_ok(){
	puts("\r\r\nOK\r"); //puts adds a newline !!
}

void mca25_read_mux_packet(unsigned char *buffer){
	unsigned int cnt;
	for(cnt=0;cnt < MCA25_COMM_BUFFER_LEN - 1;cnt++){
		MCA25_STATUS_LED_ON();
		while (!(USR & (1<<RXC))){}
		buffer[cnt] = UDR;
		MCA25_STATUS_LED_OFF();
		if (cnt>0 && buffer[cnt] == 0xF9){				//'\xF9'){
			buffer[cnt+1] = '\0';
			break; //we have finished out read.
		}
	}
	return;
}

void mca25_read_at_command(unsigned char *buffer){
	unsigned int cnt;
	for(cnt=0;cnt<MCA25_COMM_BUFFER_LEN;cnt++){
		MCA25_STATUS_LED_ON();
		while (!(USR & (1<<RXC))){}
		buffer[cnt] = UDR;
		MCA25_STATUS_LED_OFF();
		if (buffer[cnt] == '\r' || buffer[cnt] == '\n'){
			buffer[cnt] = '\0';
			break; //we have finished out read.
		}
	}
	return;
}


void mca25_pgm_send(PGM_P pointer){
	unsigned char valid=0;
	char old[4];
	
	for(;;){
		old[3] = old[2];
		old[2] = old[1];
		old[1] = old[0];
		old[0] = pgm_read_byte(pointer++);
		
		//if mux packet is finished wait some time
		//cam does not like rs232 activity while starting image grab
		/*if (old[0] == 0xF9 && old[1] == 0xF9){ //wait after the first n-1 packets
			for (int z=0; z<30000; z++){
				nop();nop();nop();nop();nop();nop();nop();nop();
			}
			for (int z=0; z<30000; z++){
				nop();nop();nop();nop();nop();nop();nop();nop();
			}
		}*/

		if ( old[3] == '%' && 
				 old[2] == 'E' &&
				 old[1] == 'N' &&
				 old[0] == 'D' ){
			//we have read the whole packet -> exit;
			break;
		}else{
			if (valid>=3)
				uart_putchar(old[3]);
			else
				valid++;
			/*if (in == 0xF9){	
				//wait some time
				int a = 0;
				while (a < 1000){a++;}
			}*/
		}
	}
}

//pgm compare routine:
int memcmp_P(unsigned char *buf, PGM_P pointer, unsigned int len){
        while(len--)
		if( *buf++ != pgm_read_byte(pointer++))
			return 1;
	return 0;
}



/******************************* CONSTANTS **********************************/
//some constants (command sequence)
PROGMEM char MCA25_START_JPG[] = {
0xF9,0x81,0xEF,0x3F,0x83,0x00,0x82,0x71,0x00,0x58,0x3C,0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,0x69,0x6E,0x67,0x2D,0x63,0x6F,
0x6D,0x6D,0x61,0x6E,0x64,0x20,0x76,0x65,0x72,0x73,0x69,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x6F,0x6E,0x3D,0x22,0x31,0x2E,0x30,0x22,0x20,0x74,0x61,0x6B,0x65,0x2D,0x70,0x69,0x63,0x3D,0x22,0x4E,
0x4F,0x22,0x20,0x73,0x65,0x6E,0x64,0x2D,0x70,0x69,0x78,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x65,0x6C,0x2D,0x73,0x69,0x7A,0x65,0x3D,0x22,0x36,0x34,0x30,0x2A,0x34,0x38,0x30,0x22,0x20,0x7A,0x6F,
0x6F,0x6D,0x3D,0x22,0x31,0x30,0x22,0x2F,0x3E,0x42,0x00,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x21,0x78,0x2D,0x62,0x74,0x2F,0x69,0x6D,0x61,0x67,0x69,0x6E,0x67,0x2D,0x6D,0x6F,0x6E,0x69,0x74,0x6F,
0x72,0x69,0x6E,0x67,0x2D,0x69,0x6D,0x61,0x67,0x65,0x00,0x8C,0xF9,
0xF9,0x81,0xEF,0x0D,0x4C,0x00,0x06,0x06,0x01,0x80,0x4B,0xF9,
'%','E','N','D'};


PROGMEM char MCA25_START_CAPTURING_1[] = {
0xF9,0x81,0xEF,0x3F,0x83,0x00,0x69,0x71,0x00,0x3F,0x3C,0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,0x69,
0x6E,0x67,0x2D,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x76,0x65,0x72,0x73,0x69,0x8C,0xF9,
'%','E','N','D'};

PROGMEM char MCA25_START_CAPTURING_2[] = {
0xF9,0x81,0xEF,0x3F,0x6F,0x6E,0x3D,0x22,0x31,0x2E,0x30,0x22,0x20,0x74,0x61,0x6B,0x65,0x2D,0x70,
0x69,0x63,0x3D,0x22,0x59,0x45,0x53,0x22,0x20,0x7A,0x6F,0x6F,0x6D,0x3D,0x22,0x31,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x30,0x22,0x2F,0x3E,0x42,0x00,0x21,0x78,0x2D,0x62,0x74,0x2F,0x69,0x6D,0x61,
0x67,0x69,0x6E,0x67,0x2D,0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,0x69,0x6E,0x67,0x2D,0x8C,0xF9,
'%','E','N','D'};

PROGMEM char MCA25_START_CAPTURING_3[] = {
0xF9,0x81,0xEF,0x19,0x69,0x6D,0x61,0x67,0x65,0x00,0x4C,0x00,0x06,0x06,0x01,0x80,0x50,0xF9,'%','E','N','D'};

PROGMEM char MCA25_CONFIG_640x480[] = {
0xF9,0x81,0xEF,0x3F,0x82,0x01,0x3B,0x01,0x00,0x03,0x49,0x01,0x35,0x3C,0x63,0x61,0x6D,0x65,
0x72,0x61,0x2D,0x73,0x65,0x74,0x74,0x69,0x6E,0x67,0x73,0x20,0x76,0x65,0x72,0x73,0x69,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x6F,0x6E,0x3D,0x22,0x31,0x2E,0x30,0x22,0x20,0x77,0x68,0x69,0x74,0x65,
0x2D,0x62,0x61,0x6C,0x61,0x6E,0x63,0x65,0x3D,0x22,0x4F,0x46,0x46,0x22,0x20,0x63,0x6F,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x6C,0x6F,0x72,0x2D,0x63,0x6F,0x6D,0x70,0x65,0x6E,0x73,0x61,0x74,0x69,
0x6F,0x6E,0x3D,0x22,0x31,0x33,0x22,0x20,0x66,0x75,0x6E,0x2D,0x6C,0x61,0x79,0x65,0x72,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x3D,0x22,0x30,0x22,0x3E,0x3C,0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,0x69,
0x6E,0x67,0x2D,0x66,0x6F,0x72,0x6D,0x61,0x74,0x20,0x65,0x6E,0x63,0x6F,0x64,0x69,0x6E,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x67,0x3D,0x22,0x45,0x42,0x4D,0x50,0x22,0x20,0x70,0x69,0x78,0x65,0x6C,
0x2D,0x73,0x69,0x7A,0x65,0x3D,0x22,0x38,0x30,0x2A,0x36,0x30,0x22,0x20,0x63,0x6F,0x6C,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x6F,0x72,0x2D,0x64,0x65,0x70,0x74,0x68,0x3D,0x22,0x38,0x22,0x2F,0x3E,
0x0D,0x0A,0x3C,0x74,0x68,0x75,0x6D,0x62,0x6E,0x61,0x69,0x6C,0x2D,0x66,0x6F,0x72,0x6D,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x61,0x74,0x20,0x65,0x6E,0x63,0x6F,0x64,0x69,0x6E,0x67,0x3D,0x22,0x45,
0x42,0x4D,0x50,0x22,0x20,0x70,0x69,0x78,0x65,0x6C,0x2D,0x73,0x69,0x7A,0x65,0x3D,0x22,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x31,0x30,0x31,0x2A,0x38,0x30,0x22,0x20,0x63,0x6F,0x6C,0x6F,0x72,0x2D,
0x64,0x65,0x70,0x74,0x68,0x3D,0x22,0x38,0x22,0x2F,0x3E,0x0D,0x0A,0x3C,0x6E,0x61,0x74,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x69,0x76,0x65,0x2D,0x66,0x6F,0x72,0x6D,0x61,0x74,0x20,0x65,0x6E,0x63,
0x6F,0x64,0x69,0x6E,0x67,0x3D,0x22,0x22,0x20,0x70,0x69,0x78,0x65,0x6C,0x2D,0x73,0x69,0x8C,0xF9,
0xF9,0x81,0xEF,0x3F,0x7A,0x65,0x3D,0x22,0x36,0x34,0x30,0x2A,0x34,0x38,0x30,0x22,0x2F,0x3E,
0x0D,0x0A,0x3C,0x2F,0x63,0x61,0x6D,0x65,0x72,0x61,0x2D,0x73,0x65,0x74,0x74,0x69,0x6E,0x8C,0xF9,
0xF9,0x81,0xEF,0x0B,0x67,0x73,0x3E,0x0D,0x0A,0xAF,0xF9,'%','E','N','D'};