WatchMe Robot

     Eredményes nap volt a mai. Sikerült a kamerát összekötni az FPGA-val, de úgy, hogy a képet egyből az FPGA-ba mentettem. Valamivel korábban sikerült elkészíteni egy első verziót, de az olyan ocsmányul nézett ki (már ami a forráskódot illeti), hogy inkább ujra nekifogtam. Úgy érzem, sikerült egy teljesen letisztult formát összehozni.

#include "xparameters.h"

#include "stdio.h"

#include "xutil.h"

#include "xuartlite.h"

#include "xuartlite_l.h"

#include "xintc_l.h"

#include "xgpio.h"

//====================================================
// Definitions
//====================================================

#define BAUDRATE 38400
#define USE_PARITY 0
#define PARITY_ODD 1
#define DATABITS 8

//====================================================
// GLOBAL VARIABLES
//====================================================
Xuint8 sdata;
XGpio leds;
XUartLite Second_Rs;
Xuint8 filesize[9];
Xuint8 KH, KL;
Xuint8 flag;
Xuint8 flag2;
Xuint8 what;
Xuint8 framecounter=0;
int counter=0;
int i;
u8* imagedata=(u8*)XPAR_MICRON_RAM_MEM0_BASEADDR;

//====================================================
// INTERRUPT HANDLER FUNCTION
//====================================================

void uart_interrupt_handler(void* addr_p)
{ 
    Xuint8 empty;
            empty = XUartLite_IsReceiveEmpty(XPAR_RS232_SECOND_BASEADDR);
            if (empty == FALSE )
            {
                sdata = XUartLite_RecvByte(XPAR_RS232_SECOND_BASEADDR);
                //XGpio_DiscreteWrite(&leds, 1, sdata);
                //xil_printf("%x",sdata);
                if(flag == 1 )
                {
                    ////xil_printf("%c",sdata);
                    
                    filesize[counter]=sdata;
                    
                    counter=counter+1;
                    
                    if (counter == 9)
                    {
                        flag = 0;
                        counter = 0;
                    }
                }

                if(flag==2)
                {
                    imagedata[counter]=sdata;
                    if(sdata == 0xD9)
                        if(imagedata[counter-1] == 0xFF )
                            flag = 0;
                    counter=counter+1;
                }
            }
}

//====================================================
// Delay functions, not yet tested
//====================================================

void usleep(unsigned int delay)
{
unsigned int j, k; 

for(k=0; k<delay*10; k++)
   for(j=0; j<26; j++);
}

void sleep(unsigned int delay)
{
unsigned int j, k; 

for(k=0; k<delay; k++)
   for(j=0; j<100; j++)
        usleep(1);
}

//====================================================
// Clear the Micron Ram Memory
//====================================================
void ClearMemory()
{
    for(i=0;i<1000000;i++)
    imagedata[i]=0;
}


//====================================================
// Interrupt, and RS232_Second initialization
//====================================================

void initialize()
{

    XUartLite_Config UART_Configuration;
    UART_Configuration.DeviceId = XPAR_RS232_SECOND_DEVICE_ID;
    UART_Configuration.RegBaseAddr = XPAR_RS232_SECOND_BASEADDR;
    UART_Configuration.BaudRate = BAUDRATE;
    UART_Configuration.UseParity = USE_PARITY;
    UART_Configuration.ParityOdd = PARITY_ODD;
    UART_Configuration.DataBits = DATABITS; 

     //UART init:
    XUartLite_CfgInitialize (&Second_Rs, &UART_Configuration, XPAR_RS232_SECOND_BASEADDR) ;

    //xil_printf("Second UART configured to send any data.\n");
    //-----------------


        XGpio_Initialize(&leds, XPAR_LEDS_8BIT_DEVICE_ID);
        XGpio_SetDataDirection(&leds, 1,0x0);  
        //XGpio_DiscreteWrite(&leds, 1, 1);
        
        XIntc_RegisterHandler(XPAR_XPS_INTC_0_BASEADDR,
                                     XPAR_INTC_0_UARTLITE_2_VEC_ID,
                                     (XInterruptHandler)uart_interrupt_handler,
                                     (void *)XPAR_RS232_SECOND_BASEADDR);    
        //XGpio_DiscreteWrite(&leds, 1, 2);
        
        XIntc_MasterEnable(XPAR_XPS_INTC_0_BASEADDR);
        //XGpio_DiscreteWrite(&leds, 1, 3);
        
        XIntc_EnableIntr(XPAR_XPS_INTC_0_BASEADDR, 0x1);
        //XGpio_DiscreteWrite(&leds, 1, 4);
        
        XIntc_EnableIntr(XPAR_XPS_INTC_0_BASEADDR, XPAR_RS232_SECOND_INTERRUPT_MASK);
        //XGpio_DiscreteWrite(&leds, 1, 5);
        
        XUartLite_Initialize(&Second_Rs,XPAR_RS232_SECOND_DEVICE_ID);
        //XGpio_DiscreteWrite(&leds, 1, 6);
        
        XUartLite_SetRecvHandler(&Second_Rs,
                                         (XUartLite_Handler)  uart_interrupt_handler,  
                                         (void *)XPAR_RS232_SECOND_BASEADDR);  
        //XGpio_DiscreteWrite(&leds, 1, 7);
        
        XUartLite_EnableInterrupt(&Second_Rs);  
        //XGpio_DiscreteWrite(&leds, 1, 8);
        
        microblaze_enable_interrupts();
        //XGpio_DiscreteWrite(&leds, 1, 9);
}
//====================================================
// Sending one bit to the Camera
//====================================================

void Kuldes()
{
        while(XUartLite_IsSending(&Second_Rs));
                XUartLite_Send(&Second_Rs, &what, 1);
}

//====================================================
// Reset the camera. Delay 2-3 seconds after completing
//====================================================

void SendResetCmd()
{
        what=0x56;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x26;
        Kuldes();
        what=0x00;
        Kuldes();
        sleep(500);
}

void ImageSize_160_120()
{
//56 00 31 05 04 01 00 19 22
        what=0x56;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x31;
        Kuldes();
        what=0x05;
        Kuldes();
        what=0x04;
        Kuldes();
        what=0x01;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x19;
        Kuldes();
        what=0x22;
        Kuldes();
        SendResetCmd();
}
//====================================================
// First step to take a picture
//====================================================
void SendTakePhotoCmd()
{
        what=0x56;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x36;
        Kuldes();
        what=0x01;
        Kuldes();        
        what=0x00;
        Kuldes();
        sleep(10);
}
//====================================================
// Second step. Get the FileSize
//====================================================
void ReadJpegFileSize()
{
        flag = 1;
        what=0x56;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x34;
        Kuldes();
        what=0x01;
        Kuldes();        
        what=0x00;
        Kuldes();
        sleep(10);
}
//====================================================
// Third step. If we have the size, we can get the Image
//====================================================

//Read data
void SendReadDataCmd()
{
        flag=2;
        what=0x56;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x32;
        Kuldes();
        what=0x0C;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x0A;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x00;//MH
        Kuldes();
        what=0x00;//ML
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x00;
        Kuldes();
        what=KH;
        Kuldes();
        what=KL;
        Kuldes();
        what=0x00;
        Kuldes();
        what=0x0A;
        Kuldes();        
}

int main()
{
    ClearMemory();
    initialize();
    //xil_printf("Initialization Complete.\n");
    //xil_printf("Reset Command Sending.\n");
    SendResetCmd();
    //xil_printf("\nImage size Changed to 160*120\n");
    ImageSize_160_120();
    //xil_printf("Take Photo Command Sending.\n");
    
    while(framecounter<100)//get 10 images
    {
        SendTakePhotoCmd();
        //xil_printf("Read Jpeg FileSize Command Sending.\n");
        ReadJpegFileSize();
        while(flag==1);
            //xil_printf("\n%d\n",counter);
        KH = filesize[7];
        KL = filesize[8];
        //xil_printf("KH = %d \n KL = %d\n",KH,KL);
        //xil_printf("Read Data Command Sending.\n");
        SendReadDataCmd();

        while(flag==2);
        //xil_printf("\n\n-----------\n\n");
        //for (i=0;i<counter;i++)
            //xil_printf("%c",imagedata[i]);
        //xil_printf("\n\n-----------\n\n");
        //for (i=0;i<counter;i++)
            //xil_printf("%d ",imagedata[i]);
        framecounter=framecounter+1;
        xil_printf("Frame %d taken.\n",framecounter);
        counter=0;
    }
    while(1);
} 

     A kamerával a kapcsolatot kis kódsorokon keresztül valósíthatjuk meg, ilyen az 56 00 26 00, ami a kamera ujraindítását vonja maga után, vagy például a 56 00 32 0C 00 0A 00 00 MH ML 00 00 KH KL 00 04, ami a képletöltés elindításáért felelős.

    Valamikor a délután folyamán sikerült egy első verzió a programból, mint azt már említettem, de azt még nem konstatálta az agyam, hogy JPEG fájlformátummal dolgozom. Többszöri ujrapróbálás után sem sikerült megérteni, hogy az illető kiírt kód mit is jelenthet. Első probléma, hogy ha nekem egy 160*120-as képem van, akkor miért gyárt le nekem háromezer akárhány pixelt. Sehogy sem talált. Akkor megpróbáltam Matlabba bemásolni, s onnan kihozni valamit, persze ott is minimális sikerrel.

     Aztán valahogy rájöttem, hogy (ha már a neve is az, hogy JPEG color camera, akkor ) a képek is JPEG formátumban vannak. Erről még nem döntöttem el, hogy jó-e vagy sem. Nem igazán látom át a formátum lelkivilágát. Nekem valahogy az kellene, hogy adott x-y koordinátán mennyi az R, a G meg a B színkomponens.

     Egy kép a programról működés közben :







     Illetve mégegy kód a JPEG képem kódjáról (amit még ezidáig nem tudtam megjeleníteni).







     Az ötlet megvan, hogy mit is kellene vele csinálni, hogy kép legyen belőle, viszont a soros kommunikáció nehézségei miatt inkább még egy kicsit hanyagolom. Valahogy úgy kellene, hogy írni egy soros klienst, ahol egy byte-tömbbe belementeni a bejövő értékeket, majd elmenteni egy "kicsikutya.jpg" néven. Ebből már csak a soros kliens hiányzik. Meg a byte-tömb. Viszont asszem ez utóbbit én is meg tudom oldani.